chore(rln-wasm): save this commit for later benchmark in html and wasm-bindgen-test in a seperate branch

.github/workflows/ci.yml

@@ -24,8 +24,8 @@ jobs:
   utils-test:
     strategy:
       matrix:
-        platform: [ ubuntu-latest, macos-latest ]
-        crate: [ utils ]
+        platform: [ubuntu-latest, macos-latest]
+        crate: [utils]
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 60
 
@@ -50,9 +50,9 @@ jobs:
   rln-test:
     strategy:
       matrix:
-        platform: [ ubuntu-latest, macos-latest ]
-        crate: [ rln ]
-        feature: [ "default", "arkzkey", "stateless" ]
+        platform: [ubuntu-latest, macos-latest]
+        crate: [rln]
+        feature: ["default", "arkzkey", "stateless"]
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 60
 
@@ -78,15 +78,16 @@ jobs:
           fi
         working-directory: ${{ matrix.crate }}
 
-  rln-wasm:
+  rln-wasm-test:
     strategy:
       matrix:
-        platform: [ ubuntu-latest, macos-latest ]
-        feature: [ "default", "arkzkey" ]
+        platform: [ubuntu-latest, macos-latest]
+        crate: [rln-wasm]
+        feature: ["default", "arkzkey"]
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 60
 
-    name: test - rln-wasm - ${{ matrix.platform }} - ${{ matrix.feature }}
+    name: test - ${{ matrix.crate }} - ${{ matrix.platform }} - ${{ matrix.feature }}
     steps:
       - uses: actions/checkout@v3
       - name: Install stable toolchain
@@ -105,7 +106,7 @@ jobs:
           else
             cargo make build_${{ matrix.feature }}
           fi
-        working-directory: rln-wasm
+        working-directory: ${{ matrix.crate }}
       - name: cargo-make test
         run: |
           if [ ${{ matrix.feature }} == default ]; then
@@ -113,14 +114,62 @@ jobs:
           else
             cargo make test_${{ matrix.feature }} --release
           fi
-        working-directory: rln-wasm
+        working-directory: ${{ matrix.crate }}
+      - name: cargo-make test browser
+        run: |
+          if [ ${{ matrix.feature }} == default ]; then
+            cargo make test_browser --release
+          else
+            cargo make test_browser_${{ matrix.feature }} --release
+          fi
+        working-directory: ${{ matrix.crate }}
+
+  rln-wasm-multihread-test:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+        crate: [rln-wasm]
+        feature: ["multithread", "multithread_arkzkey"]
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 60
+
+    name: test - ${{ matrix.crate }} - ${{ matrix.platform }} - ${{ matrix.feature }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install nightly toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+          components: rust-src
+          target: wasm32-unknown-unknown
+      - uses: Swatinem/rust-cache@v2
+      - name: Install Dependencies
+        run: make installdeps
+      - name: cargo-make build
+        run: |
+          if [ ${{ matrix.feature }} == default ]; then
+            cargo make build
+          else
+            cargo make build_${{ matrix.feature }}
+          fi
+        working-directory: ${{ matrix.crate }}
+      - name: cargo-make test
+        run: |
+          if [ ${{ matrix.feature }} == default ]; then
+            cargo make test --release
+          else
+            cargo make test_${{ matrix.feature }} --release
+          fi
+        working-directory: ${{ matrix.crate }}
 
   lint:
     strategy:
       matrix:
         # we run lint tests only on ubuntu
-        platform: [ ubuntu-latest ]
-        crate: [ rln, rln-wasm, utils ]
+        platform: [ubuntu-latest]
+        crate: [rln, rln-wasm, utils]
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 60
 
@@ -154,12 +203,12 @@ jobs:
     strategy:
       matrix:
         # we run benchmark tests only on ubuntu
-        platform: [ ubuntu-latest ]
-        crate: [ utils ]
+        platform: [ubuntu-latest]
+        crate: [utils]
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 60
 
-    name: benchmark - ${{ matrix.platform }} - ${{ matrix.crate }}
+    name: benchmark - ${{ matrix.crate }} - ${{ matrix.platform }}
     steps:
       - name: Checkout sources
         uses: actions/checkout@v3
@@ -175,13 +224,13 @@ jobs:
     strategy:
       matrix:
         # we run benchmark tests only on ubuntu
-        platform: [ ubuntu-latest ]
-        crate: [ rln ]
-        feature: [ "default", "arkzkey" ]
+        platform: [ubuntu-latest]
+        crate: [rln]
+        feature: ["default", "arkzkey"]
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 60
 
-    name: benchmark - ${{ matrix.platform }} - ${{ matrix.crate }} - ${{ matrix.feature }}
+    name: benchmark - ${{ matrix.crate }} - ${{ matrix.platform }} - ${{ matrix.feature }}
     steps:
       - name: Checkout sources
         uses: actions/checkout@v3
@@ -190,4 +239,4 @@ jobs:
         with:
           branchName: ${{ github.base_ref }}
           cwd: ${{ matrix.crate }}
-          features: ${{ matrix.feature }}
+          features: ${{ matrix.feature }}

Cargo.lock

@@ -802,6 +802,15 @@ dependencies = [
  "itertools 0.10.5",
 ]
 
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.6"
@@ -1638,6 +1647,7 @@ checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
  "crossbeam-deque",
  "crossbeam-utils",
+ "wasm_sync",
 ]
 
 [[package]]
@@ -1737,7 +1747,9 @@ dependencies = [
  "serde_json",
  "wasm-bindgen",
  "wasm-bindgen-futures",
+ "wasm-bindgen-rayon",
  "wasm-bindgen-test",
+ "web-sys",
  "zerokit_utils",
 ]
 
@@ -2292,6 +2304,18 @@ dependencies = [
  "wasm-bindgen-shared",
 ]
 
