feat: allow for separate vk render on-chain (#697)

Co-authored-by: dante <45801863+alexander-camuto@users.noreply.github.com>

.github/workflows/large-tests.yml

@@ -6,7 +6,7 @@ on:
         description: "Test scenario tags"
 jobs:
   large-tests:
-    runs-on: self-hosted
+    runs-on: kaiju
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -23,6 +23,6 @@ jobs:
       - name: Self Attention KZG prove and verify large tests
         run: cargo test --release --verbose tests::large_kzg_prove_and_verify_::large_tests_0_expects -- --include-ignored
       - name: mobilenet Mock
-        run: cargo test --release --verbose tests::large_mock_::large_tests_2_expects -- --include-ignored
+        run: cargo test --release --verbose tests::large_mock_::large_tests_3_expects -- --include-ignored
       - name: mobilenet KZG prove and verify large tests
-        run: cargo test --release --verbose tests::large_kzg_prove_and_verify_::large_tests_2_expects -- --include-ignored
+        run: cargo test --release --verbose tests::large_kzg_prove_and_verify_::large_tests_3_expects -- --include-ignored

.github/workflows/rust.yml

@@ -313,6 +313,8 @@ jobs:
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
         run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
+      - name: KZG prove and verify tests (EVM + VK rendered seperately)
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_render_seperately_ --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg all)
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_kzg_all_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg inputs)
@@ -643,14 +645,13 @@ jobs:
       #     # now dump the contents of the file into a file called kaggle.json
       #     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
       - 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: All notebooks
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::run_notebook_ --test-threads 1
       - name: Tictactoe tutorials
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --test-threads 1
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --no-capture
       # - name: Postgres tutorials
       #   run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --test-threads 1
-     

Cargo.lock

@@ -1058,16 +1058,6 @@ dependencies = [
  "itertools 0.10.5",
 ]
 
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.3"
@@ -1378,7 +1368,7 @@ checksum = "68b0cf012f1230e43cd00ebb729c6bb58707ecfa8ad08b52ef3a4ccd2697fc30"
 [[package]]
 name = "ecc"
 version = "0.1.0"
-source = "git+https://github.com/zkonduit/halo2wrong?branch=ac/chunked-mv-lookup#c1d7551c82953829caee30fe218759b0d2657d26"
+source = "git+https://github.com/zkonduit/halo2wrong?branch=ac/chunked-mv-lookup#b43ebe30e84825d0d004fa27803d99c4187d419f"
 dependencies = [
  "integer",
  "num-bigint",
@@ -1862,7 +1852,7 @@ dependencies = [
  "halo2_gadgets",
  "halo2_proofs",
  "halo2_solidity_verifier",
- "halo2curves 0.1.0",
+ "halo2curves 0.6.0",
  "hex",
  "indicatif",
  "instant",
@@ -2253,7 +2243,7 @@ dependencies = [
 [[package]]
 name = "halo2_gadgets"
 version = "0.2.0"
-source = "git+https://github.com/zkonduit/halo2?branch=ac/lookup-modularity#57b9123835aa7d8482f4182ede3e8f4b0aea5c0a"
+source = "git+https://github.com/zkonduit/halo2?branch=main#6a2b9ada9804807ddba03bbadaf6e63822cec275"
 dependencies = [
  "arrayvec 0.7.4",
  "bitvec 1.0.1",
@@ -2269,14 +2259,14 @@ dependencies = [
 
 [[package]]
 name = "halo2_proofs"
-version = "0.2.0"
-source = "git+https://github.com/zkonduit/halo2?branch=ac/lookup-modularity#57b9123835aa7d8482f4182ede3e8f4b0aea5c0a"
+version = "0.3.0"
+source = "git+https://github.com/zkonduit/halo2?branch=main#6a2b9ada9804807ddba03bbadaf6e63822cec275"
 dependencies = [
  "blake2b_simd",
  "env_logger",
  "ff",
  "group",
- "halo2curves 0.1.0",
+ "halo2curves 0.6.0",
  "icicle",
  "log",
  "maybe-rayon",
@@ -2292,7 +2282,7 @@ dependencies = [
 [[package]]
 name = "halo2_solidity_verifier"
 version = "0.1.0"
-source = "git+https://github.com/alexander-camuto/halo2-solidity-verifier?branch=ac/lookup-modularity#cf9a3128bb583680dd4c418defd8d37bd8e5c3f1"
+source = "git+https://github.com/alexander-camuto/halo2-solidity-verifier?branch=main#eb04be1f7d005e5b9dd3ff41efa30aeb5e0c34a3"
 dependencies = [
  "askama",
  "blake2b_simd",
@@ -2319,8 +2309,6 @@ dependencies = [
  "paste",
  "rand 0.8.5",
  "rand_core 0.6.4",
- "serde",
- "serde_arrays",
  "static_assertions",
  "subtle",
 ]
@@ -2343,10 +2331,35 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "halo2curves"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3675880dc0cc7cd468943266297198a28f88210ba60ca5e0e04d121edf86b46"
+dependencies = [
+ "blake2b_simd",
+ "ff",
+ "group",
+ "hex",
+ "lazy_static",
+ "num-bigint",
+ "num-traits",
+ "pairing",
+ "pasta_curves",
+ "paste",
+ "rand 0.8.5",
+ "rand_core 0.6.4",
+ "rayon",
+ "serde",
+ "serde_arrays",
+ "static_assertions",
+ "subtle",
+]
+
 [[package]]
 name = "halo2wrong"
 version = "0.1.0"
-source = "git+https://github.com/zkonduit/halo2wrong?branch=ac/chunked-mv-lookup#c1d7551c82953829caee30fe218759b0d2657d26"
+source = "git+https://github.com/zkonduit/halo2wrong?branch=ac/chunked-mv-lookup#b43ebe30e84825d0d004fa27803d99c4187d419f"
 dependencies = [
  "halo2_proofs",
  "num-bigint",
@@ -2423,6 +2436,9 @@ name = "hex"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "hex-literal"
@@ -2696,7 +2712,7 @@ dependencies = [
 [[package]]
 name = "integer"
 version = "0.1.0"
-source = "git+https://github.com/zkonduit/halo2wrong?branch=ac/chunked-mv-lookup#c1d7551c82953829caee30fe218759b0d2657d26"
+source = "git+https://github.com/zkonduit/halo2wrong?branch=ac/chunked-mv-lookup#b43ebe30e84825d0d004fa27803d99c4187d419f"
 dependencies = [
  "maingate",
  "num-bigint",
@@ -2941,7 +2957,7 @@ checksum = "b06a4cde4c0f271a446782e3eff8de789548ce57dbc8eca9292c27f4a42004b4"
 [[package]]
 name = "maingate"
 version = "0.1.0"
-source = "git+https://github.com/zkonduit/halo2wrong?branch=ac/chunked-mv-lookup#c1d7551c82953829caee30fe218759b0d2657d26"
+source = "git+https://github.com/zkonduit/halo2wrong?branch=ac/chunked-mv-lookup#b43ebe30e84825d0d004fa27803d99c4187d419f"
 dependencies = [
  "halo2wrong",
  "num-bigint",
@@ -3326,6 +3342,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
+[[package]]
+name = "pairing"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81fec4625e73cf41ef4bb6846cafa6d44736525f442ba45e407c4a000a13996f"
+dependencies = [
+ "group",
+]
+
 [[package]]
 name = "papergrid"
 version = "0.9.1"
@@ -4032,9 +4057,9 @@ checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
 
 [[package]]
 name = "rayon"
-version = "1.7.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
+checksum = "fa7237101a77a10773db45d62004a272517633fbcc3df19d96455ede1122e051"
 dependencies = [
  "either",
  "rayon-core",
@@ -4042,14 +4067,12 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.11.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
- "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-utils",
- "num_cpus",
 ]
 
 [[package]]
@@ -4737,11 +4760,11 @@ dependencies = [
 [[package]]
 name = "snark-verifier"
 version = "0.1.1"
-source = "git+https://github.com/zkonduit/snark-verifier?branch=ac/chunked-mv-lookup#22ee76bee1a24f3732e994b72b10ec09939348de"
+source = "git+https://github.com/zkonduit/snark-verifier?branch=ac/chunked-mv-lookup#574b65ea6b4d43eebac5565146519a95b435815c"
 dependencies = [
  "ecc",
  "halo2_proofs",
- "halo2curves 0.1.0",
+ "halo2curves 0.6.0",
  "hex",
  "itertools 0.10.5",
  "lazy_static",

Cargo.toml

@@ -15,9 +15,9 @@ crate-type = ["cdylib", "rlib"]
 
 
 [dependencies]
-halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch= "ac/lookup-modularity" }
-halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch= "ac/lookup-modularity"  }
-halo2curves = { version = "0.1.0" }
+halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch= "main" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch= "main"  }
+halo2curves = { version = "0.6.0", features = ["derive_serde"] }
 rand = { version = "0.8", default_features = false }
 itertools = { version = "0.10.3", default_features = false }
 clap = { version = "4.3.3", features = ["derive"]}
@@ -28,7 +28,7 @@ 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= "ac/lookup-modularity" }
+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 }

README.md

@@ -65,7 +65,7 @@ More notebook tutorials can be found within `examples/notebooks`.
 #### CLI
 Install the CLI
 ``` shell
-curl https://github.com/JSeam2/ezkl/blob/main/install_ezkl_cli.sh | bash
+curl https://raw.githubusercontent.com/zkonduit/ezkl/main/install_ezkl_cli.sh | bash
 ```
 
 https://user-images.githubusercontent.com/45801863/236771676-5bbbbfd1-ba6f-418a-902e-20738ce0e9f0.mp4

benches/accum_conv.rs

@@ -121,13 +121,16 @@ 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)
-                        .unwrap();
+                    create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(
+                        &circuit, &params, true,
+                    )
+                    .unwrap();
                 });
             });
 
-            let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
-                .unwrap();
+            let pk =
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+                    .unwrap();
 
             group.throughput(Throughput::Elements(*size as u64));
             group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {

benches/accum_dot.rs

@@ -90,13 +90,13 @@ 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)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {

benches/accum_einsum_matmul.rs

@@ -94,13 +94,13 @@ 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)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {

benches/accum_matmul_relu.rs

@@ -111,13 +111,13 @@ 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)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {

benches/accum_matmul_relu_overflow.rs

@@ -114,13 +114,13 @@ 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)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(k as u64));
         group.bench_with_input(BenchmarkId::new("prove", k), &k, |b, &_| {

benches/accum_sum.rs

@@ -86,13 +86,13 @@ 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)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {

benches/accum_sumpool.rs

@@ -101,13 +101,16 @@ 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)
-                        .unwrap();
+                    create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(
+                        &circuit, &params, true,
+                    )
+                    .unwrap();
                 });
             });
 
-            let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
-                .unwrap();
+            let pk =
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+                    .unwrap();
 
             group.throughput(Throughput::Elements(*size as u64));
             group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {

benches/pairwise_add.rs

@@ -84,13 +84,13 @@ 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)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {

benches/pairwise_pow.rs

@@ -83,13 +83,13 @@ 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)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {

benches/poseidon.rs

@@ -76,13 +76,13 @@ 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)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(*size as u64));
         group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {

benches/relu.rs

@@ -90,13 +90,13 @@ 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)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, NLCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, NLCircuit>(&circuit, &params).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, NLCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {

examples/notebooks/data_attest_hashed.ipynb

@@ -309,7 +309,7 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "print(ezkl.vecu64_to_felt(res['processed_outputs']['poseidon_hash'][0]))"
+                "print(ezkl.string_to_felt(res['processed_outputs']['poseidon_hash'][0]))"
             ]
         },
         {
@@ -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.vecu64_to_felt(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
+                "    data = [int(ezkl.string_to_felt(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
                 "\n",
                 "    # Step 1: Prepare the data\n",
                 "    # Step 2: Prepare and compile the contract.\n",

examples/notebooks/ezkl_demo.ipynb

@@ -695,7 +695,7 @@
         "formatted_output = \"[\"\n",
         "for i, value in enumerate(proof[\"instances\"]):\n",
         "    for j, field_element in enumerate(value):\n",
-        "        onchain_input_array.append(ezkl.vecu64_to_felt(field_element))\n",
+        "        onchain_input_array.append(ezkl.string_to_felt(field_element))\n",
         "        formatted_output += str(onchain_input_array[-1])\n",
         "        if j != len(value) - 1:\n",
         "            formatted_output += \", \"\n",

examples/notebooks/mnist_gan_proof_splitting.ipynb

@@ -300,13 +300,14 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 9,
+            "execution_count": 20,
             "metadata": {},
             "outputs": [],
             "source": [
                 "# iterate over each submodel gen-settings, compile circuit and setup zkSNARK\n",
                 "\n",
                 "def setup(i):\n",
+                "    print(\"Setting up split model \"+str(i))\n",
                 "    # file names\n",
                 "    model_path = os.path.join('network_split_'+str(i)+'.onnx')\n",
                 "    settings_path = os.path.join('settings_split_'+str(i)+'.json')\n",
@@ -342,12 +343,12 @@
                 "         compiled_model_path,\n",
                 "         vk_path,\n",
                 "         pk_path,\n",
+                "         compress_selectors=True,\n",
                 "      )\n",
                 "\n",
                 "    assert res == True\n",
                 "    assert os.path.isfile(vk_path)\n",
                 "    assert os.path.isfile(pk_path)\n",
-                "    \n",
                 "    res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
                 "    run_args.input_scale = settings[\"model_output_scales\"][0]\n",
                 "\n",
@@ -383,7 +384,6 @@
                 "            compiled_model_path,\n",
                 "            pk_path,\n",
                 "            proof_path,\n",
-                "            \n",
                 "            \"for-aggr\",\n",
                 "        )\n",
                 "\n",
@@ -413,7 +413,6 @@
                 "            proof_path,\n",
                 "            settings_path,\n",
                 "            vk_path,\n",
-                "            \n",
                 "        )\n",
                 "\n",
                 "    assert res == True\n",
@@ -442,7 +441,7 @@
                 "    proof_path = os.path.join('proof_split_'+str(i)+'.json')\n",
                 "    proofs.append(proof_path)\n",
                 "\n",
-                "ezkl.mock_aggregate(proofs, logrows=23, split_proofs = True)"
+                "ezkl.mock_aggregate(proofs, logrows=22, split_proofs = True)"
             ]
         }
     ],