+[[package]]
+name = "wasm-bindgen-rayon"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9beda8dfdfaf2e0ec0b47e130a0794d18188fba4da8a2155dcc3bbeb7e0d454"
+dependencies = [
+ "crossbeam-channel",
+ "js-sys",
+ "rayon-core",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "wasm-bindgen-shared"
 version = "0.2.100"
@@ -2325,6 +2349,17 @@ dependencies = [
  "syn 2.0.100",
 ]
 
+[[package]]
+name = "wasm_sync"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff360cade7fec41ff0e9d2cda57fe58258c5f16def0e21302394659e6bbb0ea"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.77"

Makefile

@@ -1,6 +1,6 @@
 .PHONY: all installdeps build test bench clean
 
-all: .pre-build build
+all: installdeps build
 
 .fetch-submodules:
 	@git submodule update --init --recursive
@@ -19,6 +19,7 @@ else ifeq ($(shell uname),Linux)
 	@sudo apt-get update
 	@sudo apt-get install -y cmake ninja-build
 endif
+	@cargo install wasm-bindgen-cli
 	@if [ ! -d "$$HOME/.nvm" ]; then \
 		curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash; \
 	fi

rln-wasm/Cargo.toml

@@ -14,10 +14,10 @@ num-bigint = { version = "0.4.6", default-features = false, features = [
     "rand",
     "serde",
 ] }
+js-sys = "0.3.77"
 wasm-bindgen = "0.2.100"
 serde-wasm-bindgen = "0.6.5"
-js-sys = "0.3.77"
-serde_json = "1.0"
+wasm-bindgen-rayon = { version = "1.2.0", optional = true }
 
 # The `console_error_panic_xhook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires
@@ -30,10 +30,16 @@ zerokit_utils = { path = "../utils" }
 getrandom = { version = "0.2.15", features = ["js"] }
 
 [dev-dependencies]
+serde_json = "1.0"
 wasm-bindgen-test = "0.3.50"
 wasm-bindgen-futures = "0.4.50"
 
+[dev-dependencies.web-sys]
+version = "0.3.77"
+features = ["Window", "Navigator"]
+
 [features]
 default = ["console_error_panic_hook"]
 stateless = ["rln/stateless"]
 arkzkey = ["rln/arkzkey"]
+multithread = ["wasm-bindgen-rayon"]

rln-wasm/Makefile.toml

@@ -6,15 +6,94 @@ dependencies = ["pack_build", "pack_rename"]
 clear = true
 dependencies = ["pack_build_arkzkey", "pack_rename"]
 
+[tasks.build_multithread]
+clear = true
+dependencies = [
+    "pack_build_multithread",
+    "pack_rename",
+    "post_build_multithread",
+]
+
+[tasks.build_multithread_arkzkey]
+clear = true
+dependencies = [
+    "pack_build_multithread_arkzkey",
+    "pack_rename",
+    "post_build_multithread",
+]
+
 [tasks.pack_build]
 command = "wasm-pack"
-args = ["build", "--release", "--target", "web", "--scope", "waku"]
-env = { "RUSTFLAGS" = "--cfg feature=\"stateless\"" }
+args = [
+    "build",
+    "--release",
+    "--target",
+    "web",
+    "--scope",
+    "waku",
+    "--features",
+    "stateless",
+]
 
 [tasks.pack_build_arkzkey]
 command = "wasm-pack"
-args = ["build", "--release", "--target", "web", "--scope", "waku"]
-env = { "RUSTFLAGS" = "--cfg feature=\"stateless\" --cfg feature=\"arkzkey\"" }
+args = [
+    "build",
+    "--release",
+    "--target",
+    "web",
+    "--scope",
+    "waku",
+    "--features",
+    "stateless,arkzkey",
+]
+
+[tasks.pack_build_multithread]
+command = "env"
+args = [
+    "RUSTFLAGS=-C target-feature=+atomics,+bulk-memory,+mutable-globals",
+    "rustup",
+    "run",
+    "nightly",
+    "wasm-pack",
+    "build",
+    "--release",
+    "--target",
+    "web",
+    "--scope",
+    "waku",
+    "--features",
+    "stateless,multithread",
+    "-Z",
+    "build-std=panic_abort,std",
+]
+
+[tasks.pack_build_multithread_arkzkey]
+command = "env"
+args = [
+    "RUSTFLAGS=-C target-feature=+atomics,+bulk-memory,+mutable-globals",
+    "rustup",
+    "run",
+    "nightly",
+    "wasm-pack",
+    "build",
+    "--release",
+    "--target",
+    "web",
+    "--scope",
+    "waku",
+    "--features",
+    "stateless,multithread,arkzkey",
+    "-Z",
+    "build-std=panic_abort,std",
+]
+
+[tasks.post_build_multithread]
+script = '''
+wasm-bindgen --target web --split-linked-modules --out-dir ./pkg ../target/wasm32-unknown-unknown/release/rln_wasm.wasm && \
+find ./pkg/snippets -name "workerHelpers.worker.js" -exec sed -i.bak 's|from '\''\.\.\/\.\.\/\.\.\/'\'';|from "../../../rln_wasm.js";|g' {} \; -exec rm -f {}.bak \; && \
+find ./pkg/snippets -name "workerHelpers.worker.js" -exec sed -i.bak 's|await initWbg(module, memory);|await initWbg({ module, memory });|g' {} \; -exec rm -f {}.bak \;
+'''
 
 [tasks.pack_rename]
 script = "sed -i.bak 's/rln-wasm/zerokit-rln-wasm/g' pkg/package.json && rm pkg/package.json.bak"
@@ -27,10 +106,12 @@ args = [
     "--node",
     "--target",
     "wasm32-unknown-unknown",
+    "--features",
+    "stateless",
     "--",
     "--nocapture",
 ]
-env = { "RUSTFLAGS" = "--cfg feature=\"stateless\"" }
+dependencies = ["build"]
 
 [tasks.test_arkzkey]
 command = "wasm-pack"
@@ -40,12 +121,99 @@ args = [
     "--node",
     "--target",
     "wasm32-unknown-unknown",
+    "--features",
+    "stateless,arkzkey",
     "--",
     "--nocapture",
 ]
-env = { "RUSTFLAGS" = "--cfg feature=\"stateless\" --cfg feature=\"arkzkey\"" }
 dependencies = ["build_arkzkey"]
 
+[tasks.test_browser]
+command = "wasm-pack"
+args = [
+    "test",
+    "--release",
+    "--chrome",
+    # "--firefox",
+    # "--safari",
+    "--headless",
+    "--target",
+    "wasm32-unknown-unknown",
+    "--features",
+    "stateless",
+    "--",
+    "--nocapture",
+]
+dependencies = ["build"]
+
+[tasks.test_browser_arkzkey]
+command = "wasm-pack"
+args = [
+    "test",
+    "--release",
+    "--chrome",
+    # "--firefox",
+    # "--safari",
+    "--headless",
+    "--target",
+    "wasm32-unknown-unknown",
+    "--features",
+    "stateless,arkzkey",
+    "--",
+    "--nocapture",
+]
+dependencies = ["build_arkzkey"]
+
+[tasks.test_multithread]
+command = "env"
+args = [
+    "RUSTFLAGS=-C target-feature=+atomics,+bulk-memory,+mutable-globals",
+    "rustup",
+    "run",
+    "nightly",
+    "wasm-pack",
+    "test",
+    "--release",
+    "--chrome",
+    # "--firefox",
+    # "--safari",
+    "--headless",
+    "--target",
+    "wasm32-unknown-unknown",
+    "--features",
+    "stateless,multithread",
+    "-Z",
+    "build-std=panic_abort,std",
+    "--",
+    "--nocapture",
+]
+dependencies = ["build_multithread"]
+
+[tasks.test_multithread_arkzkey]
+command = "env"
+args = [
+    "RUSTFLAGS=-C target-feature=+atomics,+bulk-memory,+mutable-globals",
+    "rustup",
+    "run",
+    "nightly",
+    "wasm-pack",
+    "test",
+    "--release",
+    "--chrome",
+    # "--firefox",
+    # "--safari",
+    "--headless",
+    "--target",
+    "wasm32-unknown-unknown",
+    "--features",
+    "stateless,multithread,arkzkey",
+    "-Z",
+    "build-std=panic_abort,std",
+    "--",
+    "--nocapture",
+]
+dependencies = ["build_multithread_arkzkey"]
+
 [tasks.bench]
 disabled = true
 

rln-wasm/README.md

@@ -53,3 +53,60 @@ Or test with the **arkzkey** feature enabled
 ```bash
 cargo make test_arkzkey
 ```
+
+If you want to run the tests in browser headless mode, you can use the following command:
+
+```bash
+cargo make test_browser
+cargo make test_browser_arkzkey
+```
+
+## Parallel computation
+
+The library supports parallel computation using the `wasm-bindgen-rayon` crate, enabling multi-threaded execution in the browser.
+
+> **Note**: Parallel support is not enabled by default due to WebAssembly and browser limitations. Compiling this feature requires `nightly` Rust.
+
+To enable parallel computation for WebAssembly threads, you can use the following command:
+
+```bash
+cargo make build_multithread
+```
+
+Or with the **arkzkey** feature enabled:
+
+```bash
+cargo make build_multithread_arkzkey
+```
+
+### WebAssembly Threading Support
+
+Most modern browsers support WebAssembly threads, but they require the following headers to enable `SharedArrayBuffer` and multithreading:
+
+- Cross-Origin-Opener-Policy: same-origin
+- Cross-Origin-Embedder-Policy: require-corp
+
+Without these, the application will fall back to single-threaded mode.
+
+## Feature detection
+
+If you're targeting [older browser versions that didn't support WebAssembly threads yet](https://webassembly.org/roadmap/), you'll likely want to make two builds - one with threads support and one without - and use feature detection to choose the right one on the JavaScript side.
+
+You can use [wasm-feature-detect](https://github.com/GoogleChromeLabs/wasm-feature-detect) library for this purpose. The code will look roughly like this:
+
+```js
+import { threads } from 'wasm-feature-detect';
+
+let wasmPkg;
+
+if (await threads()) {
+  wasmPkg = await import('./pkg-with-threads/index.js');
+  await wasmPkg.default();
+  await wasmPkg.initThreadPool(navigator.hardwareConcurrency);
+} else {
+  wasmPkg = await import('./pkg-without-threads/index.js');
+  await wasmPkg.default();
+}
+
+wasmPkg.nowCallAnyExportedFuncs();
+```

rln-wasm/benches/index.html

@@ -0,0 +1,561 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>RLN WASM Benchmark</title>
+    <style>
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
+          sans-serif;
+        max-width: 700px;
+        margin: 0 auto;
+        padding: 20px;
+        color: #333;
+      }
+
+      h1 {
+        text-align: center;
+        margin-bottom: 30px;
+      }
+
+      .panel {
+        background: #f8f9fa;
+        border-radius: 8px;
+        padding: 20px;
+        margin-bottom: 20px;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+      }
+
+      .file-input {
+        margin-bottom: 15px;
+      }
+
+      label {
+        display: block;
+        margin-bottom: 5px;
+        font-weight: 500;
+      }
+
+      button {
+        background: #4361ee;
+        color: white;
+        border: none;
+        padding: 10px 20px;
+        border-radius: 4px;
+        font-size: 16px;
+        cursor: pointer;
+        margin-top: 10px;
+        width: 100%;
+      }
+
+      button:hover {
+        background: #3a56d4;
+      }
+
+      button:disabled {
+        background: #cccccc;
+        cursor: not-allowed;
+      }
+
+      .results-table {
+        width: 100%;
+        border-collapse: collapse;
+        margin-top: 10px;
+      }
+
+      .results-table th,
+      .results-table td {
+        padding: 12px;
+        text-align: left;
+        border-bottom: 1px solid #ddd;
+      }
+
+      .results-table th {
+        font-weight: 600;
+        background-color: #f1f3f5;
+      }
+
+      .operation {
+        font-weight: 500;
+      }
+
+      .time {
+        font-family: monospace;
+        text-align: right;
+      }
+
+      .status {
+        padding: 10px;
+        margin-top: 15px;
+        border-radius: 4px;
+        text-align: center;
+      }
+
+      .success {
+        background-color: #d4edda;
+        color: #155724;
+      }
+
+      .error {
+        background-color: #f8d7da;
+        color: #721c24;
+      }
+
+      .running {
+        background-color: #cce5ff;
+        color: #004085;
+      }
+
+      /* Download button style */
+      .download-btn {
+        background: #28a745;
+        margin-top: 15px;
+      }
+
+      .download-btn:hover {
+        background: #218838;
+      }
+
+      /* Summary section */
+      .summary {
+        margin-top: 15px;
+        padding-top: 15px;
+        border-top: 1px solid #ddd;
+      }
+
+      .summary h3 {
+        margin-top: 0;
+      }
+
+      /* Thread info */
+      .thread-info {
+        margin-bottom: 15px;
+        padding: 10px;
+        background-color: #f1f3f5;
+        border-radius: 4px;
+        font-weight: 500;
+      }
+    </style>
+    <script>
+      // Check if cross-origin isolation is available for SharedArrayBuffer
+      document.addEventListener("DOMContentLoaded", () => {
+        if (!crossOriginIsolated) {
+          const statusElement = document.getElementById("status");
+          if (statusElement) {
+            statusElement.innerHTML =
+              '<strong style="color: #721c24;">Error:</strong> ' +
+              "Cross-Origin Isolation is not enabled. Please run the server.js script with:<br>" +
+              "<code>node server.js</code><br>" +
+              'Then access this page via <a href="http://localhost:8000">http://localhost:8000</a>';
+            statusElement.className = "status error";
+          }
+        }
+      });
+    </script>
+  </head>
+
+  <body>
+    <h1>RLN WASM Benchmark</h1>
+
+    <div class="panel">
+      <div class="thread-info" id="threadInfo">Detecting CPU cores...</div>
+
+      <div
+        class="thread-mode-selector"
+        style="display: flex; gap: 10px; margin-bottom: 15px"
+      >
+        <button id="singleThreaded" class="thread-btn" style="flex: 1">
+          Single-Threaded Mode
+        </button>
+        <button
+          id="multiThreaded"
+          class="thread-btn"
+          style="flex: 1; background: #4361ee"
+        >
+          Multi-Threaded Mode
+        </button>
+      </div>
+
+      <button id="initThreads" class="init-btn">Initialize Thread Pool</button>
+
+      <div class="file-input">
+        <label for="zkeyFile">zKey File:</label>
+        <input type="file" id="zkeyFile" />
+      </div>
+      <div class="file-input">
+        <label for="rootFile">Root File:</label>
+        <input type="file" id="rootFile" />
+      </div>
+      <div class="file-input">
+        <label for="witnessFile">Witness File:</label>
+        <input type="file" id="witnessFile" />
+      </div>
+      <div class="file-input">
+        <label for="messageFile">Message File:</label>
+        <input type="file" id="messageFile" />
+      </div>
+      <div class="file-input">
+        <label for="proofFile">Proof File:</label>
+        <input type="file" id="proofFile" />
+      </div>
+
+      <button id="runBenchmark" disabled>Run Benchmark</button>
+
+      <div id="status" class="status">Please initialize thread pool first</div>
+    </div>
+
+    <div class="panel">
+      <h2>Results</h2>
+      <table class="results-table">
+        <thead>
+          <tr>
+            <th>Operation</th>
+            <th>Time (ms)</th>
+          </tr>
+        </thead>
+        <tbody id="results">
+          <!-- Results will be populated here -->
+        </tbody>
+      </table>
+
+      <div id="summarySection" class="summary" style="display: none">
+        <h3>Summary</h3>
+        <div id="summaryContent"></div>
+        <button id="downloadResults" class="download-btn">
+          Download Results
+        </button>
+      </div>
+    </div>
+
+    <script type="module">
+      import init, * as RLN from "../pkg/rln_wasm.js";
+
+      // Get DOM elements
+      const initThreadsBtn = document.getElementById("initThreads");
+      const runBtn = document.getElementById("runBenchmark");
+      const results = document.getElementById("results");
+      const status = document.getElementById("status");
+      const summarySection = document.getElementById("summarySection");
+      const summaryContent = document.getElementById("summaryContent");
+      const downloadBtn = document.getElementById("downloadResults");
+      const threadInfo = document.getElementById("threadInfo");
+
+      // Track benchmark operations
+      const benchmarks = [];
+      let threadPoolInitialized = false;
+      let cpuCount = navigator.hardwareConcurrency || 4; // Default to 4 if detection fails
+      let useMultiThreaded = true; // Default to multi-threaded mode
+
+      // Update the thread info display
+      updateThreadInfo();
+
+      // Function to update thread info display
+      function updateThreadInfo() {
+        if (useMultiThreaded) {
+          threadInfo.textContent = `Automatically detected ${cpuCount} CPU cores for optimal performance`;
+        } else {
+          threadInfo.textContent = `Using single-threaded mode (1 CPU core)`;
+        }
+      }
+
+      // Thread mode selection
+      document
+        .getElementById("singleThreaded")
+        .addEventListener("click", () => {
+          if (!threadPoolInitialized) {
+            useMultiThreaded = false;
+            document.getElementById("singleThreaded").style.background =
+              "#4361ee";
+            document.getElementById("multiThreaded").style.background =
+              "#6c757d";
+            updateThreadInfo();
+          } else {
+            updateStatus(
+              "Thread pool already initialized. Please refresh page to change mode.",
+              "error"
+            );
+          }
+        });
+
+      document.getElementById("multiThreaded").addEventListener("click", () => {
+        if (!threadPoolInitialized) {
+          useMultiThreaded = true;
+          document.getElementById("multiThreaded").style.background = "#4361ee";
+          document.getElementById("singleThreaded").style.background =
+            "#6c757d";
+          updateThreadInfo();
+        } else {
+          updateStatus(
+            "Thread pool already initialized. Please refresh page to change mode.",
+            "error"
+          );
+        }
+      });
+
+      // Initialize thread pool
+      initThreadsBtn.addEventListener("click", async () => {
+        if (!crossOriginIsolated) {
+          updateStatus(
+            "Cross-Origin Isolation is required. Please run with server.js",
+            "error"
+          );
+          return;
+        }
+
+        if (threadPoolInitialized) {
+          updateStatus("Thread pool already initialized.", "error");
+          return;
+        }
+
+        updateStatus(
+          `Initializing thread pool with ${cpuCount} cores...`,
+          "running"
+        );
+        initThreadsBtn.disabled = true;
+
+        try {
+          const start = performance.now();
+          await init();
+          await RLN.initThreadPool(useMultiThreaded ? cpuCount : 1);
+          const duration = performance.now() - start;
+
+          benchmarks.push({
+            name: "Initialize WASM Module",
+            duration: duration,
+            success: true,
+          });
+
+          updateResults();
+          threadPoolInitialized = true;
+          updateStatus(
+            `Thread pool initialized with ${
+              useMultiThreaded ? cpuCount : 1
+            } cores`,
+            "success"
+          );
+          runBtn.disabled = false;
+        } catch (error) {
+          console.error("Thread pool initialization error:", error);
+          updateStatus(
+            `Error initializing thread pool: ${error.message}`,
+            "error"
+          );
+        } finally {
+          initThreadsBtn.disabled = false;
+        }
+      });
+
+      // Measure operation time
+      async function benchmark(name, fn) {
+        updateStatus(`Running: ${name}...`, "running");
+
+        const start = performance.now();
+        try {
+          const result = await fn();
+          const duration = performance.now() - start;
+
+          // Record result
+          benchmarks.push({ name, duration, success: true });
+          updateResults();
+
+          return { result, duration };
+        } catch (error) {
+          const duration = performance.now() - start;
+          benchmarks.push({
+            name: `${name} (FAILED)`,
+            duration,
+            success: false,
+            error: error.message,
+          });
+          updateResults();
+          throw error;
+        }
+      }
+
+      // Update results table
+      function updateResults() {
+        results.innerHTML = "";
+        benchmarks.forEach((b) => {
+          const row = document.createElement("tr");
+
+          const nameCell = document.createElement("td");
+          nameCell.className = "operation";
+          nameCell.textContent = b.name;
+
+          const timeCell = document.createElement("td");
+          timeCell.className = "time";
+          timeCell.textContent = b.duration.toFixed(2);
+
+          row.appendChild(nameCell);
+          row.appendChild(timeCell);
+
+          if (!b.success) {
+            row.style.color = "#dc3545";
+          }
+
+          results.appendChild(row);
+        });
+      }
+
+      // Update status message
+      function updateStatus(message, type = "") {
+        status.textContent = message;
+        status.className = `status ${type}`;
+      }
+
+      // Show benchmark summary
+      function showSummary() {
+        if (benchmarks.length === 0) return;
+
+        const successfulOps = benchmarks.filter((b) => b.success).length;
+
+        let summaryHTML = `
+                <p><strong>Operations:</strong> ${successfulOps}/${
+          benchmarks.length
+        } successful</p>
+                <p><strong>CPU cores used:</strong> ${
+                  useMultiThreaded ? cpuCount : 1
+                }</p>
+                <p><strong>Mode:</strong> ${
+                  useMultiThreaded ? "Multi-threaded" : "Single-threaded"
+                }</p>
+            `;
+
+        summaryContent.innerHTML = summaryHTML;
+        summarySection.style.display = "block";
+      }
+
+      // Download results as JSON
+      downloadBtn.addEventListener("click", () => {
+        const dataStr = JSON.stringify(
+          {
+            timestamp: new Date().toISOString(),
+            mode: useMultiThreaded ? "multi-threaded" : "single-threaded",
+            cpuCount: useMultiThreaded ? cpuCount : 1,
+            operations: benchmarks,
+          },
+          null,
+          2
+        );
+
+        const blob = new Blob([dataStr], { type: "application/json" });
+        const url = URL.createObjectURL(blob);
+
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = `rln-benchmark-${new Date()
+          .toISOString()
+          .slice(0, 19)}.json`;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+      });
+
+      // Read file as Uint8Array
+      async function readFile(file) {
+        const buffer = await file.arrayBuffer();
+        return new Uint8Array(buffer);
+      }
+
+      // Parse witness JSON
+      async function parseWitness(file) {
+        const text = await file.text();
+        try {
+          const data = JSON.parse(text);
+
+          if (!Array.isArray(data)) {
+            throw new Error("Witness JSON must be an array");
+          }
+
+          return data.map((value) => BigInt(value));
+        } catch (e) {
+          throw new Error(`Failed to parse witness JSON: ${e.message}`);
+        }
+      }
+
+      // Main benchmark runner
+      runBtn.addEventListener("click", async () => {
+        if (!threadPoolInitialized) {
+          updateStatus("Please initialize thread pool first", "error");
+          return;
+        }
+
+        const files = {
+          zkey: document.getElementById("zkeyFile").files[0],
+          root: document.getElementById("rootFile").files[0],
+          witness: document.getElementById("witnessFile").files[0],
+          message: document.getElementById("messageFile").files[0],
+          proof: document.getElementById("proofFile").files[0],
+        };
+
+        // Validation
+        if (!files.zkey || !files.root || !files.proof) {
+          updateStatus("Please select zKey, Root, and Proof files", "error");
+          return;
+        }
+
+        const canGenerate = files.witness && files.message;
+
+        try {
+          // Keep file references but clear previous benchmark results except initialization
+          const initBenchmark = benchmarks.find(
+            (b) => b.name === "Initialize WASM Module"
+          );
+          benchmarks.length = 0;
+          if (initBenchmark) {
+            benchmarks.push(initBenchmark);
+          }
+          updateResults();
+          summarySection.style.display = "none";
+          runBtn.disabled = true;
+          initThreadsBtn.disabled = true;
+
+          // Load files
+          const zkeyData = await readFile(files.zkey);
+          const rootData = await readFile(files.root);
+
+          // Create RLN instance
+          const { result: instance } = await benchmark(
+            "Create RLN Instance",
+            async () => {
+              return RLN.newRLN(zkeyData);
+            }
+          );
+
+          // Handle proof generation (if witness and message files provided)
+          if (canGenerate) {
+            const witnessData = await parseWitness(files.witness);
+            const messageData = await readFile(files.message);
+
+            await benchmark("Generate RLN Proof", async () => {
+              return RLN.generateRLNProofWithWitness(
+                instance,
+                witnessData,
+                messageData
+              );
+            });
+          }
+
+          // Verify uploaded proof (required)
+          const proofData = await readFile(files.proof);
+
+          await benchmark("Verify Proof", async () => {
+            return RLN.verifyWithRoots(instance, proofData, rootData);
+          });
+
+          updateStatus("Benchmark completed successfully!", "success");
+          showSummary();
+        } catch (error) {
+          console.error(error);
+          updateStatus(`Error: ${error.message}`, "error");
+          showSummary();
+        } finally {
+          runBtn.disabled = false;
+          initThreadsBtn.disabled = false;
+        }
+      });
+    </script>
+  </body>
+</html>

rln-wasm/benches/server.js

@@ -0,0 +1,83 @@
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const url = require("url");
+
+const PORT = 8000;
+
+// MIME type mapping
+const MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".wasm": "application/wasm",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+};
+
+// Create HTTP server
+const server = http.createServer((req, res) => {
+  // Set COOP and COEP headers for SharedArrayBuffer support
+  res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
+  res.setHeader("Cross-Origin-Embedder-Policy", "require-corp");
+
+  // Parse URL
+  const parsedUrl = url.parse(req.url);
+  let requestPath = parsedUrl.pathname;
+
+  // Ignore favicon
+  if (requestPath === "/favicon.ico") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  // Handle root path
+  let filePath = "." + requestPath;
+  if (filePath === "./") {
+    filePath = "./index.html";
+  }
+
+  // Handle pkg files (including snippets)
+  if (requestPath.startsWith("/pkg/")) {
+    filePath = ".." + requestPath;
+  }
+
+  // Determine content type based on file extension
+  const extname = path.extname(filePath);
+  const contentType = MIME_TYPES[extname] || "application/octet-stream";
+
+  // ❗ Block directory reads
+  if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
+    console.error(`Attempted directory read: ${filePath}`);
+    res.writeHead(403);
+    res.end("Forbidden: Cannot read directory directly");
+    return;
+  }
+
+  // Read and serve the file
+  fs.readFile(filePath, (error, content) => {
+    if (error) {
+      if (error.code === "ENOENT") {
+        console.error(`File not found: ${filePath}`);
+        res.writeHead(404);
+        res.end(`File not found: ${requestPath}`);
+      } else {
+        console.error(`Server error (${error.code}): ${filePath}`);
+        res.writeHead(500);
+        res.end(`Server Error: ${error.code}`);
+      }
+    } else {
+      res.writeHead(200, { "Content-Type": contentType });
+      res.end(content, "utf-8");
+    }
+  });
+});
+
+// Start the server
+server.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});

rln-wasm/resources/witness_calculator(browser).js

@@ -0,0 +1,335 @@
+// Browser compatible witness calculator
+(function (global) {
+  async function builder(code, options) {
+    options = options || {};
+
+    let wasmModule;
+    try {
+      wasmModule = await WebAssembly.compile(code);
+    } catch (err) {
+      console.log(err);
+      console.log(
+        "\nTry to run circom --c in order to generate c++ code instead\n"
+      );
+      throw new Error(err);
+    }
+
+    let wc;
+
+    let errStr = "";
+    let msgStr = "";
+
+    const instance = await WebAssembly.instantiate(wasmModule, {
+      runtime: {
+        exceptionHandler: function (code) {
+          let err;
+          if (code == 1) {
+            err = "Signal not found.\n";
+          } else if (code == 2) {
+            err = "Too many signals set.\n";
+          } else if (code == 3) {
+            err = "Signal already set.\n";
+          } else if (code == 4) {
+            err = "Assert Failed.\n";
+          } else if (code == 5) {
+            err = "Not enough memory.\n";
+          } else if (code == 6) {
+            err = "Input signal array access exceeds the size.\n";
+          } else {
+            err = "Unknown error.\n";
+          }
+          throw new Error(err + errStr);
+        },
+        printErrorMessage: function () {
+          errStr += getMessage() + "\n";
+          // console.error(getMessage());
+        },
+        writeBufferMessage: function () {
+          const msg = getMessage();
+          // Any calls to `log()` will always end with a `\n`, so that's when we print and reset
+          if (msg === "\n") {
+            console.log(msgStr);
+            msgStr = "";
+          } else {
+            // If we've buffered other content, put a space in between the items
+            if (msgStr !== "") {
+              msgStr += " ";
+            }
+            // Then append the message to the message we are creating
+            msgStr += msg;
+          }
+        },
+        showSharedRWMemory: function () {
+          printSharedRWMemory();
+        },
+      },
+    });
+
+    const sanityCheck = options;
+    //        options &&
+    //        (
+    //            options.sanityCheck ||
+    //            options.logGetSignal ||
+    //            options.logSetSignal ||
+    //            options.logStartComponent ||
+    //            options.logFinishComponent
+    //        );
+
+    wc = new WitnessCalculator(instance, sanityCheck);
+    return wc;
+
+    function getMessage() {
+      var message = "";
+      var c = instance.exports.getMessageChar();
+      while (c != 0) {
+        message += String.fromCharCode(c);
+        c = instance.exports.getMessageChar();
+      }
+      return message;
+    }
+
+    function printSharedRWMemory() {
+      const shared_rw_memory_size = instance.exports.getFieldNumLen32();
+      const arr = new Uint32Array(shared_rw_memory_size);
+      for (let j = 0; j < shared_rw_memory_size; j++) {
+        arr[shared_rw_memory_size - 1 - j] =
+          instance.exports.readSharedRWMemory(j);
+      }
+
+      // If we've buffered other content, put a space in between the items
+      if (msgStr !== "") {
+        msgStr += " ";
+      }
+      // Then append the value to the message we are creating
+      msgStr += fromArray32(arr).toString();
+    }
+  }
+
+  class WitnessCalculator {
+    constructor(instance, sanityCheck) {
+      this.instance = instance;
+
+      this.version = this.instance.exports.getVersion();
+      this.n32 = this.instance.exports.getFieldNumLen32();
+
+      this.instance.exports.getRawPrime();
+      const arr = new Uint32Array(this.n32);
+      for (let i = 0; i < this.n32; i++) {
+        arr[this.n32 - 1 - i] = this.instance.exports.readSharedRWMemory(i);
+      }
+      this.prime = fromArray32(arr);
+
+      this.witnessSize = this.instance.exports.getWitnessSize();
+
+      this.sanityCheck = sanityCheck;
+    }
+
+    circom_version() {
+      return this.instance.exports.getVersion();
+    }
+
+    async _doCalculateWitness(input, sanityCheck) {
+      //input is assumed to be a map from signals to arrays of bigints
+      this.instance.exports.init(this.sanityCheck || sanityCheck ? 1 : 0);
+      const keys = Object.keys(input);
+      var input_counter = 0;
+      keys.forEach((k) => {
+        const h = fnvHash(k);
+        const hMSB = parseInt(h.slice(0, 8), 16);
+        const hLSB = parseInt(h.slice(8, 16), 16);
+        const fArr = flatArray(input[k]);
+        let signalSize = this.instance.exports.getInputSignalSize(hMSB, hLSB);
+        if (signalSize < 0) {
+          throw new Error(`Signal ${k} not found\n`);
+        }
+        if (fArr.length < signalSize) {
+          throw new Error(`Not enough values for input signal ${k}\n`);
+        }
+        if (fArr.length > signalSize) {
+          throw new Error(`Too many values for input signal ${k}\n`);
+        }
+        for (let i = 0; i < fArr.length; i++) {
+          const arrFr = toArray32(BigInt(fArr[i]) % this.prime, this.n32);
+          for (let j = 0; j < this.n32; j++) {
+            this.instance.exports.writeSharedRWMemory(
+              j,
+              arrFr[this.n32 - 1 - j]
+            );
+          }
+          try {
+            this.instance.exports.setInputSignal(hMSB, hLSB, i);
+            input_counter++;
+          } catch (err) {
+            // console.log(`After adding signal ${i} of ${k}`)
+            throw new Error(err);
+          }
+        }
+      });
+      if (input_counter < this.instance.exports.getInputSize()) {
+        throw new Error(
+          `Not all inputs have been set. Only ${input_counter} out of ${this.instance.exports.getInputSize()}`
+        );
+      }
+    }
+
+    async calculateWitness(input, sanityCheck) {
+      const w = [];
+
+      await this._doCalculateWitness(input, sanityCheck);
+
+      for (let i = 0; i < this.witnessSize; i++) {
+        this.instance.exports.getWitness(i);
+        const arr = new Uint32Array(this.n32);
+        for (let j = 0; j < this.n32; j++) {
+          arr[this.n32 - 1 - j] = this.instance.exports.readSharedRWMemory(j);
+        }
+        w.push(fromArray32(arr));
+      }
+
+      return w;
+    }
+
+    async calculateBinWitness(input, sanityCheck) {
+      const buff32 = new Uint32Array(this.witnessSize * this.n32);
+      const buff = new Uint8Array(buff32.buffer);
+      await this._doCalculateWitness(input, sanityCheck);
+
+      for (let i = 0; i < this.witnessSize; i++) {
+        this.instance.exports.getWitness(i);
+        const pos = i * this.n32;
+        for (let j = 0; j < this.n32; j++) {
+          buff32[pos + j] = this.instance.exports.readSharedRWMemory(j);
+        }
+      }
+
+      return buff;
+    }
+
+    async calculateWTNSBin(input, sanityCheck) {
+      const buff32 = new Uint32Array(
+        this.witnessSize * this.n32 + this.n32 + 11
+      );
+      const buff = new Uint8Array(buff32.buffer);
+      await this._doCalculateWitness(input, sanityCheck);
+
+      //"wtns"
+      buff[0] = "w".charCodeAt(0);
+      buff[1] = "t".charCodeAt(0);
+      buff[2] = "n".charCodeAt(0);
+      buff[3] = "s".charCodeAt(0);
+
+      //version 2
+      buff32[1] = 2;
+
+      //number of sections: 2
+      buff32[2] = 2;
+
+      //id section 1
+      buff32[3] = 1;
+
+      const n8 = this.n32 * 4;
+      //id section 1 length in 64bytes
+      const idSection1length = 8 + n8;
+      const idSection1lengthHex = idSection1length.toString(16);
+      buff32[4] = parseInt(idSection1lengthHex.slice(0, 8), 16);
+      buff32[5] = parseInt(idSection1lengthHex.slice(8, 16), 16);
+
+      //this.n32
+      buff32[6] = n8;
+
+      //prime number
+      this.instance.exports.getRawPrime();
+
+      var pos = 7;
+      for (let j = 0; j < this.n32; j++) {
+        buff32[pos + j] = this.instance.exports.readSharedRWMemory(j);
+      }
+      pos += this.n32;
+
+      // witness size
+      buff32[pos] = this.witnessSize;
+      pos++;
+
+      //id section 2
+      buff32[pos] = 2;
+      pos++;
+
+      // section 2 length
+      const idSection2length = n8 * this.witnessSize;
+      const idSection2lengthHex = idSection2length.toString(16);
+      buff32[pos] = parseInt(idSection2lengthHex.slice(0, 8), 16);
+      buff32[pos + 1] = parseInt(idSection2lengthHex.slice(8, 16), 16);
+
+      pos += 2;
+      for (let i = 0; i < this.witnessSize; i++) {
+        this.instance.exports.getWitness(i);
+        for (let j = 0; j < this.n32; j++) {
+          buff32[pos + j] = this.instance.exports.readSharedRWMemory(j);
+        }
+        pos += this.n32;
+      }
+
+      return buff;
+    }
+  }
+
+  function toArray32(rem, size) {
+    const res = []; //new Uint32Array(size); //has no unshift
+    const radix = BigInt(0x100000000);
+    while (rem) {
+      res.unshift(Number(rem % radix));
+      rem = rem / radix;
+    }
+    if (size) {
+      var i = size - res.length;
+      while (i > 0) {
+        res.unshift(0);
+        i--;
+      }
+    }
+    return res;
+  }
+
+  function fromArray32(arr) {
+    //returns a BigInt
+    var res = BigInt(0);
+    const radix = BigInt(0x100000000);
+    for (let i = 0; i < arr.length; i++) {
+      res = res * radix + BigInt(arr[i]);
+    }
+    return res;
+  }
+
+  function flatArray(a) {
+    var res = [];
+    fillArray(res, a);
+    return res;
+
+    function fillArray(res, a) {
+      if (Array.isArray(a)) {
+        for (let i = 0; i < a.length; i++) {
+          fillArray(res, a[i]);
+        }
+      } else {
+        res.push(a);
+      }
+    }
+  }
+
+  function fnvHash(str) {
+    const uint64_max = BigInt(2) ** BigInt(64);
+    let hash = BigInt("0xCBF29CE484222325");
+    for (var i = 0; i < str.length; i++) {
+      hash ^= BigInt(str[i].charCodeAt());
+      hash *= BigInt(0x100000001b3);
+      hash %= uint64_max;
+    }
+    let shash = hash.toString(16);
+    let n = 16 - shash.length;
+    shash = "0".repeat(n).concat(shash);
+    return shash;
+  }
+
+  // Make it globally available
+  global.witnessCalculatorBuilder = builder;
+})(typeof self !== "undefined" ? self : window);