examples/notebooks/proof_splitting.ipynb

@@ -302,7 +302,7 @@
                 "    assert res == True\n",
                 "    assert os.path.isfile(vk_path)\n",
                 "    assert os.path.isfile(pk_path)\n",
-                "    \n",
+                "\n",
                 "    res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
                 "    run_args.input_scale = settings[\"model_output_scales\"][0]\n",
                 "\n",
@@ -330,14 +330,14 @@
                 "            compiled_model_path,\n",
                 "            pk_path,\n",
                 "            proof_path,\n",
-                "            \n",
                 "            \"for-aggr\",\n",
                 "        )\n",
                 "\n",
                 "    print(res)\n",
+                "    res_1_proof = res[\"proof\"]\n",
                 "    assert os.path.isfile(proof_path)\n",
                 "\n",
-                "    # Verify the proof\n",
+                "    # # Verify the proof\n",
                 "    if i > 0:\n",
                 "        print(\"swapping commitments\")\n",
                 "        # swap the proof commitments if we are not the first model\n",
@@ -356,12 +356,19 @@
                 "\n",
                 "        res = ezkl.swap_proof_commitments(proof_path, witness_path)\n",
                 "        print(res)\n",
+                "        \n",
+                "        # load proof and then print \n",
+                "        proof = json.load(open(proof_path, 'r'))\n",
+                "        res_2_proof = proof[\"hex_proof\"]\n",
+                "        # show diff in hex strings\n",
+                "        print(res_1_proof)\n",
+                "        print(res_2_proof)\n",
+                "        assert res_1_proof == res_2_proof\n",
                 "\n",
                 "    res = ezkl.verify(\n",
                 "            proof_path,\n",
                 "            settings_path,\n",
                 "            vk_path,\n",
-                "            \n",
                 "        )\n",
                 "\n",
                 "    assert res == True\n",
@@ -439,7 +446,7 @@
                 "    proof_path = os.path.join('proof_split_'+str(i)+'.json')\n",
                 "    proofs.append(proof_path)\n",
                 "\n",
-                "ezkl.mock_aggregate(proofs, logrows=23, split_proofs = True)"
+                "ezkl.mock_aggregate(proofs, logrows=22, split_proofs = True)"
             ]
         }
     ],

examples/notebooks/set_membership.ipynb

@@ -78,7 +78,7 @@
         "pk_path = os.path.join('test.pk')\n",
         "vk_path = os.path.join('test.vk')\n",
         "settings_path = os.path.join('settings.json')\n",
-        "",
+        "\n",
         "witness_path = os.path.join('witness.json')\n",
         "data_path = os.path.join('input.json')"
       ]
@@ -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_vecu64(e,7))\n",
-        "    result.append(ezkl.poseidon_hash([ezkl.float_to_vecu64(e, 7)])[0])\n",
+        "    print(ezkl.float_to_string(e,7))\n",
+        "    result.append(ezkl.poseidon_hash([ezkl.float_to_string(e, 7)])[0])\n",
         "\n",
         "y = y.unsqueeze(0)\n",
         "y = y.reshape(1, 9)\n",
@@ -343,7 +343,7 @@
         "# we force the output to be 0 this corresponds to the set membership 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] = [[0, 0, 0, 0]]\n",
+        "witness[\"outputs\"][0] = [\"0000000000000000000000000000000000000000000000000000000000000000\"]\n",
         "json.dump(witness, open(witness_path, \"w\"))\n",
         "\n",
         "witness = json.load(open(witness_path, \"r\"))\n",
@@ -353,7 +353,6 @@
         "        compiled_model_path,\n",
         "        vk_path,\n",
         "        pk_path,\n",
-        "        \n",
         "        witness_path = witness_path,\n",
         "    )\n",
         "\n",
@@ -520,4 +519,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/simple_demo_public_network_output.ipynb

@@ -210,7 +210,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 9,
             "id": "b1c561a8",
             "metadata": {},
             "outputs": [],

examples/notebooks/solvency.ipynb

@@ -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_vecu64(e, 0)])[0])\n",
+        "    users.append(ezkl.poseidon_hash([ezkl.float_to_string(e, 0)])[0])\n",
         "\n",
         "users_t = torch.tensor(user_preimages)\n",
         "users_t = users_t.reshape(1, 6)\n",
@@ -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_vecu64(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_string(1.0, 0)]\n",
         "json.dump(witness, open(witness_path, \"w\"))"
       ]
     },
@@ -417,7 +417,7 @@
         "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
         "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
         "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [ezkl.float_to_vecu64(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_string(1.0, 0)]\n",
         "json.dump(witness, open(witness_path, \"w\"))\n"
       ]
     },

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\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
             ]
         },
         {

examples/notebooks/tictactoe_binary_classification.ipynb

@@ -520,7 +520,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
             ]
         },
         {
@@ -636,7 +636,8 @@
             "mimetype": "text/x-python",
             "name": "python",
             "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3"
+            "pygments_lexer": "ipython3",
+            "version": "3.9.15"
         }
     },
     "nbformat": 4,

examples/notebooks/voice_judge.ipynb

@@ -25,17 +25,9 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 1,
+            "execution_count": null,
             "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "voice_data_dir:  .\n"
-                    ]
-                }
-            ],
+            "outputs": [],
             "source": [
                 "\n",
                 "import os\n",
@@ -43,7 +35,7 @@
                 "\n",
                 "voice_data_dir = os.environ.get('VOICE_DATA_DIR')\n",
                 "\n",
-                "#  if is none set to \"\" \n",
+                "#  if is none set to \"\"\n",
                 "if voice_data_dir is None:\n",
                 "    voice_data_dir = \"\"\n",
                 "\n",
@@ -637,7 +629,7 @@
             "source": [
                 "\n",
                 "\n",
-                "res = ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\", scales = [4])\n",
                 "assert res == True\n",
                 "print(\"verified\")\n"
             ]
@@ -908,7 +900,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.13"
+            "version": "3.9.15"
         }
     },
     "nbformat": 4,

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

src/circuit/modules/kzg.rs

@@ -219,7 +219,7 @@ mod tests {
             };
             let prover = halo2_proofs::dev::MockProver::run(K as u32, &circuit, vec![]).unwrap();
 
-            assert_eq!(prover.verify_par(), Ok(()))
+            assert_eq!(prover.verify(), Ok(()))
         }
     }
 
@@ -240,6 +240,6 @@ mod tests {
             message: message.into(),
         };
         let prover = halo2_proofs::dev::MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        assert_eq!(prover.verify_par(), Ok(()))
+        assert_eq!(prover.verify(), Ok(()))
     }
 }

src/circuit/modules/poseidon.rs

@@ -499,7 +499,7 @@ mod tests {
             _spec: PhantomData,
         };
         let prover = halo2_proofs::dev::MockProver::run(k, &circuit, output).unwrap();
-        assert_eq!(prover.verify_par(), Ok(()))
+        assert_eq!(prover.verify(), Ok(()))
     }
 
     #[test]
@@ -518,7 +518,7 @@ mod tests {
             _spec: PhantomData,
         };
         let prover = halo2_proofs::dev::MockProver::run(k, &circuit, output).unwrap();
-        assert_eq!(prover.verify_par(), Ok(()))
+        assert_eq!(prover.verify(), Ok(()))
     }
 
     #[test]
@@ -551,7 +551,7 @@ mod tests {
             };
             let prover = halo2_proofs::dev::MockProver::run(k, &circuit, output).unwrap();
 
-            assert_eq!(prover.verify_par(), Ok(()))
+            assert_eq!(prover.verify(), Ok(()))
         }
     }
 
@@ -573,6 +573,6 @@ mod tests {
             _spec: PhantomData,
         };
         let prover = halo2_proofs::dev::MockProver::run(k, &circuit, output).unwrap();
-        assert_eq!(prover.verify_par(), Ok(()))
+        assert_eq!(prover.verify(), Ok(()))
     }
 }

src/circuit/ops/layouts.rs

@@ -1837,15 +1837,6 @@ pub fn deconv<F: PrimeField + TensorType + PartialOrd + std::marker::Send + std:
         )));
     }
 
-    if has_bias {
-        let bias = &inputs[2];
-        if (bias.dims().len() != 1) || (bias.dims()[0] != kernel.dims()[0]) {
-            return Err(Box::new(TensorError::DimMismatch(
-                "deconv bias".to_string(),
-            )));
-        }
-    }
-
     let (kernel_height, kernel_width) = (kernel.dims()[2], kernel.dims()[3]);
 
     let null_val = ValType::Constant(F::ZERO);

src/circuit/ops/poly.rs

@@ -237,7 +237,7 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
             }
             PolyOp::Neg => layouts::neg(config, region, values[..].try_into()?)?,
             PolyOp::Iff => layouts::iff(config, region, values[..].try_into()?)?,
-            PolyOp::Einsum { equation } => layouts::einsum(config, region, &values, equation)?,
+            PolyOp::Einsum { equation } => layouts::einsum(config, region, values, equation)?,
             PolyOp::Sum { axes } => {
                 layouts::sum_axes(config, region, values[..].try_into()?, axes)?
             }

src/circuit/tests.rs