rln-wasm/resources/witness_calculator(node).js

@@ -1,3 +1,4 @@
+// Node.js module compatible witness calculator
 module.exports = async function builder(code, options) {
   options = options || {};
 

rln-wasm/snippets/wasm-bindgen-rayon-e6698bae2cc7187f/src/workerHelpers.worker.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2022 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Note: our JS should have been generated in
+// `[out-dir]/snippets/wasm-bindgen-rayon-[hash]/workerHelpers.worker.js`,
+// resolve the main module via `../../..`.
+//
+// This might need updating if the generated structure changes on wasm-bindgen
+// side ever in the future, but works well with bundlers today. The whole
+// point of this crate, after all, is to abstract away unstable features
+// and temporary bugs so that you don't need to deal with them in your code.
+import initWbg, { wbg_rayon_start_worker } from "../../../pkg/rln_wasm.js";
+
+onmessage = async ({ data: { module, memory, receiver } }) => {
+  await initWbg({ module, memory });
+  postMessage(true);
+  wbg_rayon_start_worker(receiver);
+};

rln-wasm/src/lib.rs

@@ -6,6 +6,9 @@ use rln::public::{hash, poseidon_hash, RLN};
 use std::vec::Vec;
 use wasm_bindgen::prelude::*;
 
+#[cfg(feature = "multithread")]
+pub use wasm_bindgen_rayon::init_thread_pool;
+
 #[wasm_bindgen(js_name = initPanicHook)]
 pub fn init_panic_hook() {
     console_error_panic_hook::set_once();

rln-wasm/src/utils.js

@@ -1,26 +0,0 @@
-const fs = require("fs");
-
-// Utils functions for loading circom witness calculator and reading files from test
-
-module.exports = {
-  read_file: function (path) {
-    return fs.readFileSync(path);
-  },
-
-  calculateWitness: async function (circom_path, inputs) {
-    const wc = require("../resources/witness_calculator.js");
-    const wasmFile = fs.readFileSync(circom_path);
-    const wasmFileBuffer = wasmFile.slice(
-      wasmFile.byteOffset,
-      wasmFile.byteOffset + wasmFile.byteLength
-    );
-    const witnessCalculator = await wc(wasmFileBuffer);
-    const calculatedWitness = await witnessCalculator.calculateWitness(
-      inputs,
-      false
-    );
-    return JSON.stringify(calculatedWitness, (key, value) =>
-      typeof value === "bigint" ? value.toString() : value
-    );
-  },
-};

rln-wasm/tests/browser.rs

@@ -0,0 +1,372 @@
+#![cfg(target_arch = "wasm32")]
+
+#[cfg(test)]
+mod tests {
+    use js_sys::{BigInt as JsBigInt, Date, Object, Uint8Array};
+    use rln::circuit::{Fr, TEST_TREE_HEIGHT};
+    use rln::hashers::{hash_to_field, poseidon_hash};
+    use rln::poseidon_tree::PoseidonTree;
+    use rln::protocol::{prepare_verify_input, rln_witness_from_values, serialize_witness};
+    use rln::utils::{bytes_le_to_fr, fr_to_bytes_le};
+    use rln_wasm::{
+        wasm_generate_rln_proof_with_witness, wasm_key_gen, wasm_new, wasm_rln_witness_to_json,
+        wasm_verify_with_roots,
+    };
+    use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
+    use wasm_bindgen_test::{console_log, wasm_bindgen_test, wasm_bindgen_test_configure};
+    use zerokit_utils::merkle_tree::merkle_tree::ZerokitMerkleTree;
+
+    #[cfg(feature = "multithread")]
+    use {rln_wasm::init_thread_pool, wasm_bindgen_futures::JsFuture, web_sys::window};
+
+    #[wasm_bindgen(inline_js = r#"
+    export function isThreadpoolSupported() {
+      return typeof SharedArrayBuffer !== 'undefined' &&
+             typeof Atomics !== 'undefined' &&
+             typeof crossOriginIsolated !== 'undefined' &&
+             crossOriginIsolated;
+    }
+
+    export function initWitnessCalculator(jsCode) {
+      eval(jsCode);
+      if (typeof window.witnessCalculatorBuilder !== 'function') {
+        return false;
+      }
+      return true;
+    }
+
+    export function readFile(data) {
+      return new Uint8Array(data);
+    }
+
+    export async function calculateWitness(circom_data, inputs) {
+      const wasmBuffer = circom_data instanceof Uint8Array ? circom_data : new Uint8Array(circom_data);
+      const witnessCalculator = await window.witnessCalculatorBuilder(wasmBuffer);
+      const calculatedWitness = await witnessCalculator.calculateWitness(inputs, false);
+      return JSON.stringify(calculatedWitness, (key, value) =>
+        typeof value === "bigint" ? value.toString() : value
+      );
+    }
+    "#)]
+    extern "C" {
+        #[wasm_bindgen(catch)]
+        fn isThreadpoolSupported() -> Result<bool, JsValue>;
+
+        #[wasm_bindgen(catch)]
+        fn initWitnessCalculator(js: &str) -> Result<bool, JsValue>;
+
+        #[wasm_bindgen(catch)]
+        fn readFile(data: &[u8]) -> Result<Uint8Array, JsValue>;
+
+        #[wasm_bindgen(catch)]
+        async fn calculateWitness(circom_data: &[u8], inputs: Object) -> Result<JsValue, JsValue>;
+    }
+
+    const WITNESS_CALCULATOR_JS: &str = include_str!("../resources/witness_calculator(browser).js");
+
+    #[cfg(feature = "arkzkey")]
+    const ZKEY_BYTES: &[u8] =
+        include_bytes!("../../rln/resources/tree_height_20/rln_final.arkzkey");
+    #[cfg(not(feature = "arkzkey"))]
+    const ZKEY_BYTES: &[u8] = include_bytes!("../../rln/resources/tree_height_20/rln_final.zkey");
+
+    const CIRCOM_BYTES: &[u8] = include_bytes!("../../rln/resources/tree_height_20/rln.wasm");
+
+    wasm_bindgen_test_configure!(run_in_browser);
+
+    #[wasm_bindgen_test]
+    pub async fn rln_wasm_benchmark() {
+        // Check if thread pool is supported
+        #[cfg(feature = "multithread")]
+        if !isThreadpoolSupported().expect("Failed to check thread pool support") {
+            panic!("Thread pool is NOT supported");
+        } else {
+            // Initialize thread pool
+            let cpu_count = window()
+                .expect("Failed to get window")
+                .navigator()
+                .hardware_concurrency() as usize;
+            JsFuture::from(init_thread_pool(cpu_count))
+                .await
+                .expect("Failed to initialize thread pool");
+        }
+
+        // Initialize the witness calculator
+        initWitnessCalculator(WITNESS_CALCULATOR_JS)
+            .expect("Failed to initialize witness calculator");
+
+        let mut results = String::from("\nbenchmarks:\n");
+        let iterations = 10;
+
+        let zkey = readFile(&ZKEY_BYTES).expect("Failed to read zkey file");
+
+        // Benchmark wasm_new
+        let start_wasm_new = Date::now();
+        for _ in 0..iterations {
+            let _ = wasm_new(zkey.clone()).expect("Failed to create RLN instance");
+        }
+        let wasm_new_result = Date::now() - start_wasm_new;
+
+        // Create RLN instance for other benchmarks
+        let rln_instance = wasm_new(zkey).expect("Failed to create RLN instance");
+        let mut tree = PoseidonTree::default(TEST_TREE_HEIGHT).expect("Failed to create tree");
+
+        // Benchmark wasm_key_gen
+        let start_wasm_key_gen = Date::now();
+        for _ in 0..iterations {
+            let _ = wasm_key_gen(rln_instance).expect("Failed to generate keys");
+        }
+        let wasm_key_gen_result = Date::now() - start_wasm_key_gen;
+
+        // Generate identity pair for other benchmarks
+        let mem_keys = wasm_key_gen(rln_instance).expect("Failed to generate keys");
+        let id_key = mem_keys.subarray(0, 32);
+        let (identity_secret_hash, _) = bytes_le_to_fr(&id_key.to_vec());
+        let (id_commitment, _) = bytes_le_to_fr(&mem_keys.subarray(32, 64).to_vec());
+
+        let epoch = hash_to_field(b"test-epoch");
+        let rln_identifier = hash_to_field(b"test-rln-identifier");
+        let external_nullifier = poseidon_hash(&[epoch, rln_identifier]);
+
+        let identity_index = tree.leaves_set();
+
+        let user_message_limit = Fr::from(100);
+
+        let rate_commitment = poseidon_hash(&[id_commitment, user_message_limit]);
+        tree.update_next(rate_commitment)
+            .expect("Failed to update tree");
+
+        let message_id = Fr::from(0);
+        let signal: [u8; 32] = [0; 32];
+        let x = hash_to_field(&signal);
+
+        let merkle_proof = tree
+            .proof(identity_index)
+            .expect("Failed to generate merkle proof");
+
+        let rln_witness = rln_witness_from_values(
+            identity_secret_hash,
+            &merkle_proof,
+            x,
+            external_nullifier,
+            user_message_limit,
+            message_id,
+        )
+        .expect("Failed to create RLN witness");
+
+        let serialized_witness =
+            serialize_witness(&rln_witness).expect("Failed to serialize witness");
+        let witness_buffer = Uint8Array::from(&serialized_witness[..]);
+
+        let json_inputs = wasm_rln_witness_to_json(rln_instance, witness_buffer.clone())
+            .expect("Failed to convert witness to JSON");
+
+        // Benchmark calculateWitness
+        let start_calculate_witness = Date::now();
+        for _ in 0..iterations {
+            let _ = calculateWitness(&CIRCOM_BYTES, json_inputs.clone())
+                .await
+                .expect("Failed to calculate witness");
+        }
+        let calculate_witness_result = Date::now() - start_calculate_witness;
+
+        // Calculate witness for other benchmarks
+        let calculated_witness_json = calculateWitness(&CIRCOM_BYTES, json_inputs)
+            .await
+            .expect("Failed to calculate witness")
+            .as_string()
+            .expect("Failed to convert calculated witness to string");
+        let calculated_witness_vec_str: Vec<String> =
+            serde_json::from_str(&calculated_witness_json).expect("Failed to parse JSON");
+        let calculated_witness: Vec<JsBigInt> = calculated_witness_vec_str
+            .iter()
+            .map(|x| JsBigInt::new(&x.into()).expect("Failed to create JsBigInt"))
+            .collect();
+
+        // Benchmark wasm_generate_rln_proof_with_witness
+        let start_wasm_generate_rln_proof_with_witness = Date::now();
+        for _ in 0..iterations {
+            let _ = wasm_generate_rln_proof_with_witness(
+                rln_instance,
+                calculated_witness.clone(),
+                witness_buffer.clone(),
+            )
+            .expect("Failed to generate proof");
+        }
+        let wasm_generate_rln_proof_with_witness_result =
+            Date::now() - start_wasm_generate_rln_proof_with_witness;
+
+        // Generate a proof for other benchmarks
+        let proof =
+            wasm_generate_rln_proof_with_witness(rln_instance, calculated_witness, witness_buffer)
+                .expect("Failed to generate proof");
+
+        let proof_data = proof.to_vec();
+        let verify_input = prepare_verify_input(proof_data, &signal);
+        let input_buffer = Uint8Array::from(&verify_input[..]);
+
+        let root = tree.root();
+        let roots_serialized = fr_to_bytes_le(&root);
+        let roots_buffer = Uint8Array::from(&roots_serialized[..]);
+
+        // Benchmark wasm_verify_with_roots
+        let start_wasm_verify_with_roots = Date::now();
+        for _ in 0..iterations {
+            let _ =
+                wasm_verify_with_roots(rln_instance, input_buffer.clone(), roots_buffer.clone())
+                    .expect("Failed to verify proof");
+        }
+        let wasm_verify_with_roots_result = Date::now() - start_wasm_verify_with_roots;
+
+        // Verify the proof with the root
+        let is_proof_valid = wasm_verify_with_roots(rln_instance, input_buffer, roots_buffer)
+            .expect("Failed to verify proof");
+        assert!(is_proof_valid, "verification failed");
+
+        // Format and display results
+        let format_duration = |duration_ms: f64| -> String {
+            let avg_ms = duration_ms / (iterations as f64);
+            if avg_ms >= 1000.0 {
+                format!("{:.3} s", avg_ms / 1000.0)
+            } else {
+                format!("{:.3} ms", avg_ms)
+            }
+        };
+
+        results.push_str(&format!("wasm_new: {}\n", format_duration(wasm_new_result)));
+        results.push_str(&format!(
+            "wasm_key_gen: {}\n",
+            format_duration(wasm_key_gen_result)
+        ));
+        results.push_str(&format!(
+            "calculateWitness: {}\n",
+            format_duration(calculate_witness_result)
+        ));
+        results.push_str(&format!(
+            "wasm_generate_rln_proof_with_witness: {}\n",
+            format_duration(wasm_generate_rln_proof_with_witness_result)
+        ));
+        results.push_str(&format!(
+            "wasm_verify_with_roots: {}\n",
+            format_duration(wasm_verify_with_roots_result)
+        ));
+
+        // Log the results
+        console_log!("{results}");
+    }
+
+    #[wasm_bindgen_test]
+    pub async fn rln_wasm_test() {
+        // Check if thread pool is supported
+        #[cfg(feature = "multithread")]
+        if !isThreadpoolSupported().expect("Failed to check thread pool support") {
+            panic!("Thread pool is NOT supported");
+        } else {
+            // Initialize thread pool
+            let cpu_count = window()
+                .expect("Failed to get window")
+                .navigator()
+                .hardware_concurrency() as usize;
+            JsFuture::from(init_thread_pool(cpu_count))
+                .await
+                .expect("Failed to initialize thread pool");
+        }
+
+        // Initialize the witness calculator
+        initWitnessCalculator(WITNESS_CALCULATOR_JS)
+            .expect("Failed to initialize witness calculator");
+
+        // Read the zkey file
+        let zkey = readFile(&ZKEY_BYTES).expect("Failed to read zkey file");
+
+        // Create RLN instance and separated tree
+        let rln_instance = wasm_new(zkey).expect("Failed to create RLN instance");
+        let mut tree = PoseidonTree::default(TEST_TREE_HEIGHT).expect("Failed to create tree");
+
+        // Setting up the epoch and rln_identifier
+        let epoch = hash_to_field(b"test-epoch");
+        let rln_identifier = hash_to_field(b"test-rln-identifier");
+        let external_nullifier = poseidon_hash(&[epoch, rln_identifier]);
+
+        // Generate identity pair
+        let mem_keys = wasm_key_gen(rln_instance).expect("Failed to generate keys");
+        let (identity_secret_hash, _) = bytes_le_to_fr(&mem_keys.subarray(0, 32).to_vec());
+        let (id_commitment, _) = bytes_le_to_fr(&mem_keys.subarray(32, 64).to_vec());
+
+        // Get index of the identity
+        let identity_index = tree.leaves_set();
+
+        // Setting up the user message limit
+        let user_message_limit = Fr::from(100);
+
+        // Updating the tree with the rate commitment
+        let rate_commitment = poseidon_hash(&[id_commitment, user_message_limit]);
+        tree.update_next(rate_commitment)
+            .expect("Failed to update tree");
+
+        // Generate merkle proof
+        let merkle_proof = tree
+            .proof(identity_index)
+            .expect("Failed to generate merkle proof");
+
+        // Create message id and signal
+        let message_id = Fr::from(0);
+        let signal: [u8; 32] = [0; 32];
+        let x = hash_to_field(&signal);
+
+        // Prepare input for witness calculation
+        let rln_witness = rln_witness_from_values(
+            identity_secret_hash,
+            &merkle_proof,
+            x,
+            external_nullifier,
+            user_message_limit,
+            message_id,
+        )
+        .expect("Failed to create RLN witness");
+
+        // Serialize the rln witness
+        let serialized_witness =
+            serialize_witness(&rln_witness).expect("Failed to serialize witness");
+        // Convert the serialized witness to a Uint8Array
+        let witness_buffer = Uint8Array::from(&serialized_witness[..]);
+
+        // Obtaining inputs that should be sent to circom witness calculator
+        let json_inputs = wasm_rln_witness_to_json(rln_instance, witness_buffer.clone())
+            .expect("Failed to convert witness to JSON");
+
+        // Calculating witness with JS
+        // (Using a JSON since wasm_bindgen does not like Result<Vec<JsBigInt>,JsValue>)
+        let calculated_witness_json = calculateWitness(&CIRCOM_BYTES, json_inputs)
+            .await
+            .expect("Failed to calculate witness")
+            .as_string()
+            .expect("Failed to convert calculated witness to string");
+        let calculated_witness_vec_str: Vec<String> =
+            serde_json::from_str(&calculated_witness_json).expect("Failed to parse JSON");
+        let calculated_witness: Vec<JsBigInt> = calculated_witness_vec_str
+            .iter()
+            .map(|x| JsBigInt::new(&x.into()).expect("Failed to create JsBigInt"))
+            .collect();
+
+        // Generate a proof from the calculated witness
+        let proof =
+            wasm_generate_rln_proof_with_witness(rln_instance, calculated_witness, witness_buffer)
+                .expect("Failed to generate proof");
+
+        // Prepare the root for verification
+        let root = tree.root();
+        let roots_serialized = fr_to_bytes_le(&root);
+        let roots_buffer = Uint8Array::from(&roots_serialized[..]);
+
+        // Prepare input for proof verification
+        let proof_data = proof.to_vec();
+        let verify_input = prepare_verify_input(proof_data, &signal);
+        let input_buffer = Uint8Array::from(&verify_input[..]);
+
+        // Verify the proof with the root
+        let is_proof_valid = wasm_verify_with_roots(rln_instance, input_buffer, roots_buffer)
+            .expect("Failed to verify proof");
+        assert!(is_proof_valid, "verification failed");
+    }
+}

rln-wasm/tests/node.rs

@@ -1,3 +1,4 @@
+#![cfg(not(feature = "multithread"))]
 #![cfg(target_arch = "wasm32")]
 
 #[cfg(test)]
@@ -8,15 +9,43 @@ mod tests {
     use rln::poseidon_tree::PoseidonTree;
     use rln::protocol::{prepare_verify_input, rln_witness_from_values, serialize_witness};
     use rln::utils::{bytes_le_to_fr, fr_to_bytes_le};
-    use rln_wasm::*;
-    use wasm_bindgen::{prelude::*, JsValue};
-    use wasm_bindgen_test::wasm_bindgen_test;
+    use rln_wasm::{
+        wasm_generate_rln_proof_with_witness, wasm_key_gen, wasm_new, wasm_rln_witness_to_json,
+        wasm_verify_with_roots,
+    };
+    use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
+    use wasm_bindgen_test::{console_log, wasm_bindgen_test};
     use zerokit_utils::merkle_tree::merkle_tree::ZerokitMerkleTree;
 
-    #[wasm_bindgen(module = "src/utils.js")]
+    #[wasm_bindgen(inline_js = r#"
+    const fs = require("fs");
+
+    module.exports = {
+      readFile: function (path) {
+        return fs.readFileSync(path);
+      },
+
+      calculateWitness: async function (circom_path, inputs) {
+        const wc = require("resources/witness_calculator(node).js");
+        const wasmFile = fs.readFileSync(circom_path);
+        const wasmFileBuffer = wasmFile.slice(
+          wasmFile.byteOffset,
+          wasmFile.byteOffset + wasmFile.byteLength
+        );
+        const witnessCalculator = await wc(wasmFileBuffer);
+        const calculatedWitness = await witnessCalculator.calculateWitness(
+          inputs,
+          false
+        );
+        return JSON.stringify(calculatedWitness, (key, value) =>
+          typeof value === "bigint" ? value.toString() : value
+        );
+      },
+    };
+    "#)]
     extern "C" {
         #[wasm_bindgen(catch)]
-        fn read_file(path: &str) -> Result<Uint8Array, JsValue>;
+        fn readFile(path: &str) -> Result<Uint8Array, JsValue>;
 
         #[wasm_bindgen(catch)]
         async fn calculateWitness(circom_path: &str, input: Object) -> Result<JsValue, JsValue>;
@@ -34,7 +63,7 @@ mod tests {
         let mut results = String::from("\nbenchmarks:\n");
         let iterations = 10;
 
-        let zkey = read_file(&ZKEY_PATH).expect("Failed to read zkey file");
+        let zkey = readFile(&ZKEY_PATH).expect("Failed to read zkey file");
 
         // Benchmark wasm_new
         let start_wasm_new = Date::now();
@@ -188,13 +217,13 @@ mod tests {
         ));
 
         // Log the results
-        wasm_bindgen_test::console_log!("{results}");
+        console_log!("{results}");
     }
 
     #[wasm_bindgen_test]
     pub async fn rln_wasm_test() {
         // Read the zkey file
-        let zkey = read_file(&ZKEY_PATH).expect("Failed to read zkey file");
+        let zkey = readFile(&ZKEY_PATH).expect("Failed to read zkey file");
 
         // Create RLN instance and separated tree
         let rln_instance = wasm_new(zkey).expect("Failed to create RLN instance");