@@ -90,7 +90,7 @@ mod matmul {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -165,7 +165,7 @@ mod matmul_col_overflow_double_col {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -239,7 +239,7 @@ mod matmul_col_overflow {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -327,7 +327,7 @@ mod matmul_col_ultra_overflow_double_col {
             halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
             F,
             MatmulCircuit<F>,
-        >(&circuit, &params)
+        >(&circuit, &params, true)
         .unwrap();
 
         let prover = crate::pfsys::create_proof_circuit_kzg(
@@ -441,7 +441,7 @@ mod matmul_col_ultra_overflow {
             halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
             F,
             MatmulCircuit<F>,
-        >(&circuit, &params)
+        >(&circuit, &params, true)
         .unwrap();
 
         let prover = crate::pfsys::create_proof_circuit_kzg(
@@ -543,7 +543,7 @@ mod dot {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -620,7 +620,7 @@ mod dot_col_overflow_triple_col {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -693,7 +693,7 @@ mod dot_col_overflow {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -762,7 +762,7 @@ mod sum {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -832,7 +832,7 @@ mod sum_col_overflow_double_col {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -901,7 +901,7 @@ mod sum_col_overflow {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -994,7 +994,7 @@ mod composition {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -1095,7 +1095,7 @@ mod conv {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 
     #[test]
@@ -1133,7 +1133,7 @@ mod conv {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -1240,7 +1240,7 @@ mod conv_col_ultra_overflow {
             halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
             F,
             ConvCircuit<F>,
-        >(&circuit, &params)
+        >(&circuit, &params, true)
         .unwrap();
 
         let prover = crate::pfsys::create_proof_circuit_kzg(
@@ -1390,7 +1390,7 @@ mod conv_relu_col_ultra_overflow {
             halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
             F,
             ConvCircuit<F>,
-        >(&circuit, &params)
+        >(&circuit, &params, true)
         .unwrap();
 
         let prover = crate::pfsys::create_proof_circuit_kzg(
@@ -1484,7 +1484,7 @@ mod add_w_shape_casting {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -1551,7 +1551,7 @@ mod add {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -1618,7 +1618,7 @@ mod add_with_overflow {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -1727,7 +1727,7 @@ mod add_with_overflow_and_poseidon {
 
         let prover =
             MockProver::run(K as u32, &circuit, vec![vec![commitment_a, commitment_b]]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 
     #[test]
@@ -1822,7 +1822,7 @@ mod sub {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -1889,7 +1889,7 @@ mod mult {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -1954,7 +1954,7 @@ mod pow {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -2023,7 +2023,7 @@ mod pack {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -2116,7 +2116,7 @@ mod matmul_relu {
         };
 
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -2222,7 +2222,7 @@ mod rangecheckpercent {
                 _marker: PhantomData,
             };
             let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-            prover.assert_satisfied_par();
+            prover.assert_satisfied();
         }
         {
             let inp = Tensor::new(Some(&[Value::<F>::known(F::from(200_u64))]), &[1]).unwrap();
@@ -2233,7 +2233,7 @@ mod rangecheckpercent {
                 _marker: PhantomData,
             };
             let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-            prover.assert_satisfied_par();
+            prover.assert_satisfied();
         }
 
         // Unsuccessful case
@@ -2328,7 +2328,7 @@ mod relu {
         };
 
         let prover = MockProver::run(4_u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }
 
@@ -2421,7 +2421,7 @@ mod lookup_ultra_overflow {
             halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
             F,
             ReLUCircuit<F>,
-        >(&circuit, &params)
+        >(&circuit, &params, true)
         .unwrap();
 
         let prover = crate::pfsys::create_proof_circuit_kzg(
@@ -2557,6 +2557,6 @@ mod softmax {
             _marker: PhantomData,
         };
         let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied_par();
+        prover.assert_satisfied();
     }
 }

src/commands.rs

@@ -59,6 +59,8 @@ pub const DEFAULT_SOL_CODE_DA: &str = "evm_deploy_da.sol";
 pub const DEFAULT_CONTRACT_ADDRESS: &str = "contract.address";
 /// Default contract address for data attestation
 pub const DEFAULT_CONTRACT_ADDRESS_DA: &str = "contract_da.address";
+/// Default contract address for vk
+pub const DEFAULT_CONTRACT_ADDRESS_VK: &str = "contract_vk.address";
 /// Default check mode
 pub const DEFAULT_CHECKMODE: &str = "safe";
 /// Default calibration target
@@ -73,6 +75,14 @@ pub const DEFAULT_FUZZ_RUNS: &str = "10";
 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";
+/// Default render vk seperately
+pub const DEFAULT_RENDER_VK_SEPERATELY: &str = "false";
+/// Default VK sol path
+pub const DEFAULT_VK_SOL: &str = "vk.sol";
+/// Default VK abi path
+pub const DEFAULT_VK_ABI: &str = "vk.abi";
 
 impl std::fmt::Display for TranscriptType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -389,6 +399,9 @@ pub enum Commands {
         /// whether the accumulated are segments of a larger proof
         #[arg(long, default_value = DEFAULT_SPLIT)]
         split_proofs: bool,
+        /// compress selectors
+        #[arg(long, default_value = DEFAULT_COMPRESS_SELECTORS)]
+        compress_selectors: bool,
     },
     /// Aggregates proofs :)
     Aggregate {
@@ -451,6 +464,9 @@ pub enum Commands {
         /// The graph witness (optional - used to override fixed values in the circuit)
         #[arg(short = 'W', long)]
         witness: Option<PathBuf>,
+        /// compress selectors
+        #[arg(long, default_value = DEFAULT_COMPRESS_SELECTORS)]
+        compress_selectors: bool,
     },
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -473,6 +489,9 @@ pub enum Commands {
         /// 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,
     },
     #[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
@@ -573,6 +592,31 @@ pub enum Commands {
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_ABI)]
         abi_path: PathBuf,
+        /// Whether the verifier key should be rendered as a separate contract.
+        /// We recommend disabling selector compression if this is enabled.
+        /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
+        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY)]
+        render_vk_seperately: bool,
+    },
+    #[cfg(not(target_arch = "wasm32"))]
+    /// Creates an EVM verifier for a single proof
+    #[command(name = "create-evm-vk")]
+    CreateEVMVK {
+        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        #[arg(long)]
+        srs_path: Option<PathBuf>,
+        /// The path to load circuit settings .json file from (generated using the gen-settings command)
+        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
+        settings_path: PathBuf,
+        /// The path to load the desired verification key file
+        #[arg(long, default_value = DEFAULT_VK)]
+        vk_path: PathBuf,
+        /// The path to output the Solidity code
+        #[arg(long, default_value = DEFAULT_VK_SOL)]
+        sol_code_path: PathBuf,
+        /// The path to output the Solidity verifier ABI
+        #[arg(long, default_value = DEFAULT_VK_ABI)]
+        abi_path: PathBuf,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Creates an EVM verifier that attests to on-chain inputs for a single proof
@@ -618,6 +662,11 @@ pub enum Commands {
         // logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
         logrows: u32,
+        /// Whether the verifier key should be rendered as a separate contract.
+        /// We recommend disabling selector compression if this is enabled.
+        /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
+        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY)]
+        render_vk_seperately: bool,
     },
     /// Verifies a proof, returning accept or reject
     Verify {
@@ -669,6 +718,25 @@ pub enum Commands {
         private_key: Option<String>,
     },
     #[cfg(not(target_arch = "wasm32"))]
+    /// Deploys an evm verifier that is generated by ezkl
+    DeployEvmVK {
+        /// The path to the Solidity code (generated using the create-evm-verifier command)
+        #[arg(long, default_value = DEFAULT_VK_SOL)]
+        sol_code_path: PathBuf,
+        /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
+        #[arg(short = 'U', long)]
+        rpc_url: Option<String>,
+        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_VK)]
+        /// The path to output the contract address
+        addr_path: PathBuf,
+        /// The optimizer runs to set on the verifier. Lower values optimize for deployment cost, while higher values optimize for gas cost.
+        #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS)]
+        optimizer_runs: usize,
+        /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
+        #[arg(short = 'P', long)]
+        private_key: Option<String>,
+    },
+    #[cfg(not(target_arch = "wasm32"))]
     /// Deploys an evm verifier that allows for data attestation
     #[command(name = "deploy-evm-da")]
     DeployEvmDataAttestation {
@@ -710,6 +778,9 @@ pub enum Commands {
         /// does the verifier use data attestation ?
         #[arg(long)]
         addr_da: Option<H160>,
+        // is the vk rendered seperately, if so specify an address
+        #[arg(long)]
+        addr_vk: Option<H160>,
     },
 
     /// Print the proof in hexadecimal

src/eth.rs

@@ -101,17 +101,18 @@ pub async fn setup_eth_backend(
 }
 
 ///
-pub async fn deploy_verifier_via_solidity(
+pub async fn deploy_contract_via_solidity(
     sol_code_path: PathBuf,
     rpc_url: Option<&str>,
     runs: usize,
     private_key: Option<&str>,
+    contract_name: &str,
 ) -> Result<ethers::types::Address, Box<dyn Error>> {
     // anvil instance must be alive at least until the factory completes the deploy
     let (anvil, client) = setup_eth_backend(rpc_url, private_key).await?;
 
     let (abi, bytecode, runtime_bytecode) =
-        get_contract_artifacts(sol_code_path, "Halo2Verifier", runs)?;
+        get_contract_artifacts(sol_code_path, contract_name, runs)?;
 
     let factory = get_sol_contract_factory(abi, bytecode, runtime_bytecode, client.clone())?;
     let contract = factory.deploy(())?.send().await?;
@@ -335,11 +336,16 @@ pub async fn update_account_calls(
 pub async fn verify_proof_via_solidity(
     proof: Snark<Fr, G1Affine>,
     addr: ethers::types::Address,
+    addr_vk: Option<H160>,
     rpc_url: Option<&str>,
 ) -> Result<bool, Box<dyn Error>> {
     let flattened_instances = proof.instances.into_iter().flatten();
 
-    let encoded = encode_calldata(None, &proof.proof, &flattened_instances.collect::<Vec<_>>());
+    let encoded = encode_calldata(
+        addr_vk.as_ref().map(|x| x.0),
+        &proof.proof,
+        &flattened_instances.collect::<Vec<_>>(),
+    );
 
     info!("encoded: {:#?}", hex::encode(&encoded));
     let (anvil, client) = setup_eth_backend(rpc_url, None).await?;
@@ -439,6 +445,7 @@ pub async fn verify_proof_with_data_attestation(
     proof: Snark<Fr, G1Affine>,
     addr_verifier: ethers::types::Address,
     addr_da: ethers::types::Address,
+    addr_vk: Option<H160>,
     rpc_url: Option<&str>,
 ) -> Result<bool, Box<dyn Error>> {
     use ethers::abi::{Function, Param, ParamType, StateMutability, Token};
@@ -452,8 +459,11 @@ pub async fn verify_proof_with_data_attestation(
         public_inputs.push(u);
     }
 
-    let encoded_verifier =
-        encode_calldata(None, &proof.proof, &flattened_instances.collect::<Vec<_>>());
+    let encoded_verifier = encode_calldata(
+        addr_vk.as_ref().map(|x| x.0),
+        &proof.proof,
+        &flattened_instances.collect::<Vec<_>>(),
+    );
 
     info!("encoded: {:#?}", hex::encode(&encoded_verifier));
 

src/execute.rs

@@ -3,7 +3,7 @@ use crate::circuit::CheckMode;
 use crate::commands::CalibrationTarget;
 use crate::commands::Commands;
 #[cfg(not(target_arch = "wasm32"))]
-use crate::eth::{deploy_da_verifier_via_solidity, deploy_verifier_via_solidity};
+use crate::eth::{deploy_contract_via_solidity, deploy_da_verifier_via_solidity};
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(unused_imports)]
 use crate::eth::{fix_da_sol, get_contract_artifacts, verify_proof_via_solidity};
@@ -140,8 +140,14 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             compiled_circuit,
             transcript,
             num_runs,
-        } => fuzz(compiled_circuit, witness, transcript, num_runs),
-
+            compress_selectors,
+        } => fuzz(
+            compiled_circuit,
+            witness,
+            transcript,
+            num_runs,
+            compress_selectors,
+        ),
         Commands::GenSrs { srs_path, logrows } => gen_srs_cmd(srs_path, logrows as u32),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::GetSrs {
@@ -198,7 +204,22 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             settings_path,
             sol_code_path,
             abi_path,
-        } => create_evm_verifier(vk_path, srs_path, settings_path, sol_code_path, abi_path),
+            render_vk_seperately,
+        } => create_evm_verifier(
+            vk_path,
+            srs_path,
+            settings_path,
+            sol_code_path,
+            abi_path,
+            render_vk_seperately,
+        ),
+        Commands::CreateEVMVK {
+            vk_path,
+            srs_path,
+            settings_path,
+            sol_code_path,
+            abi_path,
+        } => create_evm_vk(vk_path, srs_path, settings_path, sol_code_path, abi_path),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEVMDataAttestation {
             settings_path,
@@ -214,6 +235,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             abi_path,
             aggregation_settings,
             logrows,
+            render_vk_seperately,
         } => create_evm_aggregate_verifier(
             vk_path,
             srs_path,
@@ -221,6 +243,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             abi_path,
             aggregation_settings,
             logrows,
+            render_vk_seperately,
         ),
         Commands::CompileCircuit {
             model,
@@ -233,7 +256,15 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             vk_path,
             pk_path,
             witness,
-        } => setup(compiled_circuit, srs_path, vk_path, pk_path, witness),
+            compress_selectors,
+        } => setup(
+            compiled_circuit,
+            srs_path,
+            vk_path,
+            pk_path,
+            witness,
+            compress_selectors,
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::SetupTestEVMData {
             data,
@@ -296,6 +327,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             srs_path,
             logrows,
             split_proofs,
+            compress_selectors,
         } => setup_aggregate(
             sample_snarks,
             vk_path,
@@ -303,6 +335,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             srs_path,
             logrows,
             split_proofs,
+            compress_selectors,
         ),
         Commands::Aggregate {
             proof_path,
@@ -352,6 +385,25 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
                 addr_path,
                 optimizer_runs,
                 private_key,
+                "Halo2Verifier",
+            )
+            .await
+        }
+        #[cfg(not(target_arch = "wasm32"))]
+        Commands::DeployEvmVK {
+            sol_code_path,
+            rpc_url,
+            addr_path,
+            optimizer_runs,
+            private_key,
+        } => {
+            deploy_evm(
+                sol_code_path,
+                rpc_url,
+                addr_path,
+                optimizer_runs,
+                private_key,
+                "Halo2VerifyingKey",
             )
             .await
         }
@@ -382,7 +434,8 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             addr_verifier,
             rpc_url,
             addr_da,
-        } => verify_evm(proof_path, addr_verifier, rpc_url, addr_da).await,
+            addr_vk,
+        } => verify_evm(proof_path, addr_verifier, rpc_url, addr_da, addr_vk).await,
         Commands::PrintProofHex { proof_path } => print_proof_hex(proof_path),
     }
 }
@@ -432,7 +485,7 @@ async fn fetch_srs(uri: &str) -> Result<Vec<u8>, Box<dyn Error>> {
 #[cfg(not(target_arch = "wasm32"))]
 fn check_srs_hash(logrows: u32, srs_path: Option<PathBuf>) -> Result<String, Box<dyn Error>> {
     let path = get_srs_path(logrows, srs_path);
-    let hash = sha256::digest(&std::fs::read(path.clone())?);
+    let hash = sha256::digest(std::fs::read(path.clone())?);
     info!("SRS hash: {}", hash);
 
     let predefined_hash = match { crate::srs_sha::PUBLIC_SRS_SHA256_HASHES.get(&logrows) } {
@@ -440,7 +493,7 @@ fn check_srs_hash(logrows: u32, srs_path: Option<PathBuf>) -> Result<String, Box
         None => return Err(format!("SRS (k={}) hash not found in public set", logrows).into()),
     };
 
-    if hash != predefined_hash.to_string() {
+    if hash != *predefined_hash {
         // delete file
         warn!("removing SRS file at {}", path.display());
         std::fs::remove_file(path)?;
@@ -663,7 +716,7 @@ impl AccuracyResults {
             let abs_error = error.map(|x| x.abs());
             let squared_error = error.map(|x| x.powi(2));
             let percentage_error =
-                error.enum_map(|i, x| Ok::<_, TensorError>(x / original[i].clone()))?;
+                error.enum_map(|i, x| Ok::<_, TensorError>(x / original[i]))?;
             let abs_percentage_error = percentage_error.map(|x| x.abs());
 
             errors.extend(error.into_iter());
@@ -679,29 +732,25 @@ impl AccuracyResults {
             abs_percentage_errors.iter().sum::<f32>() / abs_percentage_errors.len() as f32;
         let mean_error = errors.iter().sum::<f32>() / errors.len() as f32;
         let median_error = errors[errors.len() / 2];
-        let max_error = errors
+        let max_error = *errors
             .iter()
             .max_by(|a, b| a.partial_cmp(b).unwrap())
-            .unwrap()
-            .clone();
-        let min_error = errors
+            .unwrap();
+        let min_error = *errors
             .iter()
             .min_by(|a, b| a.partial_cmp(b).unwrap())
-            .unwrap()
-            .clone();
+            .unwrap();
 
         let mean_abs_error = abs_errors.iter().sum::<f32>() / abs_errors.len() as f32;
         let median_abs_error = abs_errors[abs_errors.len() / 2];
-        let max_abs_error = abs_errors
+        let max_abs_error = *abs_errors
             .iter()
             .max_by(|a, b| a.partial_cmp(b).unwrap())
-            .unwrap()
-            .clone();
-        let min_abs_error = abs_errors
+            .unwrap();
+        let min_abs_error = *abs_errors
             .iter()
             .min_by(|a, b| a.partial_cmp(b).unwrap())
-            .unwrap()
-            .clone();
+            .unwrap();
 
         let mean_squared_error = squared_errors.iter().sum::<f32>() / squared_errors.len() as f32;
 
@@ -1096,7 +1145,7 @@ pub(crate) fn mock(
     )
     .map_err(Box::<dyn Error>::from)?;
     prover
-        .verify_par()
+        .verify()
         .map_err(|e| Box::<dyn Error>::from(ExecutionError::VerifyError(e)))?;
     Ok(String::new())
 }
@@ -1141,6 +1190,7 @@ pub(crate) fn create_evm_verifier(
     settings_path: PathBuf,
     sol_code_path: PathBuf,
     abi_path: PathBuf,
+    render_vk_seperately: bool,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
     let circuit_settings = GraphSettings::load(&settings_path)?;
@@ -1158,7 +1208,11 @@ pub(crate) fn create_evm_verifier(
         halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
         num_instance,
     );
-    let verifier_solidity = generator.render()?;
+    let verifier_solidity = if render_vk_seperately {
+        generator.render_separately()?.0 // ignore the rendered vk for now and generate it in create_evm_vk
+    } else {
+        generator.render()?
+    };
 
     File::create(sol_code_path.clone())?.write_all(verifier_solidity.as_bytes())?;
 
@@ -1170,6 +1224,43 @@ pub(crate) fn create_evm_verifier(
     Ok(String::new())
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) fn create_evm_vk(
+    vk_path: PathBuf,
+    srs_path: Option<PathBuf>,
+    settings_path: PathBuf,
+    sol_code_path: PathBuf,
+    abi_path: PathBuf,
+) -> Result<String, Box<dyn Error>> {
+    check_solc_requirement();
+    let circuit_settings = GraphSettings::load(&settings_path)?;
+    let params = load_params_cmd(srs_path, circuit_settings.run_args.logrows)?;
+
+    let num_instance = circuit_settings.total_instances();
+    let num_instance: usize = num_instance.iter().sum::<usize>();
+
+    let vk = load_vk::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(vk_path, circuit_settings)?;
+    trace!("params computed");
+
+    let generator = halo2_solidity_verifier::SolidityGenerator::new(
+        &params,
+        &vk,
+        halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
+        num_instance,
+    );
+
+    let vk_solidity = generator.render_separately()?.1;
+
+    File::create(sol_code_path.clone())?.write_all(vk_solidity.as_bytes())?;
+
+    // fetch abi of the contract
+    let (abi, _, _) = get_contract_artifacts(sol_code_path, "Halo2VerifyingKey", 0)?;
+    // save abi to file
+    serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
+
+    Ok(String::new())
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn create_evm_data_attestation(
     settings_path: PathBuf,
@@ -1265,13 +1356,15 @@ pub(crate) async fn deploy_evm(
     addr_path: PathBuf,
     runs: usize,
     private_key: Option<String>,
+    contract_name: &str,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
-    let contract_address = deploy_verifier_via_solidity(
+    let contract_address = deploy_contract_via_solidity(
         sol_code_path,
         rpc_url.as_deref(),
         runs,
         private_key.as_deref(),
+        contract_name,
     )
     .await?;
 
@@ -1288,6 +1381,7 @@ pub(crate) async fn verify_evm(
     addr_verifier: H160,
     rpc_url: Option<String>,
     addr_da: Option<H160>,
+    addr_vk: Option<H160>,
 ) -> Result<String, Box<dyn Error>> {
     use crate::eth::verify_proof_with_data_attestation;
     check_solc_requirement();
@@ -1299,11 +1393,12 @@ pub(crate) async fn verify_evm(
             proof.clone(),
             addr_verifier,
             addr_da,
+            addr_vk,
             rpc_url.as_deref(),
         )
         .await?
     } else {
-        verify_proof_via_solidity(proof.clone(), addr_verifier, rpc_url.as_deref()).await?
+        verify_proof_via_solidity(proof.clone(), addr_verifier, addr_vk, rpc_url.as_deref()).await?
     };
 
     info!("Solidity verification result: {}", result);
@@ -1323,6 +1418,7 @@ pub(crate) fn create_evm_aggregate_verifier(
     abi_path: PathBuf,
     circuit_settings: Vec<PathBuf>,
     logrows: u32,
+    render_vk_seperately: bool,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
     let srs_path = get_srs_path(logrows, srs_path);
@@ -1361,7 +1457,11 @@ pub(crate) fn create_evm_aggregate_verifier(
 
     generator = generator.set_acc_encoding(Some(acc_encoding));
 
-    let verifier_solidity = generator.render()?;
+    let verifier_solidity = if render_vk_seperately {
+        generator.render_separately()?.0 // ignore the rendered vk for now and generate it in create_evm_vk
+    } else {
+        generator.render()?
+    };
 
     File::create(sol_code_path.clone())?.write_all(verifier_solidity.as_bytes())?;
 
@@ -1390,6 +1490,7 @@ pub(crate) fn setup(
     vk_path: PathBuf,
     pk_path: PathBuf,
     witness: Option<PathBuf>,
+    compress_selectors: bool,
 ) -> Result<String, Box<dyn Error>> {
     // these aren't real values so the sanity checks are mostly meaningless
     let mut circuit = GraphCircuit::load(compiled_circuit)?;
@@ -1400,8 +1501,12 @@ pub(crate) fn setup(
 
     let params = load_params_cmd(srs_path, circuit.settings().run_args.logrows)?;
 
-    let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(&circuit, &params)
-        .map_err(Box::<dyn Error>::from)?;
+    let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
+        &circuit,
+        &params,
+        compress_selectors,
+    )
+    .map_err(Box::<dyn Error>::from)?;
 
     save_vk::<KZGCommitmentScheme<Bn256>>(&vk_path, pk.get_vk())?;
     save_pk::<KZGCommitmentScheme<Bn256>>(&pk_path, &pk)?;
@@ -1540,6 +1645,7 @@ pub(crate) fn fuzz(
     data_path: PathBuf,
     transcript: TranscriptType,
     num_runs: usize,
+    compress_selectors: bool,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
     let passed = AtomicBool::new(true);
@@ -1555,8 +1661,12 @@ pub(crate) fn fuzz(
 
     let data = GraphWitness::from_path(data_path)?;
 
-    let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(&circuit, &params)
-        .map_err(Box::<dyn Error>::from)?;
+    let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
+        &circuit,
+        &params,
+        compress_selectors,
+    )
+    .map_err(Box::<dyn Error>::from)?;
 
     circuit.load_graph_witness(&data)?;
 
@@ -1572,9 +1682,12 @@ pub(crate) fn fuzz(
     let fuzz_pk = || {
         let new_params = gen_srs::<KZGCommitmentScheme<Bn256>>(logrows);
 
-        let bad_pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(&circuit, &new_params)
-                .map_err(|_| ())?;
+        let bad_pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
+            &circuit,
+            &new_params,
+            compress_selectors,
+        )
+        .map_err(|_| ())?;
 
         let bad_proof = create_proof_circuit_kzg(
             circuit.clone(),
@@ -1645,9 +1758,12 @@ pub(crate) fn fuzz(
     let fuzz_vk = || {
         let new_params = gen_srs::<KZGCommitmentScheme<Bn256>>(logrows);
 
-        let bad_pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(&circuit, &new_params)
-                .map_err(|_| ())?;
+        let bad_pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
+            &circuit,
+            &new_params,
+            compress_selectors,
+        )
+        .map_err(|_| ())?;
 
         let bad_vk = bad_pk.get_vk();
 
@@ -1807,7 +1923,7 @@ pub(crate) fn mock_aggregate(
     let prover = halo2_proofs::dev::MockProver::run(logrows, &circuit, vec![circuit.instances()])
         .map_err(Box::<dyn Error>::from)?;
     prover
-        .verify_par()
+        .verify()
         .map_err(|e| Box::<dyn Error>::from(ExecutionError::VerifyError(e)))?;
     #[cfg(not(target_arch = "wasm32"))]
     pb.finish_with_message("Done.");
@@ -1821,6 +1937,7 @@ pub(crate) fn setup_aggregate(
     srs_path: Option<PathBuf>,
     logrows: u32,
     split_proofs: bool,
+    compress_selectors: bool,
 ) -> Result<String, Box<dyn Error>> {
     // the K used for the aggregation circuit
     let params = load_params_cmd(srs_path, logrows)?;
@@ -1831,8 +1948,11 @@ pub(crate) fn setup_aggregate(
     }
 
     let agg_circuit = AggregationCircuit::new(&params.get_g()[0].into(), snarks, split_proofs)?;
-    let agg_pk =
-        create_keys::<KZGCommitmentScheme<Bn256>, Fr, AggregationCircuit>(&agg_circuit, &params)?;
+    let agg_pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, AggregationCircuit>(
+        &agg_circuit,
+        &params,
+        compress_selectors,
+    )?;
 
     let agg_vk = agg_pk.get_vk();
 

src/graph/input.rs

@@ -617,13 +617,13 @@ impl ToPyObject for DataSource {
 }
 
 #[cfg(feature = "python-bindings")]
-use crate::pfsys::field_to_vecu64_montgomery;
+use crate::pfsys::field_to_string_montgomery;
 
 #[cfg(feature = "python-bindings")]
 impl ToPyObject for FileSourceInner {
     fn to_object(&self, py: Python) -> PyObject {
         match self {
-            FileSourceInner::Field(data) => field_to_vecu64_montgomery(data).to_object(py),
+            FileSourceInner::Field(data) => field_to_string_montgomery(data).to_object(py),
             FileSourceInner::Bool(data) => data.to_object(py),
             FileSourceInner::Float(data) => data.to_object(py),
         }

src/graph/mod.rs

@@ -53,7 +53,7 @@ pub use utilities::*;
 pub use vars::*;
 
 #[cfg(feature = "python-bindings")]
-use crate::pfsys::field_to_vecu64_montgomery;
+use crate::pfsys::field_to_string_montgomery;
 
 /// The safety factor for the range of the lookup table.
 pub const RANGE_MULTIPLIER: i128 = 2;
@@ -332,16 +332,16 @@ impl ToPyObject for GraphWitness {
         let dict_params = PyDict::new(py);
         let dict_outputs = PyDict::new(py);
 
-        let inputs: Vec<Vec<[u64; 4]>> = self
+        let inputs: Vec<Vec<String>> = self
             .inputs
             .iter()
-            .map(|x| x.iter().map(field_to_vecu64_montgomery).collect())
+            .map(|x| x.iter().map(field_to_string_montgomery).collect())
             .collect();
 
-        let outputs: Vec<Vec<[u64; 4]>> = self
+        let outputs: Vec<Vec<String>> = self
             .outputs
             .iter()
-            .map(|x| x.iter().map(field_to_vecu64_montgomery).collect())
+            .map(|x| x.iter().map(field_to_string_montgomery).collect())
             .collect();
 
         dict.set_item("inputs", inputs).unwrap();
@@ -389,9 +389,9 @@ impl ToPyObject for GraphWitness {
 
 #[cfg(feature = "python-bindings")]
 fn insert_poseidon_hash_pydict(pydict: &PyDict, poseidon_hash: &Vec<Fp>) -> Result<(), PyErr> {
-    let poseidon_hash: Vec<[u64; 4]> = poseidon_hash
+    let poseidon_hash: Vec<String> = poseidon_hash
         .iter()
-        .map(field_to_vecu64_montgomery)
+        .map(field_to_string_montgomery)
         .collect();
     pydict.set_item("poseidon_hash", poseidon_hash)?;
 
@@ -763,18 +763,18 @@ impl GraphCircuit {
         if self.settings().run_args.input_visibility.is_public() {
             public_inputs.rescaled_inputs = elements.rescaled_inputs.clone();
             public_inputs.inputs = elements.inputs.clone();
-        } else if let Some(_) = &data.processed_inputs {
+        } else if data.processed_inputs.is_some() {
             public_inputs.processed_inputs = elements.processed_inputs.clone();
         }
 
-        if let Some(_) = &data.processed_params {
+        if data.processed_params.is_some() {
             public_inputs.processed_params = elements.processed_params.clone();
         }
 
         if self.settings().run_args.output_visibility.is_public() {
             public_inputs.rescaled_outputs = elements.rescaled_outputs.clone();
             public_inputs.outputs = elements.outputs.clone();
-        } else if let Some(_) = &data.processed_outputs {
+        } else if data.processed_outputs.is_some() {
             public_inputs.processed_outputs = elements.processed_outputs.clone();
         }
 
@@ -999,7 +999,6 @@ impl GraphCircuit {
             || min_lookup_inputs < -MAX_LOOKUP_ABS / lookup_safety_margin
         {
             let err_string = format!("max lookup input ({}) is too large", max_lookup_inputs);
-            error!("{}", err_string);
             return Err(err_string.into());
         }
 
@@ -1134,7 +1133,7 @@ impl GraphCircuit {
 
         while (1 << extended_k) < (n * quotient_poly_degree) {
             extended_k += 1;
-            if !(extended_k <= bn256::Fr::S) {
+            if extended_k > bn256::Fr::S {
                 return false;
             }
         }

src/graph/utilities.rs

@@ -71,8 +71,8 @@ pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i12
 pub fn dequantize(felt: Fp, scale: crate::Scale, shift: f64) -> f64 {
     let int_rep = crate::fieldutils::felt_to_i128(felt);
     let multiplier = scale_to_multiplier(scale);
-    let float_rep = int_rep as f64 / multiplier - shift;
-    float_rep
+    
+    int_rep as f64 / multiplier - shift
 }
 
 /// Converts a scale (log base 2) to a fixed point multiplier.

src/pfsys/mod.rs

@@ -11,7 +11,7 @@ use crate::tensor::TensorType;
 use clap::ValueEnum;
 use halo2_proofs::circuit::Value;
 use halo2_proofs::plonk::{
-    create_proof, keygen_pk, keygen_vk, verify_proof, Circuit, ProvingKey, VerifyingKey,
+    create_proof, keygen_pk, keygen_vk_custom, verify_proof, Circuit, ProvingKey, VerifyingKey,
 };
 use halo2_proofs::poly::commitment::{CommitmentScheme, Params, ParamsProver, Prover, Verifier};
 use halo2_proofs::poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG};
@@ -167,8 +167,8 @@ impl ToPyObject for TranscriptType {
 #[cfg(feature = "python-bindings")]
 ///
 pub fn g1affine_to_pydict(g1affine_dict: &PyDict, g1affine: &G1Affine) {
-    let g1affine_x = field_to_vecu64_montgomery(&g1affine.x);
-    let g1affine_y = field_to_vecu64_montgomery(&g1affine.y);
+    let g1affine_x = field_to_string_montgomery(&g1affine.x);
+    let g1affine_y = field_to_string_montgomery(&g1affine.y);
     g1affine_dict.set_item("x", g1affine_x).unwrap();
     g1affine_dict.set_item("y", g1affine_y).unwrap();
 }
@@ -178,24 +178,24 @@ use halo2curves::bn256::G1;
 #[cfg(feature = "python-bindings")]
 ///
 pub fn g1_to_pydict(g1_dict: &PyDict, g1: &G1) {
-    let g1_x = field_to_vecu64_montgomery(&g1.x);
-    let g1_y = field_to_vecu64_montgomery(&g1.y);
-    let g1_z = field_to_vecu64_montgomery(&g1.z);
+    let g1_x = field_to_string_montgomery(&g1.x);
+    let g1_y = field_to_string_montgomery(&g1.y);
+    let g1_z = field_to_string_montgomery(&g1.z);
     g1_dict.set_item("x", g1_x).unwrap();
     g1_dict.set_item("y", g1_y).unwrap();
     g1_dict.set_item("z", g1_z).unwrap();
 }
 
 /// converts fp into `Vec<u64>` in Montgomery form
-pub fn field_to_vecu64_montgomery<F: PrimeField + SerdeObject + Serialize>(fp: &F) -> [u64; 4] {
+pub fn field_to_string_montgomery<F: PrimeField + SerdeObject + Serialize>(fp: &F) -> String {
     let repr = serde_json::to_string(&fp).unwrap();
-    let b: [u64; 4] = serde_json::from_str(&repr).unwrap();
+    let b: String = serde_json::from_str(&repr).unwrap();
     b
 }
 
 /// converts `Vec<u64>` in Montgomery form into fp
-pub fn vecu64_to_field_montgomery<F: PrimeField + SerdeObject + Serialize + DeserializeOwned>(
-    b: &[u64; 4],
+pub fn string_to_field_montgomery<F: PrimeField + SerdeObject + Serialize + DeserializeOwned>(
+    b: &String,
 ) -> F {
     let repr = serde_json::to_string(&b).unwrap();
     let fp: F = serde_json::from_str(&repr).unwrap();
@@ -256,10 +256,10 @@ where
 {
     fn to_object(&self, py: Python) -> PyObject {
         let dict = PyDict::new(py);
-        let field_elems: Vec<Vec<[u64; 4]>> = self
+        let field_elems: Vec<Vec<String>> = self
             .instances
             .iter()
-            .map(|x| x.iter().map(|fp| field_to_vecu64_montgomery(fp)).collect())
+            .map(|x| x.iter().map(|fp| field_to_string_montgomery(fp)).collect())
             .collect::<Vec<_>>();
         dict.set_item("instances", field_elems).unwrap();
         let hex_proof = hex::encode(&self.proof);
@@ -306,6 +306,12 @@ where
         }
     }
 
+    /// create hex proof from proof
+    pub fn create_hex_proof(&mut self) {
+        let hex_proof = hex::encode(&self.proof);
+        self.hex_proof = Some(format!("0x{}", hex_proof));
+    }
+
     /// Saves the Proof to a specified `proof_path`.
     pub fn save(&self, proof_path: &PathBuf) -> Result<(), Box<dyn Error>> {
         let file = std::fs::File::create(proof_path)?;
@@ -427,6 +433,7 @@ where
 pub fn create_keys<Scheme: CommitmentScheme, F: PrimeField + TensorType, C: Circuit<F>>(
     circuit: &C,
     params: &'_ Scheme::ParamsProver,
+    compress_selectors: bool,
 ) -> Result<ProvingKey<Scheme::Curve>, halo2_proofs::plonk::Error>
 where
     C: Circuit<Scheme::Scalar>,
@@ -438,7 +445,7 @@ where
     // Initialize verifying key
     let now = Instant::now();
     trace!("preparing VK");
-    let vk = keygen_vk(params, &empty_circuit)?;
+    let vk = keygen_vk_custom(params, &empty_circuit, compress_selectors)?;
     let elapsed = now.elapsed();
     info!("VK took {}.{}", elapsed.as_secs(), elapsed.subsec_millis());
 
@@ -594,6 +601,7 @@ where
     let mut snark_new = snark.clone();
     // swap the proof bytes for the new ones
     snark_new.proof[..proof_first_bytes.len()].copy_from_slice(&proof_first_bytes);
+    snark_new.create_hex_proof();
 
     Ok(snark_new)
 }

src/python.rs

@@ -30,7 +30,7 @@ use std::str::FromStr;
 use std::{fs::File, path::PathBuf};
 use tokio::runtime::Runtime;
 
-type PyFelt = [u64; 4];
+type PyFelt = String;
 
 #[pyclass]
 #[derive(Debug, Clone)]
@@ -65,9 +65,9 @@ struct PyG1 {
 impl From<G1> for PyG1 {
     fn from(g1: G1) -> Self {
         PyG1 {
-            x: crate::pfsys::field_to_vecu64_montgomery::<Fq>(&g1.x),
-            y: crate::pfsys::field_to_vecu64_montgomery::<Fq>(&g1.y),
-            z: crate::pfsys::field_to_vecu64_montgomery::<Fq>(&g1.z),
+            x: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.x),
+            y: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.y),
+            z: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.z),
         }
     }
 }
@@ -75,9 +75,9 @@ impl From<G1> for PyG1 {
 impl From<PyG1> for G1 {
     fn from(val: PyG1) -> Self {
         G1 {
-            x: crate::pfsys::vecu64_to_field_montgomery::<Fq>(&val.x),
-            y: crate::pfsys::vecu64_to_field_montgomery::<Fq>(&val.y),
-            z: crate::pfsys::vecu64_to_field_montgomery::<Fq>(&val.z),
+            x: crate::pfsys::string_to_field_montgomery::<Fq>(&val.x),
+            y: crate::pfsys::string_to_field_montgomery::<Fq>(&val.y),
+            z: crate::pfsys::string_to_field_montgomery::<Fq>(&val.z),
         }
     }
 }
@@ -108,8 +108,8 @@ pub struct PyG1Affine {
 impl From<G1Affine> for PyG1Affine {
     fn from(g1: G1Affine) -> Self {
         PyG1Affine {
-            x: crate::pfsys::field_to_vecu64_montgomery::<Fq>(&g1.x),
-            y: crate::pfsys::field_to_vecu64_montgomery::<Fq>(&g1.y),
+            x: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.x),
+            y: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.y),
         }
     }
 }
@@ -117,8 +117,8 @@ impl From<G1Affine> for PyG1Affine {
 impl From<PyG1Affine> for G1Affine {
     fn from(val: PyG1Affine) -> Self {
         G1Affine {
-            x: crate::pfsys::vecu64_to_field_montgomery::<Fq>(&val.x),
-            y: crate::pfsys::vecu64_to_field_montgomery::<Fq>(&val.y),
+            x: crate::pfsys::string_to_field_montgomery::<Fq>(&val.x),
+            y: crate::pfsys::string_to_field_montgomery::<Fq>(&val.y),
         }
     }
 }
@@ -211,10 +211,10 @@ impl Into<PyRunArgs> for RunArgs {
 #[pyfunction(signature = (
     array,
 ))]
-fn vecu64_to_felt(array: PyFelt) -> PyResult<String> {
+fn string_to_felt(array: PyFelt) -> PyResult<String> {
     Ok(format!(
         "{:?}",
-        crate::pfsys::vecu64_to_field_montgomery::<Fr>(&array)
+        crate::pfsys::string_to_field_montgomery::<Fr>(&array)
     ))
 }
 
@@ -222,8 +222,8 @@ fn vecu64_to_felt(array: PyFelt) -> PyResult<String> {
 #[pyfunction(signature = (
     array,
 ))]
-fn vecu64_to_int(array: PyFelt) -> PyResult<i128> {
-    let felt = crate::pfsys::vecu64_to_field_montgomery::<Fr>(&array);
+fn string_to_int(array: PyFelt) -> PyResult<i128> {
+    let felt = crate::pfsys::string_to_field_montgomery::<Fr>(&array);
     let int_rep = felt_to_i128(felt);
     Ok(int_rep)
 }
@@ -233,8 +233,8 @@ fn vecu64_to_int(array: PyFelt) -> PyResult<i128> {
     array,
     scale
 ))]
-fn vecu64_to_float(array: PyFelt, scale: crate::Scale) -> PyResult<f64> {
-    let felt = crate::pfsys::vecu64_to_field_montgomery::<Fr>(&array);
+fn string_to_float(array: PyFelt, scale: crate::Scale) -> PyResult<f64> {
+    let felt = crate::pfsys::string_to_field_montgomery::<Fr>(&array);
     let int_rep = felt_to_i128(felt);
     let multiplier = scale_to_multiplier(scale);
     let float_rep = int_rep as f64 / multiplier;
@@ -246,11 +246,11 @@ fn vecu64_to_float(array: PyFelt, scale: crate::Scale) -> PyResult<f64> {
 input,
 scale
 ))]
-fn float_to_vecu64(input: f64, scale: crate::Scale) -> PyResult<PyFelt> {
+fn float_to_string(input: f64, scale: crate::Scale) -> PyResult<PyFelt> {
     let int_rep = quantize_float(&input, 0.0, scale)
         .map_err(|_| PyIOError::new_err("Failed to quantize input"))?;
     let felt = i128_to_felt(int_rep);
-    Ok(crate::pfsys::field_to_vecu64_montgomery::<Fr>(&felt))
+    Ok(crate::pfsys::field_to_string_montgomery::<Fr>(&felt))
 }
 
 /// Converts a buffer to vector of 4 u64s representing a fixed point field element
@@ -318,7 +318,7 @@ fn buffer_to_felts(buffer: Vec<u8>) -> PyResult<Vec<String>> {
 fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {
     let message: Vec<Fr> = message
         .iter()
-        .map(crate::pfsys::vecu64_to_field_montgomery::<Fr>)
+        .map(crate::pfsys::string_to_field_montgomery::<Fr>)
         .collect::<Vec<_>>();
 
     let output =
@@ -329,7 +329,7 @@ fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {
 
     let hash = output[0]
         .iter()
-        .map(crate::pfsys::field_to_vecu64_montgomery::<Fr>)
+        .map(crate::pfsys::field_to_string_montgomery::<Fr>)
         .collect::<Vec<_>>();
     Ok(hash)
 }
@@ -337,8 +337,8 @@ fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {
 /// Generate a kzg commitment.
 #[pyfunction(signature = (
     message,
-    vk_path,
-    settings_path,
+    vk_path=PathBuf::from(DEFAULT_VK),
+    settings_path=PathBuf::from(DEFAULT_SETTINGS),
     srs_path=None
     ))]
 fn kzg_commit(
@@ -349,7 +349,7 @@ fn kzg_commit(
 ) -> PyResult<Vec<PyG1Affine>> {
     let message: Vec<Fr> = message
         .iter()
-        .map(crate::pfsys::vecu64_to_field_montgomery::<Fr>)
+        .map(crate::pfsys::string_to_field_montgomery::<Fr>)
         .collect::<Vec<_>>();
 
     let settings = GraphSettings::load(&settings_path)
@@ -387,9 +387,9 @@ fn swap_proof_commitments(proof_path: PathBuf, witness_path: PathBuf) -> PyResul
 
 /// Generates a vk from a pk for a model circuit and saves it to a file
 #[pyfunction(signature = (
-    path_to_pk,
-    circuit_settings_path,
-    vk_output_path
+    path_to_pk=PathBuf::from(DEFAULT_PK),
+    circuit_settings_path=PathBuf::from(DEFAULT_SETTINGS),
+    vk_output_path=PathBuf::from(DEFAULT_VK),
     ))]
 fn gen_vk_from_pk_single(
     path_to_pk: PathBuf,
@@ -413,8 +413,8 @@ fn gen_vk_from_pk_single(
 
 /// Generates a vk from a pk for an aggregate circuit and saves it to a file
 #[pyfunction(signature = (
-    path_to_pk,
-    vk_output_path
+    path_to_pk=PathBuf::from(DEFAULT_PK_AGGREGATED),
+    vk_output_path=PathBuf::from(DEFAULT_VK_AGGREGATED),
     ))]
 fn gen_vk_from_pk_aggr(path_to_pk: PathBuf, vk_output_path: PathBuf) -> PyResult<bool> {
     let pk = load_pk::<KZGCommitmentScheme<Bn256>, Fr, AggregationCircuit>(path_to_pk, ())
@@ -543,7 +543,7 @@ fn calibrate_settings(
 #[pyfunction(signature = (
     data=PathBuf::from(DEFAULT_DATA),
     model=PathBuf::from(DEFAULT_MODEL),
-    output=None,
+    output=PathBuf::from(DEFAULT_WITNESS),
     vk_path=None,
     srs_path=None,
 ))]
@@ -604,7 +604,8 @@ fn mock_aggregate(
     vk_path=PathBuf::from(DEFAULT_VK),
     pk_path=PathBuf::from(DEFAULT_PK),
     srs_path=None,
-    witness_path = None
+    witness_path = None,
+    compress_selectors=DEFAULT_COMPRESS_SELECTORS.parse().unwrap(),
 ))]
 fn setup(
     model: PathBuf,
@@ -612,8 +613,17 @@ fn setup(
     pk_path: PathBuf,
     srs_path: Option<PathBuf>,
     witness_path: Option<PathBuf>,
+    compress_selectors: bool,
 ) -> Result<bool, PyErr> {
-    crate::execute::setup(model, srs_path, vk_path, pk_path, witness_path).map_err(|e| {
+    crate::execute::setup(
+        model,
+        srs_path,
+        vk_path,
+        pk_path,
+        witness_path,
+        compress_selectors,
+    )
+    .map_err(|e| {
         let err_str = format!("Failed to run setup: {}", e);
         PyRuntimeError::new_err(err_str)
     })?;
@@ -682,7 +692,8 @@ fn verify(
     pk_path=PathBuf::from(DEFAULT_PK_AGGREGATED),
     logrows=DEFAULT_AGGREGATED_LOGROWS.parse().unwrap(),
     split_proofs = false,
-    srs_path = None
+    srs_path = None,
+    compress_selectors=DEFAULT_COMPRESS_SELECTORS.parse().unwrap(),
 ))]
 fn setup_aggregate(
     sample_snarks: Vec<PathBuf>,
@@ -691,6 +702,7 @@ fn setup_aggregate(
     logrows: u32,
     split_proofs: bool,
     srs_path: Option<PathBuf>,
+    compress_selectors: bool,
 ) -> Result<bool, PyErr> {
     crate::execute::setup_aggregate(
         sample_snarks,
@@ -699,6 +711,7 @@ fn setup_aggregate(
         srs_path,
         logrows,
         split_proofs,
+        compress_selectors,
     )
     .map_err(|e| {
         let err_str = format!("Failed to setup aggregate: {}", e);
@@ -794,6 +807,7 @@ fn verify_aggr(
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE),
     abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
     srs_path=None,
+    render_vk_seperately = DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap(),
 ))]
 fn create_evm_verifier(
     vk_path: PathBuf,
@@ -801,12 +815,20 @@ fn create_evm_verifier(
     sol_code_path: PathBuf,
     abi_path: PathBuf,
     srs_path: Option<PathBuf>,
+    render_vk_seperately: bool,
 ) -> Result<bool, PyErr> {
-    crate::execute::create_evm_verifier(vk_path, srs_path, settings_path, sol_code_path, abi_path)
-        .map_err(|e| {
-            let err_str = format!("Failed to run create_evm_verifier: {}", e);
-            PyRuntimeError::new_err(err_str)
-        })?;
+    crate::execute::create_evm_verifier(
+        vk_path,
+        srs_path,
+        settings_path,
+        sol_code_path,
+        abi_path,
+        render_vk_seperately,
+    )
+    .map_err(|e| {
+        let err_str = format!("Failed to run create_evm_verifier: {}", e);
+        PyRuntimeError::new_err(err_str)
+    })?;
 
     Ok(true)
 }
@@ -872,7 +894,7 @@ fn setup_test_evm_witness(
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE),
     rpc_url=None,
     optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
-    private_key=None
+    private_key=None,
 ))]
 fn deploy_evm(
     addr_path: PathBuf,
@@ -889,6 +911,39 @@ fn deploy_evm(
             addr_path,
             optimizer_runs,
             private_key,
+            "Halo2Verifier",
+        ))
+        .map_err(|e| {
+            let err_str = format!("Failed to run deploy_evm: {}", e);
+            PyRuntimeError::new_err(err_str)
+        })?;
+
+    Ok(true)
+}
+
+#[pyfunction(signature = (
+    addr_path,
+    sol_code_path=PathBuf::from(DEFAULT_VK_SOL),
+    rpc_url=None,
+    optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
+    private_key=None,
+))]
+fn deploy_vk_evm(
+    addr_path: PathBuf,
+    sol_code_path: PathBuf,
+    rpc_url: Option<String>,
+    optimizer_runs: usize,
+    private_key: Option<String>,
+) -> Result<bool, PyErr> {
+    Runtime::new()
+        .unwrap()
+        .block_on(crate::execute::deploy_evm(
+            sol_code_path,
+            rpc_url,
+            addr_path,
+            optimizer_runs,
+            private_key,
+            "Halo2VerifyingKey",
         ))
         .map_err(|e| {
             let err_str = format!("Failed to run deploy_evm: {}", e);
@@ -940,12 +995,14 @@ fn deploy_da_evm(
     proof_path=PathBuf::from(DEFAULT_PROOF),
     rpc_url=None,
     addr_da = None,
+    addr_vk = None,
 ))]
 fn verify_evm(
     addr_verifier: &str,
     proof_path: PathBuf,
     rpc_url: Option<String>,
     addr_da: Option<&str>,
+    addr_vk: Option<&str>,
 ) -> Result<bool, PyErr> {
     let addr_verifier = H160::from_str(addr_verifier).map_err(|e| {
         let err_str = format!("address is invalid: {}", e);
@@ -960,6 +1017,15 @@ fn verify_evm(
     } else {
         None
     };
+    let addr_vk = if let Some(addr_vk) = addr_vk {
+        let addr_vk = H160::from_str(addr_vk).map_err(|e| {
+            let err_str = format!("address is invalid: {}", e);
+            PyRuntimeError::new_err(err_str)
+        })?;
+        Some(addr_vk)
+    } else {
+        None
+    };
 
     Runtime::new()
         .unwrap()
@@ -968,6 +1034,7 @@ fn verify_evm(
             addr_verifier,
             rpc_url,
             addr_da,
+            addr_vk,
         ))
         .map_err(|e| {
             let err_str = format!("Failed to run verify_evm: {}", e);
@@ -985,6 +1052,7 @@ fn verify_evm(
     abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
     logrows=DEFAULT_AGGREGATED_LOGROWS.parse().unwrap(),
     srs_path=None,
+    render_vk_seperately = DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap(),
 ))]
 fn create_evm_verifier_aggr(
     aggregation_settings: Vec<PathBuf>,
@@ -993,6 +1061,7 @@ fn create_evm_verifier_aggr(
     abi_path: PathBuf,
     logrows: u32,
     srs_path: Option<PathBuf>,
+    render_vk_seperately: bool,
 ) -> Result<bool, PyErr> {
     crate::execute::create_evm_aggregate_verifier(
         vk_path,
@@ -1001,6 +1070,7 @@ fn create_evm_verifier_aggr(
         abi_path,
         aggregation_settings,
         logrows,
+        render_vk_seperately,
     )
     .map_err(|e| {
         let err_str = format!("Failed to run create_evm_verifier_aggr: {}", e);
@@ -1027,13 +1097,13 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_class::<PyG1Affine>()?;
     m.add_class::<PyG1>()?;
     m.add_class::<PyTestDataSource>()?;
-    m.add_function(wrap_pyfunction!(vecu64_to_felt, m)?)?;
-    m.add_function(wrap_pyfunction!(vecu64_to_int, m)?)?;
-    m.add_function(wrap_pyfunction!(vecu64_to_float, m)?)?;
+    m.add_function(wrap_pyfunction!(string_to_felt, m)?)?;
+    m.add_function(wrap_pyfunction!(string_to_int, m)?)?;
+    m.add_function(wrap_pyfunction!(string_to_float, m)?)?;
     m.add_function(wrap_pyfunction!(kzg_commit, m)?)?;
     m.add_function(wrap_pyfunction!(swap_proof_commitments, m)?)?;
     m.add_function(wrap_pyfunction!(poseidon_hash, m)?)?;
-    m.add_function(wrap_pyfunction!(float_to_vecu64, m)?)?;
+    m.add_function(wrap_pyfunction!(float_to_string, m)?)?;
     m.add_function(wrap_pyfunction!(buffer_to_felts, m)?)?;
     m.add_function(wrap_pyfunction!(gen_vk_from_pk_aggr, m)?)?;
     m.add_function(wrap_pyfunction!(gen_vk_from_pk_single, m)?)?;
@@ -1054,6 +1124,7 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(verify_aggr, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier, m)?)?;
     m.add_function(wrap_pyfunction!(deploy_evm, m)?)?;
+    m.add_function(wrap_pyfunction!(deploy_vk_evm, m)?)?;
     m.add_function(wrap_pyfunction!(deploy_da_evm, m)?)?;
     m.add_function(wrap_pyfunction!(verify_evm, m)?)?;
     m.add_function(wrap_pyfunction!(print_proof_hex, m)?)?;

src/wasm.rs

@@ -72,7 +72,7 @@ pub fn encodeVerifierCalldata(
 /// Converts 4 u64s to a field element
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn vecU64ToFelt(array: wasm_bindgen::Clamped<Vec<u8>>) -> Result<String, JsError> {
+pub fn stringToFelt(array: wasm_bindgen::Clamped<Vec<u8>>) -> Result<String, JsError> {
     let felt: Fr = serde_json::from_slice(&array[..])
         .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
     Ok(format!("{:?}", felt))
@@ -81,7 +81,7 @@ pub fn vecU64ToFelt(array: wasm_bindgen::Clamped<Vec<u8>>) -> Result<String, JsE
 /// Converts 4 u64s representing a field element directly to an integer
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn vecU64ToInt(
+pub fn stringToInt(
     array: wasm_bindgen::Clamped<Vec<u8>>,
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
     let felt: Fr = serde_json::from_slice(&array[..])
@@ -95,7 +95,7 @@ pub fn vecU64ToInt(
 /// Converts 4 u64s representing a field element directly to a (rescaled from fixed point scaling) floating point
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn vecU64ToFloat(
+pub fn stringToFloat(
     array: wasm_bindgen::Clamped<Vec<u8>>,
     scale: crate::Scale,
 ) -> Result<f64, JsError> {
@@ -109,23 +109,23 @@ pub fn vecU64ToFloat(
 /// Converts a floating point element to 4 u64s representing a fixed point field element
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn floatToVecU64(
+pub fn floatTostring(
     input: f64,
     scale: crate::Scale,
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
     let int_rep =
         quantize_float(&input, 0.0, scale).map_err(|e| JsError::new(&format!("{}", e)))?;
     let felt = i128_to_felt(int_rep);
-    let vec = crate::pfsys::field_to_vecu64_montgomery::<halo2curves::bn256::Fr>(&felt);
+    let vec = crate::pfsys::field_to_string_montgomery::<halo2curves::bn256::Fr>(&felt);
     Ok(wasm_bindgen::Clamped(serde_json::to_vec(&vec).map_err(
-        |e| JsError::new(&format!("Failed to serialize vecu64_montgomery{}", e)),
+        |e| JsError::new(&format!("Failed to serialize string_montgomery{}", e)),
     )?))
 }
 
 /// Converts a buffer to vector of 4 u64s representing a fixed point field element
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn bufferToVecOfVecU64(
+pub fn bufferToVecOfstring(
     buffer: wasm_bindgen::Clamped<Vec<u8>>,
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
     // Convert the buffer to a slice
@@ -224,6 +224,7 @@ pub fn genWitness(
 pub fn genVk(
     compiled_circuit: wasm_bindgen::Clamped<Vec<u8>>,
     params_ser: wasm_bindgen::Clamped<Vec<u8>>,
+    compress_selectors: bool,
 ) -> Result<Vec<u8>, JsError> {
     // Read in kzg params
     let mut reader = std::io::BufReader::new(&params_ser[..]);
@@ -235,9 +236,13 @@ pub fn genVk(
         .map_err(|e| JsError::new(&format!("Failed to deserialize compiled model: {}", e)))?;
 
     // Create verifying key
-    let vk = create_vk_wasm::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(&circuit, &params)
-        .map_err(Box::<dyn std::error::Error>::from)
-        .map_err(|e| JsError::new(&format!("Failed to create verifying key: {}", e)))?;
+    let vk = create_vk_wasm::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
+        &circuit,
+        &params,
+        compress_selectors,
+    )
+    .map_err(Box::<dyn std::error::Error>::from)
+    .map_err(|e| JsError::new(&format!("Failed to create verifying key: {}", e)))?;
 
     let mut serialized_vk = Vec::new();
     vk.write(&mut serialized_vk, halo2_proofs::SerdeFormat::RawBytes)
@@ -497,6 +502,7 @@ pub fn srsValidation(srs: wasm_bindgen::Clamped<Vec<u8>>) -> Result<bool, JsErro
 pub fn create_vk_wasm<Scheme: CommitmentScheme, F: PrimeField + TensorType, C: Circuit<F>>(
     circuit: &C,
     params: &'_ Scheme::ParamsProver,
+    compress_selectors: bool,
 ) -> Result<VerifyingKey<Scheme::Curve>, halo2_proofs::plonk::Error>
 where
     C: Circuit<Scheme::Scalar>,
@@ -506,7 +512,7 @@ where
     let empty_circuit = <C as Circuit<F>>::without_witnesses(circuit);
 
     // Initialize the verifying key
-    let vk = keygen_vk(params, &empty_circuit)?;
+    let vk = keygen_vk_custom(params, &empty_circuit, compress_selectors)?;
     Ok(vk)
 }
 /// Creates a [ProvingKey] from a [VerifyingKey] for a [GraphCircuit] (`circuit`) with specific [CommitmentScheme] parameters (`params`) for the WASM target

tests/integration_tests.rs

@@ -170,9 +170,9 @@ mod native_tests {
         }
     }
 
-    const PF_FAILURE: &str = "examples/test_failure.proof";
+    const PF_FAILURE: &str = "examples/test_failure_proof.json";
 
-    const PF_FAILURE_AGGR: &str = "examples/test_failure_aggr.proof";
+    const PF_FAILURE_AGGR: &str = "examples/test_failure_aggr_proof.json";
 
     const LARGE_TESTS: [&str; 5] = [
         "self_attention",
@@ -360,7 +360,7 @@ mod native_tests {
     #[cfg(feature = "icicle")]
     const TESTS_AGGR: [&str; 3] = ["1l_mlp", "1l_flatten", "1l_average"];
 
-    const TESTS_EVM: [&str; 21] = [
+    const TESTS_EVM: [&str; 23] = [
         "1l_mlp",
         "1l_flatten",
         "1l_average",
@@ -376,12 +376,14 @@ mod native_tests {
         "1l_tanh",
         "2l_relu_sigmoid_small",
         "2l_relu_small",
-        "2l_relu_fc",
         "min",
         "max",
         "1l_max_pool",
         "idolmodel",
         "1l_identity",
+        "lstm",
+        "rnn",
+        "quantize_dequantize",
     ];
 
     const TESTS_EVM_AGGR: [&str; 18] = [
@@ -880,7 +882,8 @@ mod native_tests {
             use crate::native_tests::TESTS_EVM_AGGR;
             use test_case::test_case;
             use crate::native_tests::kzg_evm_prove_and_verify;
-            use crate::native_tests::run_js_tests;
+            use crate::native_tests::kzg_evm_prove_and_verify_render_seperately;
+            
             use crate::native_tests::kzg_evm_on_chain_input_prove_and_verify;
             use crate::native_tests::kzg_evm_aggr_prove_and_verify;
             use crate::native_tests::kzg_fuzz;
@@ -955,7 +958,7 @@ mod native_tests {
             });
 
 
-            seq!(N in 0..= 17 {
+            seq!(N in 0..=17 {
                 // these take a particularly long time to run
                 #(#[test_case(TESTS_EVM_AGGR[N])])*
                 #[ignore]
@@ -971,7 +974,7 @@ mod native_tests {
             });
 
 
-            seq!(N in 0..= 20 {
+            seq!(N in 0..=22 {
 
                 #(#[test_case(TESTS_EVM[N])])*
                 fn kzg_evm_prove_and_verify_(test: &str) {
@@ -979,9 +982,22 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                     let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
-                    kzg_evm_prove_and_verify(path, test.to_string(), "private", "private", "public");
-                    #[cfg(not(feature = "icicle"))]
-                    run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    kzg_evm_prove_and_verify(2, path, test.to_string(), "private", "private", "public");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    test_dir.close().unwrap();
+
+                }
+
+                #(#[test_case(TESTS_EVM[N])])*
+                fn kzg_evm_prove_and_verify_render_seperately_(test: &str) {
+                    crate::native_tests::init_binary();
+                    let test_dir = TempDir::new(test).unwrap();
+                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                    let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
+                    kzg_evm_prove_and_verify_render_seperately(2, path, test.to_string(), "private", "private", "public");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
                     test_dir.close().unwrap();
 
                 }
@@ -993,9 +1009,9 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                     let mut _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
-                    kzg_evm_prove_and_verify(path, test.to_string(), "hashed", "private", "private");
-                    #[cfg(not(feature = "icicle"))]
-                    run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    kzg_evm_prove_and_verify(2, path, test.to_string(), "hashed", "private", "private");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
                     test_dir.close().unwrap();
                 }
 
@@ -1010,9 +1026,9 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                     let mut _anvil_child = crate::native_tests::start_anvil(false, hardfork);
-                    kzg_evm_prove_and_verify(path, test.to_string(), "kzgcommit", "private", "public");
-                    #[cfg(not(feature = "icicle"))]
-                    run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    kzg_evm_prove_and_verify(2, path, test.to_string(), "kzgcommit", "private", "public");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
                     test_dir.close().unwrap();
                 }
 
@@ -1023,9 +1039,9 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                     let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
-                    kzg_evm_prove_and_verify(path, test.to_string(), "private", "hashed", "public");
-                    #[cfg(not(feature = "icicle"))]
-                    run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    kzg_evm_prove_and_verify(2, path, test.to_string(), "private", "hashed", "public");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
                     test_dir.close().unwrap();
 
                 }
@@ -1036,9 +1052,9 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                     let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
-                    kzg_evm_prove_and_verify(path, test.to_string(), "private", "private", "hashed");
-                    #[cfg(not(feature = "icicle"))]
-                    run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    kzg_evm_prove_and_verify(2, path, test.to_string(), "private", "private", "hashed");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
                     test_dir.close().unwrap();
                 }
 
@@ -1049,9 +1065,9 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                     let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
-                    kzg_evm_prove_and_verify(path, test.to_string(), "private", "kzgcommit", "public");
-                    #[cfg(not(feature = "icicle"))]
-                    run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    kzg_evm_prove_and_verify(2, path, test.to_string(), "private", "kzgcommit", "public");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
                     test_dir.close().unwrap();
                 }
 
@@ -1062,9 +1078,9 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                     let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
-                    kzg_evm_prove_and_verify(path, test.to_string(), "private", "private", "kzgcommit");
-                    #[cfg(not(feature = "icicle"))]
-                    run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    kzg_evm_prove_and_verify(2, path, test.to_string(), "private", "private", "kzgcommit");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
                     test_dir.close().unwrap();
                 }
 
@@ -1074,9 +1090,9 @@ mod native_tests {
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                     let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
-                    kzg_evm_prove_and_verify(path, test.to_string(), "kzgcommit", "kzgcommit", "kzgcommit");
-                    #[cfg(not(feature = "icicle"))]
-                    run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    kzg_evm_prove_and_verify(2, path, test.to_string(), "kzgcommit", "kzgcommit", "kzgcommit");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
                     test_dir.close().unwrap();
                 }
 
@@ -1740,6 +1756,7 @@ mod native_tests {
 
     // prove-serialize-verify, the usual full path
     fn kzg_evm_prove_and_verify(
+        num_inner_columns: usize,
         test_dir: &str,
         example_name: String,
         input_visibility: &str,
@@ -1755,7 +1772,7 @@ mod native_tests {
             input_visibility,
             param_visibility,
             output_visibility,
-            2,
+            num_inner_columns,
             None,
             false,
             "single",
@@ -1830,6 +1847,137 @@ mod native_tests {
         assert!(!status.success());
     }
 
+    // prove-serialize-verify, the usual full path
+    fn kzg_evm_prove_and_verify_render_seperately(
+        num_inner_columns: usize,
+        test_dir: &str,
+        example_name: String,
+        input_visibility: &str,
+        param_visibility: &str,
+        output_visibility: &str,
+    ) {
+        let anvil_url = ANVIL_URL.as_str();
+
+        kzg_prove_and_verify(
+            test_dir,
+            example_name.clone(),
+            "safe",
+            input_visibility,
+            param_visibility,
+            output_visibility,
+            num_inner_columns,
+            None,
+            false,
+            "single",
+        );
+
+        let settings_path = format!("{}/{}/settings.json", test_dir, example_name);
+        init_params(settings_path.clone().into());
+
+        let vk_arg = format!("{}/{}/key.vk", test_dir, example_name);
+        let rpc_arg = format!("--rpc-url={}", anvil_url);
+        let addr_path_arg = format!("--addr-path={}/{}/addr.txt", test_dir, example_name);
+        let settings_arg = format!("--settings-path={}", settings_path);
+        let sol_arg = format!("--sol-code-path={}/{}/kzg.sol", test_dir, example_name);
+
+        // create the verifier
+        let args = vec![
+            "create-evm-verifier",
+            "--vk-path",
+            &vk_arg,
+            &settings_arg,
+            &sol_arg,
+            "--render-vk-seperately",
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+
+        let addr_path_arg_vk = format!("--addr-path={}/{}/addr_vk.txt", test_dir, example_name);
+        let sol_arg_vk = format!("--sol-code-path={}/{}/vk.sol", test_dir, example_name);
+        // create the verifier
+        let args = vec![
+            "create-evm-vk",
+            "--vk-path",
+            &vk_arg,
+            &settings_arg,
+            &sol_arg_vk,
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+
+        // deploy the verifier
+        let args = vec![
+            "deploy-evm-verifier",
+            rpc_arg.as_str(),
+            addr_path_arg.as_str(),
+            sol_arg.as_str(),
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+
+        // read in the address
+        let addr = std::fs::read_to_string(format!("{}/{}/addr.txt", test_dir, example_name))
+            .expect("failed to read address file");
+
+        let deployed_addr_arg = format!("--addr-verifier={}", addr);
+
+        // deploy the vk
+        let args = vec![
+            "deploy-evm-vk",
+            rpc_arg.as_str(),
+            addr_path_arg_vk.as_str(),
+            sol_arg_vk.as_str(),
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+
+        // read in the address
+        let addr_vk = std::fs::read_to_string(format!("{}/{}/addr_vk.txt", test_dir, example_name))
+            .expect("failed to read address file");
+
+        let deployed_addr_arg_vk = format!("--addr-vk={}", addr_vk);
+
+        // now verify the proof
+        let pf_arg = format!("{}/{}/proof.pf", test_dir, example_name);
+        let mut args = vec![
+            "verify-evm",
+            "--proof-path",
+            pf_arg.as_str(),
+            rpc_arg.as_str(),
+            deployed_addr_arg.as_str(),
+            deployed_addr_arg_vk.as_str(),
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+        // As sanity check, add example that should fail.
+        args[2] = PF_FAILURE;
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(args)
+            .status()
+            .expect("failed to execute process");
+        assert!(!status.success());
+    }
+
     // run js browser evm verify tests for a given example
     fn run_js_tests(test_dir: &str, example_name: String, js_test: &str) {
         let status = Command::new("pnpm")

tests/output_comparison.py

@@ -12,7 +12,7 @@ def get_ezkl_output(witness_file, settings_file):
     outputs = witness_output['outputs']
     with open(settings_file) as f:
         settings = json.load(f)
-    ezkl_outputs = [[ezkl.vecu64_to_float(
+    ezkl_outputs = [[ezkl.string_to_float(
         outputs[i][j], settings['model_output_scales'][i]) for j in range(len(outputs[i]))] for i in range(len(outputs))]
     return ezkl_outputs
 

tests/py_integration_tests.rs

@@ -118,38 +118,38 @@ mod py_tests {
     }
 
     const TESTS: [&str; 32] = [
+        "proof_splitting.ipynb", // 0
         "variance.ipynb",
-        "proof_splitting.ipynb",
-        "mnist_gan_proof_splitting.ipynb",
         "mnist_gan.ipynb",
         // "mnist_vae.ipynb",
         "keras_simple_demo.ipynb",
-        "hashed_vis.ipynb",
+        "mnist_gan_proof_splitting.ipynb", // 4
+        "hashed_vis.ipynb",                // 5
         "simple_demo_all_public.ipynb",
         "data_attest.ipynb",
         "little_transformer.ipynb",
         "simple_demo_aggregated_proofs.ipynb",
-        "ezkl_demo.ipynb",
+        "ezkl_demo.ipynb", // 10
         "lstm.ipynb",
         "set_membership.ipynb",
         "decision_tree.ipynb",
         "random_forest.ipynb",
-        "gradient_boosted_trees.ipynb",
+        "gradient_boosted_trees.ipynb", // 15
         "xgboost.ipynb",
         "lightgbm.ipynb",
         "svm.ipynb",
         "simple_demo_public_input_output.ipynb",
-        "simple_demo_public_network_output.ipynb",
+        "simple_demo_public_network_output.ipynb", // 20
         "gcn.ipynb",
         "linear_regression.ipynb",
         "stacked_regression.ipynb",
         "data_attest_hashed.ipynb",
-        "kzg_vis.ipynb",
+        "kzg_vis.ipynb", // 25
         "kmeans.ipynb",
         "solvency.ipynb",
         "sklearn_mlp.ipynb",
         "generalized_inverse.ipynb",
-        "mnist_classifier.ipynb",
+        "mnist_classifier.ipynb", // 30
         "world_rotation.ipynb",
     ];
 

tests/python/binding_tests.py

@@ -56,9 +56,9 @@ def test_poseidon_hash():
     Test for poseidon_hash
     """
     message = [1.0, 2.0, 3.0, 4.0]
-    message = [ezkl.float_to_vecu64(x, 7) for x in message]
+    message = [ezkl.float_to_string(x, 7) for x in message]
     res = ezkl.poseidon_hash(message)
-    assert ezkl.vecu64_to_felt(
+    assert ezkl.string_to_felt(
         res[0]) == "0x0da7e5e5c8877242fa699f586baf770d731defd54f952d4adeb85047a0e32f45"
 
 
@@ -70,14 +70,14 @@ def test_field_serialization():
 
     input = 890
     scale = 7
-    felt = ezkl.float_to_vecu64(input, scale)
-    roundtrip_input = ezkl.vecu64_to_float(felt, scale)
+    felt = ezkl.float_to_string(input, scale)
+    roundtrip_input = ezkl.string_to_float(felt, scale)
     assert input == roundtrip_input
 
     input = -700
     scale = 7
-    felt = ezkl.float_to_vecu64(input, scale)
-    roundtrip_input = ezkl.vecu64_to_float(felt, scale)
+    felt = ezkl.float_to_string(input, scale)
+    roundtrip_input = ezkl.string_to_float(felt, scale)
     assert input == roundtrip_input
 
 

tests/wasm.rs

@@ -8,10 +8,10 @@ mod wasm32 {
     use ezkl::graph::GraphWitness;
     use ezkl::pfsys;
     use ezkl::wasm::{
-        bufferToVecOfVecU64, compiledCircuitValidation, encodeVerifierCalldata, genPk, genVk,
+        bufferToVecOfstring, compiledCircuitValidation, encodeVerifierCalldata, genPk, genVk,
         genWitness, inputValidation, pkValidation, poseidonHash, printProofHex, proofValidation,
-        prove, settingsValidation, srsValidation, u8_array_to_u128_le, vecU64ToFelt, vecU64ToFloat,
-        vecU64ToInt, verify, vkValidation, witnessValidation,
+        prove, settingsValidation, srsValidation, stringToFelt, stringToFloat, stringToInt,
+        u8_array_to_u128_le, verify, vkValidation, witnessValidation,
     };
     use halo2_solidity_verifier::encode_calldata;
     use halo2curves::bn256::{Fr, G1Affine};
@@ -26,7 +26,7 @@ mod wasm32 {
     pub const NETWORK_COMPILED: &[u8] = include_bytes!("../tests/wasm/model.compiled");
     pub const NETWORK: &[u8] = include_bytes!("../tests/wasm/network.onnx");
     pub const INPUT: &[u8] = include_bytes!("../tests/wasm/input.json");
-    pub const PROOF: &[u8] = include_bytes!("../tests/wasm/test.proof");
+    pub const PROOF: &[u8] = include_bytes!("../tests/wasm/proof.json");
     pub const SETTINGS: &[u8] = include_bytes!("../tests/wasm/settings.json");
     pub const PK: &[u8] = include_bytes!("../tests/wasm/pk.key");
     pub const VK: &[u8] = include_bytes!("../tests/wasm/vk.key");
@@ -78,19 +78,19 @@ mod wasm32 {
             let serialized = serde_json::to_vec(&field_element).unwrap();
             let clamped = wasm_bindgen::Clamped(serialized);
             let scale = 2;
-            let floating_point = vecU64ToFloat(clamped.clone(), scale)
+            let floating_point = stringToFloat(clamped.clone(), scale)
                 .map_err(|_| "failed")
                 .unwrap();
             assert_eq!(floating_point, (i as f64) / 4.0);
 
             let integer: i128 = serde_json::from_slice(
-                &vecU64ToInt(clamped.clone()).map_err(|_| "failed").unwrap(),
+                &stringToInt(clamped.clone()).map_err(|_| "failed").unwrap(),
             )
             .unwrap();
             assert_eq!(integer, i as i128);
 
             let hex_string = format!("{:?}", field_element);
-            let returned_string = vecU64ToFelt(clamped).map_err(|_| "failed").unwrap();
+            let returned_string = stringToFelt(clamped).map_err(|_| "failed").unwrap();
             assert_eq!(hex_string, returned_string);
         }
     }
@@ -101,7 +101,7 @@ mod wasm32 {
         let mut buffer = string_high.clone().into_bytes();
         let clamped = wasm_bindgen::Clamped(buffer.clone());
 
-        let field_elements_ser = bufferToVecOfVecU64(clamped).map_err(|_| "failed").unwrap();
+        let field_elements_ser = bufferToVecOfstring(clamped).map_err(|_| "failed").unwrap();
 
         let field_elements: Vec<Fr> = serde_json::from_slice(&field_elements_ser[..]).unwrap();
 
@@ -118,7 +118,7 @@ mod wasm32 {
         let buffer = string_sample.clone().into_bytes();
         let clamped = wasm_bindgen::Clamped(buffer.clone());
 
-        let field_elements_ser = bufferToVecOfVecU64(clamped).map_err(|_| "failed").unwrap();
+        let field_elements_ser = bufferToVecOfstring(clamped).map_err(|_| "failed").unwrap();
 
         let field_elements: Vec<Fr> = serde_json::from_slice(&field_elements_ser[..]).unwrap();
 
@@ -133,7 +133,7 @@ mod wasm32 {
         let buffer = string_concat.into_bytes();
         let clamped = wasm_bindgen::Clamped(buffer.clone());
 
-        let field_elements_ser = bufferToVecOfVecU64(clamped).map_err(|_| "failed").unwrap();
+        let field_elements_ser = bufferToVecOfstring(clamped).map_err(|_| "failed").unwrap();
 
         let field_elements: Vec<Fr> = serde_json::from_slice(&field_elements_ser[..]).unwrap();
 
@@ -186,6 +186,7 @@ mod wasm32 {
         let vk = genVk(
             wasm_bindgen::Clamped(NETWORK_COMPILED.to_vec()),
             wasm_bindgen::Clamped(SRS.to_vec()),
+            true,
         )
         .map_err(|_| "failed")
         .unwrap();
@@ -206,6 +207,7 @@ mod wasm32 {
         let vk = genVk(
             wasm_bindgen::Clamped(NETWORK_COMPILED.to_vec()),
             wasm_bindgen::Clamped(SRS.to_vec()),
+            true,
         )
         .map_err(|_| "failed")
         .unwrap();
@@ -218,6 +220,7 @@ mod wasm32 {
         let vk = genVk(
             wasm_bindgen::Clamped(NETWORK_COMPILED.to_vec()),
             wasm_bindgen::Clamped(SRS.to_vec()),
+            true,
         )
         .map_err(|_| "failed")
         .unwrap();

tests/wasm/utils.ts

@@ -1,7 +1,6 @@
 import * as fs from 'fs/promises';
 import * as fsSync from 'fs'
 import JSONBig from 'json-bigint';
-import { vecU64ToFelt } from '@ezkljs/engine/nodejs'
 const solc = require('solc');
 
 // import os module

tests/wasm/witness.json

@@ -1 +1 @@
-{"inputs":[[[6425625360762666998,7924344314350639699,14762033076929465436,2023505479389396574],[12436184717236109307,3962172157175319849,7381016538464732718,1011752739694698287],[12436184717236109307,3962172157175319849,7381016538464732718,1011752739694698287]]],"pretty_elements":{"rescaled_inputs":[["2","1","1"]],"inputs":[["0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000001"]],"processed_inputs":[],"processed_params":[],"processed_outputs":[],"rescaled_outputs":[["0","0","0","0"]],"outputs":[["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"]]},"outputs":[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],"processed_inputs":null,"processed_params":null,"processed_outputs":null,"max_lookup_inputs":0,"min_lookup_inputs":-1}
+{"inputs":[["0200000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000"]],"pretty_elements":{"rescaled_inputs":[["2","1","1"]],"inputs":[["0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000001"]],"processed_inputs":[],"processed_params":[],"processed_outputs":[],"rescaled_outputs":[["0","0","0","0"]],"outputs":[["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"]]},"outputs":[["0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000"]],"processed_inputs":null,"processed_params":null,"processed_outputs":null,"max_lookup_inputs":0,"min_lookup_inputs":-1}