feat(rln-wasm): add browser benchmark with simple HTML file and default data

feat(rln-wasm): add simple benchmark for rln-wasm module
Freeze rust version (#272 )
2026-01-10 06:08:09 -05:00 · 2025-04-01 17:35:29 +07:00 · 2025-03-29 17:10:28 +07:00 · 2025-02-19 18:19:38 +07:00 · 2025-02-19 18:17:03 +07:00 · 2024-10-01 14:16:03 +07:00
38 changed files with 3068 additions and 1720 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,11 +21,11 @@ on:
 name: Tests

 jobs:
-  test:
+  utils-test:
    strategy:
      matrix:
-        platform: [ubuntu-latest, macos-latest]
-        crate: [rln, utils]
+        platform: [ ubuntu-latest, macos-latest ]
+        crate: [ utils ]
    runs-on: ${{ matrix.platform }}
    timeout-minutes: 60

@@ -47,10 +47,37 @@ jobs:
          cargo make test --release
        working-directory: ${{ matrix.crate }}

+  rln-test:
+    strategy:
+      matrix:
+        platform: [ ubuntu-latest, macos-latest ]
+        crate: [ rln ]
+        feature: [ "default", "arkzkey", "stateless" ]
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 60
+
+    name: test - ${{ matrix.crate }} - ${{ matrix.platform }} - ${{ matrix.feature }}
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - uses: Swatinem/rust-cache@v2
+      - name: Install dependencies
+        run: make installdeps
+      - name: cargo-make test
+        run: |
+          cargo make test_${{ matrix.feature }} --release
+        working-directory: ${{ matrix.crate }}
+
  rln-wasm:
    strategy:
      matrix:
-        platform: [ubuntu-latest, macos-latest]
+        platform: [ ubuntu-latest, macos-latest ]
    runs-on: ${{ matrix.platform }}
    timeout-minutes: 60

@@ -61,7 +88,8 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: stable
+          # TODO: Update to stable once wasmer supports it
+          toolchain: 1.82.0
          override: true
      - uses: Swatinem/rust-cache@v2
      - name: Install Dependencies
@@ -77,8 +105,8 @@ jobs:
    strategy:
      matrix:
        # we run lint tests only on ubuntu
-        platform: [ubuntu-latest]
-        crate: [rln, utils]
+        platform: [ ubuntu-latest ]
+        crate: [ rln, utils ]
    runs-on: ${{ matrix.platform }}
    timeout-minutes: 60

@@ -108,14 +136,15 @@ jobs:
        # We skip clippy on rln-wasm, since wasm target is managed by cargo make
        # Currently not treating warnings as error, too noisy
        # -- -D warnings
-  benchmark:
+
+  benchmark-utils:
    # run only in pull requests
    if: github.event_name == 'pull_request'
    strategy:
      matrix:
        # we run benchmark tests only on ubuntu
-        platform: [ubuntu-latest]
-        crate: [rln, utils]
+        platform: [ ubuntu-latest ]
+        crate: [ utils ]
    runs-on: ${{ matrix.platform }}
    timeout-minutes: 60

@@ -128,3 +157,26 @@ jobs:
        with:
          branchName: ${{ github.base_ref }}
          cwd: ${{ matrix.crate }}
+
+  benchmark-rln:
+    # run only in pull requests
+    if: github.event_name == 'pull_request'
+    strategy:
+      matrix:
+        # we run benchmark tests only on ubuntu
+        platform: [ ubuntu-latest ]
+        crate: [ rln ]
+        feature: [ "default", "arkzkey" ]
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 60
+
+    name: benchmark - ${{ matrix.platform }} - ${{ matrix.crate }} - ${{ matrix.feature }}
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: Swatinem/rust-cache@v2
+      - uses: boa-dev/criterion-compare-action@v3
+        with:
+          branchName: ${{ github.base_ref }}
+          cwd: ${{ matrix.crate }}
+          features: ${{ matrix.feature }}
--- a/.github/workflows/nightly-release.yml
+++ b/.github/workflows/nightly-release.yml
@@ -8,11 +8,14 @@ jobs:
  linux:
    strategy:
      matrix:
-        feature: ["default", "arkzkey"]
+        feature: [ "default", "arkzkey", "stateless" ]
        target:
          - x86_64-unknown-linux-gnu
          - aarch64-unknown-linux-gnu
          - i686-unknown-linux-gnu
+        include:
+          - feature: stateless
+            cargo_args: --exclude rln-cli
    name: Linux build
    runs-on: ubuntu-latest
    steps:
@@ -30,13 +33,13 @@ jobs:
        run: make installdeps
      - name: cross build
        run: |
-          cross build --release --target ${{ matrix.target }} --features ${{ matrix.feature }} --workspace --exclude rln-wasm
+          cross build --release --target ${{ matrix.target }} --features ${{ matrix.feature }} --workspace --exclude rln-wasm ${{ matrix.cargo_args }}
          mkdir release
          cp target/${{ matrix.target }}/release/librln* release/
          tar -czvf ${{ matrix.target }}-${{ matrix.feature }}-rln.tar.gz release/

      - name: Upload archive artifact
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.target }}-${{ matrix.feature }}-archive
          path: ${{ matrix.target }}-${{ matrix.feature }}-rln.tar.gz
@@ -47,10 +50,13 @@ jobs:
    runs-on: macos-latest
    strategy:
      matrix:
-        feature: ["default", "arkzkey"]
+        feature: [ "default", "arkzkey", "stateless" ]
        target:
          - x86_64-apple-darwin
          - aarch64-apple-darwin
+        include:
+          - feature: stateless
+            cargo_args: --exclude rln-cli
    steps:
      - name: Checkout sources
        uses: actions/checkout@v3
@@ -66,13 +72,13 @@ jobs:
        run: make installdeps
      - name: cross build
        run: |
-          cross build --release --target ${{ matrix.target }} --features ${{ matrix.feature }} --workspace --exclude rln-wasm
+          cross build --release --target ${{ matrix.target }} --features ${{ matrix.feature }} --workspace --exclude rln-wasm ${{ matrix.cargo_args }}
          mkdir release
          cp target/${{ matrix.target }}/release/librln* release/
          tar -czvf ${{ matrix.target }}-${{ matrix.feature }}-rln.tar.gz release/

      - name: Upload archive artifact
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.target }}-${{ matrix.feature }}-archive
          path: ${{ matrix.target }}-${{ matrix.feature }}-rln.tar.gz
@@ -88,7 +94,8 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: stable
+          # TODO: Update to stable once wasmer supports it
+          toolchain: 1.82.0
          override: true
      - uses: Swatinem/rust-cache@v2
      - name: Install dependencies
@@ -104,7 +111,7 @@ jobs:
        working-directory: rln-wasm

      - name: Upload archive artifact
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
        with:
          name: browser-rln-wasm-archive
          path: rln-wasm/browser-rln-wasm.tar.gz
@@ -112,7 +119,7 @@ jobs:

  prepare-prerelease:
    name: Prepare pre-release
-    needs: [linux, macos, browser-rln-wasm]
+    needs: [ linux, macos, browser-rln-wasm ]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
@@ -120,7 +127,7 @@ jobs:
        with:
          ref: master
      - name: Download artifacts
-        uses: actions/download-artifact@v2
+        uses: actions/download-artifact@v4

      - name: Delete tag
        uses: dev-drprasad/delete-tag-and-release@v0.2.1
@@ -143,7 +150,7 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Delete artifacts
-        uses: geekyeggo/delete-artifact@v1
+        uses: geekyeggo/delete-artifact@v5
        with:
          failOnError: false
          name: |
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4

 [[package]]
 name = "addr2line"
@@ -71,9 +71,9 @@ dependencies = [

 [[package]]
 name = "anstyle"
-version = "1.0.0"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41ed9a86bf92ae6580e0a31281f65a1b1d867c0cc68d5346e2ae128dddfa6a7d"
+checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"

 [[package]]
 name = "anstyle-parse"
@@ -993,6 +993,15 @@ dependencies = [
 "subtle",
 ]

+[[package]]
+name = "document-features"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb6969eaabd2421f8a2775cfd2471a2b634372b4a25d41e3bd647b79912850a0"
+dependencies = [
+ "litrs",
+]
+
 [[package]]
 name = "ecdsa"
 version = "0.16.7"
@@ -1460,25 +1469,6 @@ dependencies = [
 "syn 1.0.109",
 ]

-[[package]]
-name = "include_dir"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18762faeff7122e89e0857b02f7ce6fcc0d101d5e9ad2ad7846cc01d61b7f19e"
-dependencies = [
- "include_dir_macros",
-]
-
-[[package]]
-name = "include_dir_macros"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b139284b5cf57ecfa712bcc66950bb635b31aff41c188e8a4cfc758eca374a3f"
-dependencies = [
- "proc-macro2",
- "quote",
-]
-
 [[package]]
 name = "indenter"
 version = "0.3.3"
@@ -1630,6 +1620,12 @@ version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f"

+[[package]]
+name = "litrs"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
+
 [[package]]
 name = "lock_api"
 version = "0.4.9"
@@ -1642,12 +1638,9 @@ dependencies = [

 [[package]]
 name = "log"
-version = "0.4.17"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if",
-]
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"

 [[package]]
 name = "loupe"
@@ -2289,7 +2282,7 @@ dependencies = [

 [[package]]
 name = "rln"
-version = "0.5.0"
+version = "0.6.1"
 dependencies = [
 "ark-bn254",
 "ark-circom",
@@ -2303,7 +2296,8 @@ dependencies = [
 "cfg-if",
 "color-eyre",
 "criterion 0.4.0",
- "include_dir",
+ "document-features",
+ "lazy_static 1.4.0",
 "num-bigint",
 "num-traits",
 "once_cell",
@@ -2332,7 +2326,7 @@ dependencies = [

 [[package]]
 name = "rln-wasm"
-version = "0.0.13"
+version = "0.1.0"
 dependencies = [
 "console_error_panic_hook",
 "getrandom",
@@ -2346,6 +2340,7 @@ dependencies = [
 "wasm-bindgen-test",
 "wasmer",
 "web-sys",
+ "zerokit_utils",
 ]

 [[package]]
@@ -3564,7 +3559,7 @@ dependencies = [

 [[package]]
 name = "zerokit_utils"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
 "ark-bn254",
 "ark-ff",
--- a/rln-cli/Cargo.toml
+++ b/rln-cli/Cargo.toml
@@ -4,7 +4,7 @@ version = "0.3.0"
 edition = "2021"

 [dependencies]
-rln = { path = "../rln" }
+rln = { path = "../rln", default-features = true, features = ["arkzkey"] }
 clap = { version = "4.2.7", features = ["cargo", "derive", "env"]}
 clap_derive = { version = "=4.2.0" }
 color-eyre = "=0.6.2"
--- a/rln-cli/src/main.rs
+++ b/rln-cli/src/main.rs
@@ -38,9 +38,9 @@ fn main() -> Result<()> {
        }) => {
            let mut resources: Vec<Vec<u8>> = Vec::new();
            #[cfg(feature = "arkzkey")]
-            let filenames = ["rln.wasm", "rln_final.arkzkey", "verification_key.json"];
+            let filenames = ["rln.wasm", "rln_final.arkzkey", "verification_key.arkvkey"];
            #[cfg(not(feature = "arkzkey"))]
-            let filenames = ["rln.wasm", "rln_final.zkey", "verification_key.json"];
+            let filenames = ["rln.wasm", "rln_final.zkey", "verification_key.arkvkey"];
            for filename in filenames {
                let fullpath = config.join(Path::new(filename));
                let mut file = File::open(&fullpath)?;
--- a/rln-cli/src/state.rs
+++ b/rln-cli/src/state.rs
@@ -5,12 +5,12 @@ use std::fs::File;
 use crate::config::{Config, InnerConfig};

 #[derive(Default)]
-pub(crate) struct State<'a> {
-    pub rln: Option<RLN<'a>>,
+pub(crate) struct State {
+    pub rln: Option<RLN>,
 }

-impl<'a> State<'a> {
-    pub(crate) fn load_state() -> Result<State<'a>> {
+impl State {
+    pub(crate) fn load_state() -> Result<State> {
        let config = Config::load_config()?;
        let rln = if let Some(InnerConfig { file, tree_height }) = config.inner {
            let resources = File::open(&file)?;
--- a/rln-wasm/Cargo.toml
+++ b/rln-wasm/Cargo.toml
@@ -1,11 +1,8 @@
 [package]
 name = "rln-wasm"
-version = "0.0.13"
+version = "0.1.0"
 edition = "2021"
 license = "MIT or Apache2"
-autobenches = false
-autotests = false
-autobins = false

 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -14,10 +11,16 @@ crate-type = ["cdylib", "rlib"]
 default = ["console_error_panic_hook"]

 [dependencies]
-rln = { path = "../rln", default-features = false, features = ["wasm"] }
-num-bigint = { version = "0.4", default-features = false, features = ["rand", "serde"] }
+rln = { path = "../rln", default-features = false, features = [
+    "wasm",
+    "stateless",
+], version = "=0.6.1"}
+num-bigint = { version = "0.4", default-features = false, features = [
+    "rand",
+    "serde",
+] }
 wasmer = { version = "2.3", default-features = false, features = ["js", "std"] }
-web-sys = {version = "0.3", features=["console"]}
+web-sys = { version = "0.3", features = ["console"] }
 getrandom = { version = "0.2.7", default-features = false, features = ["js"] }
 wasm-bindgen = "0.2.63"
 serde-wasm-bindgen = "0.4"
@@ -29,6 +32,7 @@ serde_json = "1.0.85"
 # all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
 # code size when deploying.
 console_error_panic_hook = { version = "0.1.7", optional = true }
+zerokit_utils = { version = "0.5.1", path = "../utils" }

 [dev-dependencies]
 wasm-bindgen-test = "0.3.13"
--- a/rln-wasm/Makefile.toml
+++ b/rln-wasm/Makefile.toml
@@ -7,11 +7,7 @@ script = "sed -i.bak 's/rln-wasm/zerokit-rln-wasm/g' pkg/package.json && rm pkg/

 [tasks.build]
 clear = true
-dependencies = [
-    "pack-build",
-    "pack-rename",
-    "post-build"
-]
+dependencies = ["pack-build", "pack-rename", "post-build"]

 [tasks.post-build]
 command = "wasm-strip"
--- a/rln-wasm/benchs/calculated_witness
+++ b/rln-wasm/benchs/calculated_witness
--- a/rln-wasm/benchs/index.html
+++ b/rln-wasm/benchs/index.html
@@ -0,0 +1,381 @@
+<!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;
+        }
+    </style>
+</head>
+
+<body>
+    <h1>RLN WASM Benchmark</h1>
+
+    <div class="panel">
+        <div class="file-input">
+            <label for="zkeyFile">zKey File:</label>
+            <input type="file" id="zkeyFile">
+        </div>
+        <div class="file-input">
+            <label for="vkeyFile">vkey File:</label>
+            <input type="file" id="vkeyFile">
+        </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">Run Benchmark</button>
+
+        <div id="status" class="status"></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';
+
+        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');
+
+        // Track benchmark operations
+        const benchmarks = [];
+
+        // 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>
+            `;
+
+            summaryContent.innerHTML = summaryHTML;
+            summarySection.style.display = 'block';
+        }
+
+        // Download results as JSON
+        downloadBtn.addEventListener('click', () => {
+            const dataStr = JSON.stringify({
+                timestamp: new Date().toISOString(),
+                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 () => {
+            const files = {
+                zkey: document.getElementById('zkeyFile').files[0],
+                vkey: document.getElementById('vkeyFile').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.vkey || !files.root || !files.proof) {
+                updateStatus('Please select zKey, vKey, Root, and Proof files', 'error');
+                return;
+            }
+
+            const canGenerate = files.witness && files.message;
+
+            try {
+                // Clear previous results
+                benchmarks.length = 0;
+                updateResults();
+                summarySection.style.display = 'none';
+                runBtn.disabled = true;
+
+                // Initialize
+                const { result: _ } = await benchmark('Initialize WASM Module', async () => {
+                    return await init();
+                });
+
+                // Load files
+                const zkeyData = await readFile(files.zkey);
+                const vkeyData = await readFile(files.vkey);
+                const rootData = await readFile(files.root);
+
+                // Create RLN instance
+                const { result: instance } = await benchmark('Create RLN Instance', async () => {
+                    return RLN.newRLN(zkeyData, vkeyData);
+                });
+
+                // 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;
+            }
+        });
+    </script>
+</body>
+
+</html>
--- a/rln-wasm/benchs/proof_with_signal
+++ b/rln-wasm/benchs/proof_with_signal
--- a/rln-wasm/benchs/root
+++ b/rln-wasm/benchs/root
--- a/rln-wasm/benchs/serialized_message
+++ b/rln-wasm/benchs/serialized_message
--- a/rln-wasm/resources/witness_calculator.js
+++ b/rln-wasm/resources/witness_calculator.js
@@ -1,331 +1,324 @@
 module.exports = async function builder(code, options) {
+  options = 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 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 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 ();
-            }
+  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
-//        );
+  const sanityCheck = options;
+  //        options &&
+  //        (
+  //            options.sanityCheck ||
+  //            options.logGetSignal ||
+  //            options.logSetSignal ||
+  //            options.logStartComponent ||
+  //            options.logFinishComponent
+  //        );

-    
-    wc = new WitnessCalculator(instance, sanityCheck);
-    return wc;
+  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 getMessage() {
+    var message = "";
+    var c = instance.exports.getMessageChar();
+    while (c != 0) {
+      message += String.fromCharCode(c);
+      c = instance.exports.getMessageChar();
    }
-	
-    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);
-	}
+    return message;
+  }

-	// 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());
-	}
+  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;
+  constructor(instance, sanityCheck) {
+    this.instance = instance;

-	this.version = this.instance.exports.getVersion();
-        this.n32 = this.instance.exports.getFieldNumLen32();
+    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.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]);
        }
-        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));
+        try {
+          this.instance.exports.setInputSignal(hMSB, hLSB, i);
+          input_counter++;
+        } catch (err) {
+          // console.log(`After adding signal ${i} of ${k}`)
+          throw new Error(err);
        }
-
-        return w;
+      }
+    });
+    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 calculateBinWitness(input, sanityCheck) {
+  async calculateWitness(input, sanityCheck) {
+    const w = [];

-        const buff32 = new Uint32Array(this.witnessSize*this.n32);
-	const buff = new  Uint8Array( buff32.buffer);
-        await this._doCalculateWitness(input, sanityCheck);
+    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;
+    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;
+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--;
    }
-    if (size) {
-	var i = size - res.length;
-	while (i>0) {
-	    res.unshift(0);
-	    i--;
-	}
-    }
-    return res;
+  }
+  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 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;
+  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 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;
+  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;
 }
--- a/rln-wasm/src/lib.rs
+++ b/rln-wasm/src/lib.rs
@@ -19,7 +19,7 @@ pub fn init_panic_hook() {
 pub struct RLNWrapper {
    // The purpose of this wrapper is to hold a RLN instance with the 'static lifetime
    // because wasm_bindgen does not allow returning elements with lifetimes
-    instance: RLN<'static>,
+    instance: RLN,
 }

 // Macro to call methods with arbitrary amount of arguments,
@@ -150,8 +150,8 @@ impl<T> ProcessArg for Vec<T> {
    }
 }

-impl<'a> ProcessArg for *const RLN<'a> {
-    type ReturnType = &'a RLN<'a>;
+impl ProcessArg for *const RLN {
+    type ReturnType = &'static RLN;
    fn process(self) -> Self::ReturnType {
        unsafe { &*self }
    }
@@ -181,104 +181,32 @@ impl<'a> ProcessArg for &'a [u8] {

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[wasm_bindgen(js_name = newRLN)]
-pub fn wasm_new(
-    tree_height: usize,
-    zkey: Uint8Array,
-    vk: Uint8Array,
-) -> Result<*mut RLNWrapper, String> {
-    let instance = RLN::new_with_params(tree_height, zkey.to_vec(), vk.to_vec())
-        .map_err(|err| format!("{:#?}", err))?;
+pub fn wasm_new(zkey: Uint8Array, vk: Uint8Array) -> Result<*mut RLNWrapper, String> {
+    let instance =
+        RLN::new_with_params(zkey.to_vec(), vk.to_vec()).map_err(|err| format!("{:#?}", err))?;
    let wrapper = RLNWrapper { instance };
    Ok(Box::into_raw(Box::new(wrapper)))
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = getSerializedRLNWitness)]
-pub fn wasm_get_serialized_rln_witness(
-    ctx: *mut RLNWrapper,
-    input: Uint8Array,
-) -> Result<Uint8Array, String> {
-    let rln_witness = call!(ctx, get_serialized_rln_witness, &input.to_vec()[..])
-        .map_err(|err| format!("{:#?}", err))?;
-    Ok(Uint8Array::from(&rln_witness[..]))
-}
-
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = insertMember)]
-pub fn wasm_set_next_leaf(ctx: *mut RLNWrapper, input: Uint8Array) -> Result<(), String> {
-    call_with_error_msg!(
-        ctx,
-        set_next_leaf,
-        "could not insert member into merkle tree".to_string(),
-        &input.to_vec()[..]
-    )
-}
-
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = setLeavesFrom)]
-pub fn wasm_set_leaves_from(
-    ctx: *mut RLNWrapper,
-    index: usize,
-    input: Uint8Array,
-) -> Result<(), String> {
-    call_with_error_msg!(
-        ctx,
-        set_leaves_from,
-        "could not set multiple leaves".to_string(),
-        index,
-        &*input.to_vec()
-    )
-}
-
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = deleteLeaf)]
-pub fn wasm_delete_leaf(ctx: *mut RLNWrapper, index: usize) -> Result<(), String> {
-    call_with_error_msg!(ctx, delete_leaf, "could not delete leaf".to_string(), index)
-}
-
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = setMetadata)]
-pub fn wasm_set_metadata(ctx: *mut RLNWrapper, input: Uint8Array) -> Result<(), String> {
-    call_with_error_msg!(
-        ctx,
-        set_metadata,
-        "could not set metadata".to_string(),
-        &*input.to_vec()
-    )
-}
-
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = getMetadata)]
-pub fn wasm_get_metadata(ctx: *mut RLNWrapper) -> Result<Uint8Array, String> {
-    call_with_output_and_error_msg!(ctx, get_metadata, "could not get metadata".to_string())
-}
-
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = initTreeWithLeaves)]
-pub fn wasm_init_tree_with_leaves(ctx: *mut RLNWrapper, input: Uint8Array) -> Result<(), String> {
-    call_with_error_msg!(
-        ctx,
-        init_tree_with_leaves,
-        "could not init merkle tree".to_string(),
-        &*input.to_vec()
-    )
-}
-
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = RLNWitnessToJson)]
-pub fn rln_witness_to_json(
+#[wasm_bindgen(js_name = rlnWitnessToJson)]
+pub fn wasm_rln_witness_to_json(
    ctx: *mut RLNWrapper,
    serialized_witness: Uint8Array,
 ) -> Result<Object, String> {
-    let inputs = call!(ctx, get_rln_witness_json, &serialized_witness.to_vec()[..])
-        .map_err(|err| err.to_string())?;
+    let inputs = call!(
+        ctx,
+        get_rln_witness_bigint_json,
+        &serialized_witness.to_vec()[..]
+    )
+    .map_err(|err| err.to_string())?;
    let js_value = serde_wasm_bindgen::to_value(&inputs).map_err(|err| err.to_string())?;
    Object::from_entries(&js_value).map_err(|err| format!("{:#?}", err))
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen]
-pub fn generate_rln_proof_with_witness(
+#[wasm_bindgen(js_name = generateRLNProofWithWitness)]
+pub fn wasm_generate_rln_proof_with_witness(
    ctx: *mut RLNWrapper,
    calculated_witness: Vec<JsBigInt>,
    serialized_witness: Uint8Array,
@@ -358,17 +286,6 @@ pub fn wasm_recover_id_secret(
    )
 }

-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = verifyRLNProof)]
-pub fn wasm_verify_rln_proof(ctx: *const RLNWrapper, proof: Uint8Array) -> Result<bool, String> {
-    call_bool_method_with_error_msg!(
-        ctx,
-        verify_rln_proof,
-        "error while verifying rln proof".to_string(),
-        &proof.to_vec()[..]
-    )
-}
-
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[wasm_bindgen(js_name = verifyWithRoots)]
 pub fn wasm_verify_with_roots(
@@ -385,12 +302,6 @@ pub fn wasm_verify_with_roots(
    )
 }

-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[wasm_bindgen(js_name = getRoot)]
-pub fn wasm_get_root(ctx: *const RLNWrapper) -> Result<Uint8Array, String> {
-    call_with_output_and_error_msg!(ctx, get_root, "could not obtain root")
-}
-
 #[wasm_bindgen(js_name = hash)]
 pub fn wasm_hash(input: Uint8Array) -> Result<Uint8Array, String> {
    fn_call_with_output_and_error_msg!(hash, "could not generate hash", &input.to_vec()[..])
--- a/rln-wasm/src/utils.js
+++ b/rln-wasm/src/utils.js
@@ -3,16 +3,24 @@ 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);
-    },
+  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);
-    }
-}
+  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
+    );
+  },
+};
--- a/rln-wasm/tests/rln-wasm.rs
+++ b/rln-wasm/tests/rln-wasm.rs
@@ -2,13 +2,18 @@

 #[cfg(test)]
 mod tests {
-    use js_sys::{BigInt as JsBigInt, Object, Uint8Array};
+    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::utils::vec_fr_to_bytes_le;
+    use rln::utils::vec_u8_to_bytes_le;
    use rln::utils::{bytes_le_to_fr, fr_to_bytes_le, normalize_usize};
    use rln_wasm::*;
    use wasm_bindgen::{prelude::*, JsValue};
    use wasm_bindgen_test::wasm_bindgen_test;
+    use zerokit_utils::merkle_tree::merkle_tree::ZerokitMerkleTree;
+    use zerokit_utils::ZerokitMerkleProof;

    #[wasm_bindgen(module = "src/utils.js")]
    extern "C" {
@@ -19,18 +24,19 @@ mod tests {
        async fn calculateWitness(circom_path: &str, input: Object) -> Result<JsValue, JsValue>;
    }

+    const ZKEY_PATH: &str = "../rln/resources/tree_height_20/rln_final.zkey";
+    const VKEY_PATH: &str = "../rln/resources/tree_height_20/verification_key.arkvkey";
+    const CIRCOM_PATH: &str = "../rln/resources/tree_height_20/rln.wasm";
+
    #[wasm_bindgen_test]
-    pub async fn test_basic_flow() {
-        let tree_height = TEST_TREE_HEIGHT;
-        let circom_path = format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/rln.wasm");
-        let zkey_path = format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/rln_final.zkey");
-        let vk_path =
-            format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/verification_key.json");
-        let zkey = read_file(&zkey_path).unwrap();
-        let vk = read_file(&vk_path).unwrap();
+    pub async fn rln_wasm_test() {
+        let zkey = read_file(&ZKEY_PATH).unwrap();
+        let vk = read_file(&VKEY_PATH).unwrap();

        // Creating an instance of RLN
-        let rln_instance = wasm_new(tree_height, zkey, vk).unwrap();
+        let rln_instance = wasm_new(zkey, vk).unwrap();
+
+        let mut tree = PoseidonTree::default(TEST_TREE_HEIGHT).unwrap();

        // Creating membership key
        let mem_keys = wasm_key_gen(rln_instance).unwrap();
@@ -40,7 +46,7 @@ mod tests {
        // Prepare the message
        let signal = b"Hello World";

-        let identity_index: usize = 0;
+        let identity_index = tree.leaves_set();
        // 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");
@@ -53,35 +59,31 @@ mod tests {

        let (id_commitment_fr, _) = bytes_le_to_fr(&id_commitment.to_vec()[..]);
        let rate_commitment = poseidon_hash(&[id_commitment_fr, user_message_limit]);
+        tree.update_next(rate_commitment).unwrap();

-        // Insert PK
-        wasm_set_next_leaf(
-            rln_instance,
-            Uint8Array::from(fr_to_bytes_le(&rate_commitment).as_slice()),
-        )
-        .unwrap();
+        let x = hash_to_field(signal);
+        let merkle_proof = tree.proof(identity_index).expect("proof should exist");
+        let path_elements = merkle_proof.get_path_elements();
+        let identity_path_index = merkle_proof.get_path_index();

        // Serializing the message
-        let mut serialized_vec: Vec<u8> = Vec::new();
-        serialized_vec.append(&mut id_key.to_vec());
-        serialized_vec.append(&mut normalize_usize(identity_index));
-        serialized_vec.append(&mut fr_to_bytes_le(&user_message_limit).to_vec());
-        serialized_vec.append(&mut message_id.to_vec());
-        serialized_vec.append(&mut external_nullifier.to_vec());
-        serialized_vec.append(&mut normalize_usize(signal.len()));
-        serialized_vec.append(&mut signal.to_vec());
-        let serialized_message = Uint8Array::from(&serialized_vec[..]);
-
-        let serialized_rln_witness =
-            wasm_get_serialized_rln_witness(rln_instance, serialized_message).unwrap();
+        let mut serialized: Vec<u8> = Vec::new();
+        serialized.append(&mut id_key.to_vec());
+        serialized.append(&mut fr_to_bytes_le(&user_message_limit).to_vec());
+        serialized.append(&mut message_id.to_vec());
+        serialized.append(&mut vec_fr_to_bytes_le(&path_elements).unwrap());
+        serialized.append(&mut vec_u8_to_bytes_le(&identity_path_index).unwrap());
+        serialized.append(&mut fr_to_bytes_le(&x));
+        serialized.append(&mut external_nullifier.to_vec());
+        let serialized_message = Uint8Array::from(&serialized[..]);

        // Obtaining inputs that should be sent to circom witness calculator
        let json_inputs =
-            rln_witness_to_json(rln_instance, serialized_rln_witness.clone()).unwrap();
+            wasm_rln_witness_to_json(rln_instance, serialized_message.clone()).unwrap();

        // Calculating witness with JS
        // (Using a JSON since wasm_bindgen does not like Result<Vec<JsBigInt>,JsValue>)
-        let calculated_witness_json = calculateWitness(&circom_path, json_inputs)
+        let calculated_witness_json = calculateWitness(&CIRCOM_PATH, json_inputs)
            .await
            .unwrap()
            .as_string()
@@ -94,10 +96,10 @@ mod tests {
            .collect();

        // Generating proof
-        let proof = generate_rln_proof_with_witness(
+        let proof = wasm_generate_rln_proof_with_witness(
            rln_instance,
-            calculated_witness.into(),
-            serialized_rln_witness,
+            calculated_witness,
+            serialized_message,
        )
        .unwrap();

@@ -105,19 +107,11 @@ mod tests {
        let mut proof_bytes = proof.to_vec();
        proof_bytes.append(&mut normalize_usize(signal.len()));
        proof_bytes.append(&mut signal.to_vec());
-        let proof_with_signal = Uint8Array::from(&proof_bytes[..]);
-
-        // Validate Proof
-        let is_proof_valid = wasm_verify_rln_proof(rln_instance, proof_with_signal);
-
-        assert!(
-            is_proof_valid.unwrap(),
-            "validating proof generated with wasm failed"
-        );

        // Validating Proof with Roots
-        let root = wasm_get_root(rln_instance).unwrap();
-        let roots = Uint8Array::from(&root.to_vec()[..]);
+        let root = tree.root();
+        let root_le = fr_to_bytes_le(&root);
+        let roots = Uint8Array::from(&root_le[..]);
        let proof_with_signal = Uint8Array::from(&proof_bytes[..]);

        let is_proof_valid = wasm_verify_with_roots(rln_instance, proof_with_signal, roots);
@@ -125,24 +119,157 @@ mod tests {
    }

    #[wasm_bindgen_test]
-    fn test_metadata() {
-        let tree_height = TEST_TREE_HEIGHT;
-        let zkey_path = format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/rln_final.zkey");
-        let vk_path =
-            format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/verification_key.json");
-        let zkey = read_file(&zkey_path).unwrap();
-        let vk = read_file(&vk_path).unwrap();
+    pub async fn rln_wasm_benchmark() {
+        let mut results = String::from("benchmarks:\n");
+        let iterations = 10;

-        // Creating an instance of RLN
-        let rln_instance = wasm_new(tree_height, zkey, vk).unwrap();
+        // Benchmark wasm_new
+        let zkey = read_file(&ZKEY_PATH).unwrap();
+        let vk = read_file(&VKEY_PATH).unwrap();
+        let start_wasm_new = Date::now();
+        for _ in 0..iterations {
+            let _ = wasm_new(zkey.clone(), vk.clone()).unwrap();
+        }
+        let wasm_new_result = Date::now() - start_wasm_new;

-        let test_metadata = Uint8Array::new(&JsValue::from_str("test"));
-        // Inserting random metadata
-        wasm_set_metadata(rln_instance, test_metadata.clone()).unwrap();
+        // Initialize instance for other benchmarks
+        let rln_instance = wasm_new(zkey, vk).unwrap();

-        // Getting metadata
-        let metadata = wasm_get_metadata(rln_instance).unwrap();
+        // Benchmark wasm_key_gen
+        let start_wasm_key_gen = Date::now();
+        for _ in 0..iterations {
+            let _ = wasm_key_gen(rln_instance);
+        }
+        let wasm_key_gen_result = Date::now() - start_wasm_key_gen;

-        assert_eq!(metadata.to_vec(), test_metadata.to_vec());
+        // Setup for proof generation and verification
+        let tree = PoseidonTree::default(TEST_TREE_HEIGHT).unwrap();
+        let mem_keys = wasm_key_gen(rln_instance).unwrap();
+        let id_key = mem_keys.subarray(0, 32);
+        let id_commitment = mem_keys.subarray(32, 64);
+        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]);
+
+        // Prepare inputs for other benchmarks
+        let mut benchmark_tree = tree;
+        let signal = b"Hello World";
+        let identity_index = benchmark_tree.leaves_set();
+        let user_message_limit = Fr::from(100);
+        let message_id = fr_to_bytes_le(&Fr::from(0));
+        let external_nullifier_bytes = fr_to_bytes_le(&external_nullifier);
+
+        let (id_commitment_fr, _) = bytes_le_to_fr(&id_commitment.to_vec()[..]);
+        let rate_commitment = poseidon_hash(&[id_commitment_fr, user_message_limit]);
+        benchmark_tree.update_next(rate_commitment).unwrap();
+
+        let x = hash_to_field(signal);
+        let merkle_proof = benchmark_tree
+            .proof(identity_index)
+            .expect("proof should exist");
+        let path_elements = merkle_proof.get_path_elements();
+        let identity_path_index = merkle_proof.get_path_index();
+
+        let mut serialized: Vec<u8> = Vec::new();
+        serialized.append(&mut id_key.to_vec());
+        serialized.append(&mut fr_to_bytes_le(&user_message_limit).to_vec());
+        serialized.append(&mut message_id.to_vec());
+        serialized.append(&mut vec_fr_to_bytes_le(&path_elements).unwrap());
+        serialized.append(&mut vec_u8_to_bytes_le(&identity_path_index).unwrap());
+        serialized.append(&mut fr_to_bytes_le(&x));
+        serialized.append(&mut external_nullifier_bytes.to_vec());
+        let serialized_message = Uint8Array::from(&serialized[..]);
+
+        let json_inputs =
+            wasm_rln_witness_to_json(rln_instance, serialized_message.clone()).unwrap();
+
+        // Benchmark calculateWitness
+        let start_calculate_witness = Date::now();
+        for _ in 0..iterations {
+            let _ = calculateWitness(&CIRCOM_PATH, json_inputs.clone()).await;
+        }
+        let calculate_witness_result = Date::now() - start_calculate_witness;
+
+        // Calculate witness other benchmarks
+        let calculated_witness_json = calculateWitness(&CIRCOM_PATH, json_inputs)
+            .await
+            .unwrap()
+            .as_string()
+            .unwrap();
+        let calculated_witness_vec_str: Vec<String> =
+            serde_json::from_str(&calculated_witness_json).unwrap();
+        let calculated_witness: Vec<JsBigInt> = calculated_witness_vec_str
+            .iter()
+            .map(|x| JsBigInt::new(&x.into()).unwrap())
+            .collect();
+
+        // Benchmark wasm_generate_rln_proof_with_witness
+        let start_generate = Date::now();
+        for _ in 0..iterations {
+            let _ = wasm_generate_rln_proof_with_witness(
+                rln_instance,
+                calculated_witness.clone(),
+                serialized_message.clone(),
+            );
+        }
+        let wasm_generate_proof_result = Date::now() - start_generate;
+
+        // Generate a proof for other benchmarks
+        let proof = wasm_generate_rln_proof_with_witness(
+            rln_instance,
+            calculated_witness,
+            serialized_message,
+        )
+        .unwrap();
+
+        // Prepare verification inputs
+        let mut proof_bytes = proof.to_vec();
+        proof_bytes.append(&mut normalize_usize(signal.len()));
+        proof_bytes.append(&mut signal.to_vec());
+
+        let root = benchmark_tree.root();
+        let root_le = fr_to_bytes_le(&root);
+        let roots = Uint8Array::from(&root_le[..]);
+        let proof_with_signal = Uint8Array::from(&proof_bytes[..]);
+
+        // Benchmark wasm_verify_with_roots
+        let start_verify = Date::now();
+        for _ in 0..iterations {
+            let _ = wasm_verify_with_roots(rln_instance, proof_with_signal.clone(), roots.clone());
+        }
+        let wasm_verify_result = Date::now() - start_verify;
+
+        let is_proof_valid = wasm_verify_with_roots(rln_instance, proof_with_signal, roots);
+        assert!(is_proof_valid.unwrap(), "verifying proof with roots 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!("{:.4} s", avg_ms / 1000.0)
+            } else {
+                format!("{:.2} 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_proof_result)
+        ));
+        results.push_str(&format!(
+            "wasm_verify_with_roots: {}\n",
+            format_duration(wasm_verify_result)
+        ));
+
+        wasm_bindgen_test::console_log!("{results}");
    }
 }
--- a/rln/Cargo.toml
+++ b/rln/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rln"
-version = "0.5.0"
+version = "0.6.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "APIs to manage, compute and verify zkSNARK proofs and RLN primitives"
@@ -48,17 +48,18 @@ num-bigint = { version = "=0.4.3", default-features = false, features = [
 ] }
 num-traits = "=0.2.15"
 once_cell = "=1.17.1"
+lazy_static = "=1.4.0"
 rand = "=0.8.5"
 rand_chacha = "=0.3.1"
 tiny-keccak = { version = "=2.0.2", features = ["keccak"] }
-utils = { package = "zerokit_utils", version = "=0.5.0", path = "../utils/", default-features = false }
+utils = { package = "zerokit_utils", version = "=0.5.1", path = "../utils/", default-features = false }


 # serialization
 serde_json = "=1.0.96"
 serde = { version = "=1.0.163", features = ["derive"] }

-include_dir = "=0.7.3"
+document-features = { version = "=0.2.10", optional = true }

 [dev-dependencies]
 sled = "=0.34.7"
@@ -76,6 +77,7 @@ parallel = [
 wasm = ["wasmer/js", "wasmer/std"]
 fullmerkletree = ["default"]
 arkzkey = ["ark-zkey"]
+stateless = []

 # Note: pmtree feature is still experimental
 pmtree-ft = ["utils/pmtree-ft"]
@@ -88,6 +90,18 @@ harness = false
 name = "circuit_loading_benchmark"
 harness = false

+[[bench]]
+name = "circuit_loading_arkzkey_benchmark"
+harness = false
+required-features = ["arkzkey"]
+
+[[bench]]
+name = "circuit_deser_benchmark"
+harness = false
+
 [[bench]]
 name = "poseidon_tree_benchmark"
 harness = false
+
+[package.metadata.docs.rs]
+all-features = true
--- a/rln/Makefile.toml
+++ b/rln/Makefile.toml
@@ -2,10 +2,18 @@
 command = "cargo"
 args = ["build", "--release"]

-[tasks.test]
+[tasks.test_default]
 command = "cargo"
 args = ["test", "--release"]

+[tasks.test_stateless]
+command = "cargo"
+args = ["test", "--release", "--features", "stateless"]
+
+[tasks.test_arkzkey]
+command = "cargo"
+args = ["test", "--release", "--features", "arkzkey"]
+
 [tasks.bench]
 command = "cargo"
 args = ["bench"]
--- a/rln/README.md
+++ b/rln/README.md
@@ -74,7 +74,7 @@ rln = { git = "https://github.com/vacp2p/zerokit" }

 First, we need to create a RLN object for a chosen input Merkle tree size.

-Note that we need to pass to RLN object constructor the path where the circuit (`rln.wasm`, built for the input tree size), the corresponding proving key (`rln_final.zkey`) or (`rln_final.arkzkey`) and verification key (`verification_key.json`, optional) are found.
+Note that we need to pass to RLN object constructor the path where the circuit (`rln.wasm`, built for the input tree size), the corresponding proving key (`rln_final.zkey`) or (`rln_final.arkzkey`) and verification key (`verification_key.arkvkey`, optional) are found.

 In the following we will use [cursors](https://doc.rust-lang.org/std/io/struct.Cursor.html) as readers/writers for interfacing with RLN public APIs.

--- a/rln/benches/circuit_deser_benchmark.rs
+++ b/rln/benches/circuit_deser_benchmark.rs
@@ -0,0 +1,22 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use rln::circuit::{vk_from_ark_serialized, VK_BYTES};
+
+// Here we benchmark how long the deserialization of the
+// verifying_key takes, only testing the json => verifying_key conversion,
+// and skipping conversion from bytes => string => serde_json::Value
+pub fn vk_deserialize_benchmark(c: &mut Criterion) {
+    let vk = VK_BYTES;
+
+    c.bench_function("vk::vk_from_ark_serialized", |b| {
+        b.iter(|| {
+            let _ = vk_from_ark_serialized(vk);
+        })
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().measurement_time(std::time::Duration::from_secs(10));
+    targets = vk_deserialize_benchmark
+}
+criterion_main!(benches);
--- a/rln/benches/circuit_loading_arkzkey_benchmark.rs
+++ b/rln/benches/circuit_loading_arkzkey_benchmark.rs
@@ -0,0 +1,43 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use rln::circuit::{
+    read_arkzkey_from_bytes_compressed, read_arkzkey_from_bytes_uncompressed, ARKZKEY_BYTES,
+    ARKZKEY_BYTES_UNCOMPR,
+};
+
+pub fn uncompressed_bench(c: &mut Criterion) {
+    let arkzkey = ARKZKEY_BYTES_UNCOMPR.to_vec();
+    let size = arkzkey.len() as f32;
+    println!(
+        "Size of uncompressed arkzkey: {:.2?} MB",
+        size / 1024.0 / 1024.0
+    );
+
+    c.bench_function("arkzkey::arkzkey_from_raw_uncompressed", |b| {
+        b.iter(|| {
+            let r = read_arkzkey_from_bytes_uncompressed(&arkzkey);
+            assert_eq!(r.is_ok(), true);
+        })
+    });
+}
+pub fn compressed_bench(c: &mut Criterion) {
+    let arkzkey = ARKZKEY_BYTES.to_vec();
+    let size = arkzkey.len() as f32;
+    println!(
+        "Size of compressed arkzkey: {:.2?} MB",
+        size / 1024.0 / 1024.0
+    );
+
+    c.bench_function("arkzkey::arkzkey_from_raw_compressed", |b| {
+        b.iter(|| {
+            let r = read_arkzkey_from_bytes_compressed(&arkzkey);
+            assert_eq!(r.is_ok(), true);
+        })
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().measurement_time(std::time::Duration::from_secs(250));
+    targets = uncompressed_bench, compressed_bench
+}
+criterion_main!(benches);
--- a/rln/benches/circuit_loading_benchmark.rs
+++ b/rln/benches/circuit_loading_benchmark.rs
@@ -1,14 +1,24 @@
+use ark_circom::read_zkey;
 use criterion::{criterion_group, criterion_main, Criterion};
+use std::io::Cursor;

-// Depending on the key type (enabled by the `--features arkzkey` flag)
-// the upload speed from the `rln_final.zkey` or `rln_final.arkzkey` file is calculated
-pub fn key_load_benchmark(c: &mut Criterion) {
-    c.bench_function("zkey::upload_from_folder", |b| {
+pub fn zkey_load_benchmark(c: &mut Criterion) {
+    let zkey = rln::circuit::ZKEY_BYTES.to_vec();
+    let size = zkey.len() as f32;
+    println!("Size of zkey: {:.2?} MB", size / 1024.0 / 1024.0);
+
+    c.bench_function("zkey::zkey_from_raw", |b| {
        b.iter(|| {
-            let _ = rln::circuit::zkey_from_folder();
+            let mut reader = Cursor::new(zkey.clone());
+            let r = read_zkey(&mut reader);
+            assert_eq!(r.is_ok(), true);
        })
    });
 }

-criterion_group!(benches, key_load_benchmark);
+criterion_group! {
+    name = benches;
+    config = Criterion::default().measurement_time(std::time::Duration::from_secs(250));
+    targets = zkey_load_benchmark
+}
 criterion_main!(benches);
--- a/rln/resources/tree_height_20/rln_final_uncompr.arkzkey
+++ b/rln/resources/tree_height_20/rln_final_uncompr.arkzkey
--- a/rln/resources/tree_height_20/verification_key.arkvkey
+++ b/rln/resources/tree_height_20/verification_key.arkvkey
--- a/rln/resources/tree_height_20/verification_key.json
+++ b/rln/resources/tree_height_20/verification_key.json
@@ -1,114 +0,0 @@
-{
- "protocol": "groth16",
- "curve": "bn128",
- "nPublic": 5,
- "vk_alpha_1": [
-  "20491192805390485299153009773594534940189261866228447918068658471970481763042",
-  "9383485363053290200918347156157836566562967994039712273449902621266178545958",
-  "1"
- ],
- "vk_beta_2": [
-  [
-   "6375614351688725206403948262868962793625744043794305715222011528459656738731",
-   "4252822878758300859123897981450591353533073413197771768651442665752259397132"
-  ],
-  [
-   "10505242626370262277552901082094356697409835680220590971873171140371331206856",
-   "21847035105528745403288232691147584728191162732299865338377159692350059136679"
-  ],
-  [
-   "1",
-   "0"
-  ]
- ],
- "vk_gamma_2": [
-  [
-   "10857046999023057135944570762232829481370756359578518086990519993285655852781",
-   "11559732032986387107991004021392285783925812861821192530917403151452391805634"
-  ],
-  [
-   "8495653923123431417604973247489272438418190587263600148770280649306958101930",
-   "4082367875863433681332203403145435568316851327593401208105741076214120093531"
-  ],
-  [
-   "1",
-   "0"
-  ]
- ],
- "vk_delta_2": [
-  [
-   "17077735495685170943380938230836408503627170115414840315502244846025577589191",
-   "14030085636943255545683322474441991939484590437387381169642530788494152024614"
-  ],
-  [
-   "11568745146423307387256571230823432454624378106569286849514884592874522611163",
-   "1838524899938769516485895655063198583192139511330418290063560641219523306282"
-  ],
-  [
-   "1",
-   "0"
-  ]
- ],
- "vk_alphabeta_12": [
-  [
-   [
-    "2029413683389138792403550203267699914886160938906632433982220835551125967885",
-    "21072700047562757817161031222997517981543347628379360635925549008442030252106"
-   ],
-   [
-    "5940354580057074848093997050200682056184807770593307860589430076672439820312",
-    "12156638873931618554171829126792193045421052652279363021382169897324752428276"
-   ],
-   [
-    "7898200236362823042373859371574133993780991612861777490112507062703164551277",
-    "7074218545237549455313236346927434013100842096812539264420499035217050630853"
-   ]
-  ],
-  [
-   [
-    "7077479683546002997211712695946002074877511277312570035766170199895071832130",
-    "10093483419865920389913245021038182291233451549023025229112148274109565435465"
-   ],
-   [
-    "4595479056700221319381530156280926371456704509942304414423590385166031118820",
-    "19831328484489333784475432780421641293929726139240675179672856274388269393268"
-   ],
-   [
-    "11934129596455521040620786944827826205713621633706285934057045369193958244500",
-    "8037395052364110730298837004334506829870972346962140206007064471173334027475"
-   ]
-  ]
- ],
- "IC": [
-  [
-   "4920513730204767532050733107749276406754520419375654722016092399980613788208",
-   "10950491564509418434657706642388934308456795265036074733953533582377584967294",
-   "1"
-  ],
-  [
-   "6815064660695497986531118446154820702646540722664044216580897159556261271171",
-   "17838140936832571103329556013529166877877534025488014783346458943575275015438",
-   "1"
-  ],
-  [
-   "16364982450206976302246609763791333525052810246590359380676749324389440643932",
-   "17092624338100676284548565502349491320314889021833923882585524649862570629227",
-   "1"
-  ],
-  [
-   "3679639231485547795420532910726924727560917141402837495597760107842698404034",
-   "16213191511474848247596810551723578773353083440353745908057321946068926848382",
-   "1"
-  ],
-  [
-   "9215428431027260354679105025212521481930206886203677270216204485256690813172",
-   "934602510541226149881779979217731465262250233587980565969044391353665291792",
-   "1"
-  ],
-  [
-   "8935861545794299876685457331391349387048184820319250771243971382360441890897",
-   "4993459033694759724715904486381952906869986989682015547152342336961693234616",
-   "1"
-  ]
- ]
-}
--- a/rln/src/circuit.rs
+++ b/rln/src/circuit.rs
@@ -6,42 +6,61 @@ use ark_bn254::{
 };
 use ark_groth16::{ProvingKey, VerifyingKey};
 use ark_relations::r1cs::ConstraintMatrices;
+use ark_serialize::CanonicalDeserialize;
 use cfg_if::cfg_if;
 use color_eyre::{Report, Result};
-use num_bigint::BigUint;
-use serde_json::Value;
-use std::str::FromStr;
-
-cfg_if! {
-    if #[cfg(not(target_arch = "wasm32"))] {
-        use ark_circom::{WitnessCalculator};
-        use once_cell::sync::OnceCell;
-        use std::sync::Mutex;
-        use wasmer::{Module, Store};
-        use include_dir::{include_dir, Dir};
-        use std::path::Path;
-    }
-}
-
-cfg_if! {
-    if #[cfg(feature = "arkzkey")] {
-        use ark_zkey::read_arkzkey_from_bytes;
-        const ARKZKEY_FILENAME: &str = "tree_height_20/rln_final.arkzkey";
-
-    } else {
-        use std::io::Cursor;
-        use ark_circom::read_zkey;
-    }
-}
-
-const ZKEY_FILENAME: &str = "tree_height_20/rln_final.zkey";
-const VK_FILENAME: &str = "tree_height_20/verification_key.json";
-const WASM_FILENAME: &str = "tree_height_20/rln.wasm";
-
-pub const TEST_TREE_HEIGHT: usize = 20;

 #[cfg(not(target_arch = "wasm32"))]
-static RESOURCES_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/resources");
+use {
+    ark_circom::WitnessCalculator,
+    lazy_static::lazy_static,
+    std::sync::{Arc, Mutex},
+    wasmer::{Module, Store},
+};
+
+#[cfg(feature = "arkzkey")]
+use {
+    ark_zkey::{read_arkzkey_from_bytes, SerializableConstraintMatrices, SerializableProvingKey},
+    color_eyre::eyre::WrapErr,
+};
+
+#[cfg(not(feature = "arkzkey"))]
+use {ark_circom::read_zkey, std::io::Cursor};
+
+#[cfg(feature = "arkzkey")]
+pub const ARKZKEY_BYTES: &[u8] = include_bytes!("../resources/tree_height_20/rln_final.arkzkey");
+#[cfg(feature = "arkzkey")]
+pub const ARKZKEY_BYTES_UNCOMPR: &[u8] =
+    include_bytes!("../resources/tree_height_20/rln_final_uncompr.arkzkey");
+
+pub const ZKEY_BYTES: &[u8] = include_bytes!("../resources/tree_height_20/rln_final.zkey");
+pub const VK_BYTES: &[u8] = include_bytes!("../resources/tree_height_20/verification_key.arkvkey");
+const WASM_BYTES: &[u8] = include_bytes!("../resources/tree_height_20/rln.wasm");
+
+#[cfg(not(target_arch = "wasm32"))]
+lazy_static! {
+    #[cfg(not(target_arch = "wasm32"))]
+    static ref ZKEY: (ProvingKey<Curve>, ConstraintMatrices<Fr>) = {
+        cfg_if! {
+                if #[cfg(feature = "arkzkey")] {
+                    read_arkzkey_from_bytes_uncompressed(ARKZKEY_BYTES_UNCOMPR).expect("Failed to read arkzkey")
+                } else {
+                    let mut reader = Cursor::new(ZKEY_BYTES);
+                    read_zkey(&mut reader).expect("Failed to read zkey")
+                }
+        }
+    };
+
+    #[cfg(not(target_arch = "wasm32"))]
+    static ref VK: VerifyingKey<Curve> = vk_from_ark_serialized(VK_BYTES).expect("Failed to read vk");
+
+    #[cfg(not(target_arch = "wasm32"))]
+    static ref WITNESS_CALCULATOR: Arc<Mutex<WitnessCalculator>> = {
+        circom_from_raw(WASM_BYTES).expect("Failed to create witness calculator")
+    };
+}
+
+pub const TEST_TREE_HEIGHT: usize = 20;

 // The following types define the pairing friendly elliptic curve, the underlying finite fields and groups default to this module
 // Note that proofs are serialized assuming Fr to be 4x8 = 32 bytes in size. Hence, changing to a curve with different encoding will make proof verification to fail
@@ -55,230 +74,152 @@ pub type G2Affine = ArkG2Affine;
 pub type G2Projective = ArkG2Projective;

 // Loads the proving key using a bytes vector
-pub fn zkey_from_raw(zkey_data: &Vec<u8>) -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
-    if !zkey_data.is_empty() {
-        let proving_key_and_matrices = match () {
-            #[cfg(feature = "arkzkey")]
-            () => read_arkzkey_from_bytes(zkey_data.as_slice())?,
-            #[cfg(not(feature = "arkzkey"))]
-            () => {
-                let mut c = Cursor::new(zkey_data);
-                read_zkey(&mut c)?
-            }
-        };
-        Ok(proving_key_and_matrices)
-    } else {
-        Err(Report::msg("No proving key found!"))
+pub fn zkey_from_raw(zkey_data: &[u8]) -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
+    if zkey_data.is_empty() {
+        return Err(Report::msg("No proving key found!"));
    }
+
+    let proving_key_and_matrices = match () {
+        #[cfg(feature = "arkzkey")]
+        () => read_arkzkey_from_bytes(zkey_data)?,
+        #[cfg(not(feature = "arkzkey"))]
+        () => {
+            let mut reader = Cursor::new(zkey_data);
+            read_zkey(&mut reader)?
+        }
+    };
+
+    Ok(proving_key_and_matrices)
 }

 // Loads the proving key
 #[cfg(not(target_arch = "wasm32"))]
-pub fn zkey_from_folder() -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
-    #[cfg(feature = "arkzkey")]
-    let zkey = RESOURCES_DIR.get_file(Path::new(ARKZKEY_FILENAME));
-    #[cfg(not(feature = "arkzkey"))]
-    let zkey = RESOURCES_DIR.get_file(Path::new(ZKEY_FILENAME));
-
-    if let Some(zkey) = zkey {
-        let proving_key_and_matrices = match () {
-            #[cfg(feature = "arkzkey")]
-            () => read_arkzkey_from_bytes(zkey.contents())?,
-            #[cfg(not(feature = "arkzkey"))]
-            () => {
-                let mut c = Cursor::new(zkey.contents());
-                read_zkey(&mut c)?
-            }
-        };
-        Ok(proving_key_and_matrices)
-    } else {
-        Err(Report::msg("No proving key found!"))
-    }
+pub fn zkey_from_folder() -> &'static (ProvingKey<Curve>, ConstraintMatrices<Fr>) {
+    &ZKEY
 }

 // Loads the verification key from a bytes vector
-pub fn vk_from_raw(vk_data: &[u8], zkey_data: &Vec<u8>) -> Result<VerifyingKey<Curve>> {
-    let verifying_key: VerifyingKey<Curve>;
-
+pub fn vk_from_raw(vk_data: &[u8], zkey_data: &[u8]) -> Result<VerifyingKey<Curve>> {
    if !vk_data.is_empty() {
-        verifying_key = vk_from_vector(vk_data)?;
-        Ok(verifying_key)
-    } else if !zkey_data.is_empty() {
-        let (proving_key, _matrices) = zkey_from_raw(zkey_data)?;
-        verifying_key = proving_key.vk;
-        Ok(verifying_key)
-    } else {
-        Err(Report::msg("No proving/verification key found!"))
+        return vk_from_ark_serialized(vk_data);
    }
+
+    if !zkey_data.is_empty() {
+        let (proving_key, _matrices) = zkey_from_raw(zkey_data)?;
+        return Ok(proving_key.vk);
+    }
+
+    Err(Report::msg("No proving/verification key found!"))
 }

 // Loads the verification key
 #[cfg(not(target_arch = "wasm32"))]
-pub fn vk_from_folder() -> Result<VerifyingKey<Curve>> {
-    let vk = RESOURCES_DIR.get_file(Path::new(VK_FILENAME));
-    let zkey = RESOURCES_DIR.get_file(Path::new(ZKEY_FILENAME));
-
-    let verifying_key: VerifyingKey<Curve>;
-    if let Some(vk) = vk {
-        verifying_key = vk_from_json(vk.contents_utf8().ok_or(Report::msg(
-            "Could not read verification key from JSON file!",
-        ))?)?;
-        Ok(verifying_key)
-    } else if let Some(_zkey) = zkey {
-        let (proving_key, _matrices) = zkey_from_folder()?;
-        verifying_key = proving_key.vk;
-        Ok(verifying_key)
-    } else {
-        Err(Report::msg("No proving/verification key found!"))
-    }
+pub fn vk_from_folder() -> &'static VerifyingKey<Curve> {
+    &VK
 }

-#[cfg(not(target_arch = "wasm32"))]
-static WITNESS_CALCULATOR: OnceCell<Mutex<WitnessCalculator>> = OnceCell::new();
-
 // Initializes the witness calculator using a bytes vector
 #[cfg(not(target_arch = "wasm32"))]
-pub fn circom_from_raw(wasm_buffer: Vec<u8>) -> Result<&'static Mutex<WitnessCalculator>> {
-    WITNESS_CALCULATOR.get_or_try_init(|| {
-        let store = Store::default();
-        let module = Module::new(&store, wasm_buffer)?;
-        let result = WitnessCalculator::from_module(module)?;
-        Ok::<Mutex<WitnessCalculator>, Report>(Mutex::new(result))
-    })
+pub fn circom_from_raw(wasm_buffer: &[u8]) -> Result<Arc<Mutex<WitnessCalculator>>> {
+    let module = Module::new(&Store::default(), wasm_buffer)?;
+    let result = WitnessCalculator::from_module(module)?;
+    Ok(Arc::new(Mutex::new(result)))
 }

 // Initializes the witness calculator
 #[cfg(not(target_arch = "wasm32"))]
-pub fn circom_from_folder() -> Result<&'static Mutex<WitnessCalculator>> {
-    // We read the wasm file
-    let wasm = RESOURCES_DIR.get_file(Path::new(WASM_FILENAME));
-
-    if let Some(wasm) = wasm {
-        let wasm_buffer = wasm.contents();
-        circom_from_raw(wasm_buffer.to_vec())
-    } else {
-        Err(Report::msg("No wasm file found!"))
-    }
+pub fn circom_from_folder() -> &'static Arc<Mutex<WitnessCalculator>> {
+    &WITNESS_CALCULATOR
 }

-// The following function implementations are taken/adapted from https://github.com/gakonst/ark-circom/blob/1732e15d6313fe176b0b1abb858ac9e095d0dbd7/src/zkey.rs
-
-// Utilities to convert a json verification key in a groth16::VerificationKey
-fn fq_from_str(s: &str) -> Result<Fq> {
-    Ok(Fq::from(BigUint::from_str(s)?))
-}
-
-// Extracts the element in G1 corresponding to its JSON serialization
-fn json_to_g1(json: &Value, key: &str) -> Result<G1Affine> {
-    let els: Vec<String> = json
-        .get(key)
-        .ok_or(Report::msg("no json value"))?
-        .as_array()
-        .ok_or(Report::msg("value not an array"))?
-        .iter()
-        .map(|i| i.as_str().ok_or(Report::msg("element is not a string")))
-        .map(|x| x.map(|v| v.to_owned()))
-        .collect::<Result<Vec<String>>>()?;
-
-    Ok(G1Affine::from(G1Projective::new(
-        fq_from_str(&els[0])?,
-        fq_from_str(&els[1])?,
-        fq_from_str(&els[2])?,
-    )))
-}
-
-// Extracts the vector of G1 elements corresponding to its JSON serialization
-fn json_to_g1_vec(json: &Value, key: &str) -> Result<Vec<G1Affine>> {
-    let els: Vec<Vec<String>> = json
-        .get(key)
-        .ok_or(Report::msg("no json value"))?
-        .as_array()
-        .ok_or(Report::msg("value not an array"))?
-        .iter()
-        .map(|i| {
-            i.as_array()
-                .ok_or(Report::msg("element is not an array"))
-                .and_then(|array| {
-                    array
-                        .iter()
-                        .map(|x| x.as_str().ok_or(Report::msg("element is not a string")))
-                        .map(|x| x.map(|v| v.to_owned()))
-                        .collect::<Result<Vec<String>>>()
-                })
-        })
-        .collect::<Result<Vec<Vec<String>>>>()?;
-
-    let mut res = vec![];
-    for coords in els {
-        res.push(G1Affine::from(G1Projective::new(
-            fq_from_str(&coords[0])?,
-            fq_from_str(&coords[1])?,
-            fq_from_str(&coords[2])?,
-        )))
-    }
-
-    Ok(res)
-}
-
-// Extracts the element in G2 corresponding to its JSON serialization
-fn json_to_g2(json: &Value, key: &str) -> Result<G2Affine> {
-    let els: Vec<Vec<String>> = json
-        .get(key)
-        .ok_or(Report::msg("no json value"))?
-        .as_array()
-        .ok_or(Report::msg("value not an array"))?
-        .iter()
-        .map(|i| {
-            i.as_array()
-                .ok_or(Report::msg("element is not an array"))
-                .and_then(|array| {
-                    array
-                        .iter()
-                        .map(|x| x.as_str().ok_or(Report::msg("element is not a string")))
-                        .map(|x| x.map(|v| v.to_owned()))
-                        .collect::<Result<Vec<String>>>()
-                })
-        })
-        .collect::<Result<Vec<Vec<String>>>>()?;
-
-    let x = Fq2::new(fq_from_str(&els[0][0])?, fq_from_str(&els[0][1])?);
-    let y = Fq2::new(fq_from_str(&els[1][0])?, fq_from_str(&els[1][1])?);
-    let z = Fq2::new(fq_from_str(&els[2][0])?, fq_from_str(&els[2][1])?);
-    Ok(G2Affine::from(G2Projective::new(x, y, z)))
-}
-
-// Converts JSON to a VerifyingKey
-fn to_verifying_key(json: serde_json::Value) -> Result<VerifyingKey<Curve>> {
-    Ok(VerifyingKey {
-        alpha_g1: json_to_g1(&json, "vk_alpha_1")?,
-        beta_g2: json_to_g2(&json, "vk_beta_2")?,
-        gamma_g2: json_to_g2(&json, "vk_gamma_2")?,
-        delta_g2: json_to_g2(&json, "vk_delta_2")?,
-        gamma_abc_g1: json_to_g1_vec(&json, "IC")?,
-    })
-}
-
-// Computes the verification key from its JSON serialization
-fn vk_from_json(vk: &str) -> Result<VerifyingKey<Curve>> {
-    let json: Value = serde_json::from_str(vk)?;
-    to_verifying_key(json)
-}
-
-// Computes the verification key from a bytes vector containing its JSON serialization
-fn vk_from_vector(vk: &[u8]) -> Result<VerifyingKey<Curve>> {
-    let json = String::from_utf8(vk.to_vec())?;
-    let json: Value = serde_json::from_str(&json)?;
-
-    to_verifying_key(json)
+// Computes the verification key from a bytes vector containing pre-processed ark-serialized verification key
+// uncompressed, unchecked
+pub fn vk_from_ark_serialized(data: &[u8]) -> Result<VerifyingKey<Curve>> {
+    let vk = VerifyingKey::<Curve>::deserialize_uncompressed_unchecked(data)?;
+    Ok(vk)
 }

 // Checks verification key to be correct with respect to proving key
 #[cfg(not(target_arch = "wasm32"))]
 pub fn check_vk_from_zkey(verifying_key: VerifyingKey<Curve>) -> Result<()> {
-    let (proving_key, _matrices) = zkey_from_folder()?;
+    let (proving_key, _matrices) = zkey_from_folder();
    if proving_key.vk == verifying_key {
        Ok(())
    } else {
        Err(Report::msg("verifying_keys are not equal"))
    }
 }
+
+////////////////////////////////////////////////////////
+// Functions from [arkz-key](https://github.com/zkmopro/ark-zkey/blob/main/src/lib.rs#L106)
+// without print and allow to choose between compressed and uncompressed arkzkey
+////////////////////////////////////////////////////////
+#[cfg(feature = "arkzkey")]
+pub fn read_arkzkey_from_bytes_uncompressed(
+    arkzkey_data: &[u8],
+) -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
+    if arkzkey_data.is_empty() {
+        return Err(Report::msg("No proving key found!"));
+    }
+
+    let mut cursor = std::io::Cursor::new(arkzkey_data);
+
+    let serialized_proving_key =
+        SerializableProvingKey::deserialize_uncompressed_unchecked(&mut cursor)
+            .wrap_err("Failed to deserialize proving key")?;
+
+    let serialized_constraint_matrices =
+        SerializableConstraintMatrices::deserialize_uncompressed_unchecked(&mut cursor)
+            .wrap_err("Failed to deserialize constraint matrices")?;
+
+    // Get on right form for API
+    let proving_key: ProvingKey<Bn254> = serialized_proving_key.0;
+    let constraint_matrices: ConstraintMatrices<ark_bn254::Fr> = ConstraintMatrices {
+        num_instance_variables: serialized_constraint_matrices.num_instance_variables,
+        num_witness_variables: serialized_constraint_matrices.num_witness_variables,
+        num_constraints: serialized_constraint_matrices.num_constraints,
+        a_num_non_zero: serialized_constraint_matrices.a_num_non_zero,
+        b_num_non_zero: serialized_constraint_matrices.b_num_non_zero,
+        c_num_non_zero: serialized_constraint_matrices.c_num_non_zero,
+        a: serialized_constraint_matrices.a.data,
+        b: serialized_constraint_matrices.b.data,
+        c: serialized_constraint_matrices.c.data,
+    };
+
+    Ok((proving_key, constraint_matrices))
+}
+
+#[cfg(feature = "arkzkey")]
+pub fn read_arkzkey_from_bytes_compressed(
+    arkzkey_data: &[u8],
+) -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
+    if arkzkey_data.is_empty() {
+        return Err(Report::msg("No proving key found!"));
+    }
+
+    let mut cursor = std::io::Cursor::new(arkzkey_data);
+
+    let serialized_proving_key =
+        SerializableProvingKey::deserialize_compressed_unchecked(&mut cursor)
+            .wrap_err("Failed to deserialize proving key")?;
+
+    let serialized_constraint_matrices =
+        SerializableConstraintMatrices::deserialize_compressed_unchecked(&mut cursor)
+            .wrap_err("Failed to deserialize constraint matrices")?;
+
+    // Get on right form for API
+    let proving_key: ProvingKey<Bn254> = serialized_proving_key.0;
+    let constraint_matrices: ConstraintMatrices<ark_bn254::Fr> = ConstraintMatrices {
+        num_instance_variables: serialized_constraint_matrices.num_instance_variables,
+        num_witness_variables: serialized_constraint_matrices.num_witness_variables,
+        num_constraints: serialized_constraint_matrices.num_constraints,
+        a_num_non_zero: serialized_constraint_matrices.a_num_non_zero,
+        b_num_non_zero: serialized_constraint_matrices.b_num_non_zero,
+        c_num_non_zero: serialized_constraint_matrices.c_num_non_zero,
+        a: serialized_constraint_matrices.a.data,
+        b: serialized_constraint_matrices.b.data,
+        c: serialized_constraint_matrices.c.data,
+    };
+
+    Ok((proving_key, constraint_matrices))
+}
--- a/rln/src/ffi.rs
+++ b/rln/src/ffi.rs
@@ -143,24 +143,24 @@ impl ProcessArg for *const Buffer {
    }
 }

-impl<'a> ProcessArg for *const RLN<'a> {
-    type ReturnType = &'a RLN<'a>;
+impl ProcessArg for *const RLN {
+    type ReturnType = &'static RLN;
    fn process(self) -> Self::ReturnType {
        unsafe { &*self }
    }
 }

-impl<'a> ProcessArg for *mut RLN<'a> {
-    type ReturnType = &'a mut RLN<'a>;
+impl ProcessArg for *mut RLN {
+    type ReturnType = &'static mut RLN;
    fn process(self) -> Self::ReturnType {
        unsafe { &mut *self }
    }
 }

-/// Buffer struct is taken from
-/// <https://github.com/celo-org/celo-threshold-bls-rs/blob/master/crates/threshold-bls-ffi/src/ffi.rs>
-///
-/// Also heavily inspired by <https://github.com/kilic/rln/blob/master/src/ffi.rs>
+///// Buffer struct is taken from
+///// <https://github.com/celo-org/celo-threshold-bls-rs/blob/master/crates/threshold-bls-ffi/src/ffi.rs>
+/////
+///// Also heavily inspired by <https://github.com/kilic/rln/blob/master/src/ffi.rs>

 #[repr(C)]
 #[derive(Clone, Debug, PartialEq)]
@@ -192,6 +192,7 @@ impl<'a> From<&Buffer> for &'a [u8] {
 ////////////////////////////////////////////////////////

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[cfg(not(feature = "stateless"))]
 #[no_mangle]
 pub extern "C" fn new(tree_height: usize, input_buffer: *const Buffer, ctx: *mut *mut RLN) -> bool {
    match RLN::new(tree_height, input_buffer.process()) {
@@ -207,6 +208,23 @@ pub extern "C" fn new(tree_height: usize, input_buffer: *const Buffer, ctx: *mut
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[cfg(feature = "stateless")]
+#[no_mangle]
+pub extern "C" fn new(ctx: *mut *mut RLN) -> bool {
+    match RLN::new() {
+        Ok(rln) => {
+            unsafe { *ctx = Box::into_raw(Box::new(rln)) };
+            true
+        }
+        Err(err) => {
+            eprintln!("could not instantiate rln: {err}");
+            false
+        }
+    }
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[cfg(not(feature = "stateless"))]
 #[no_mangle]
 pub extern "C" fn new_with_params(
    tree_height: usize,
@@ -234,47 +252,79 @@ pub extern "C" fn new_with_params(
    }
 }

+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[cfg(feature = "stateless")]
+#[no_mangle]
+pub extern "C" fn new_with_params(
+    circom_buffer: *const Buffer,
+    zkey_buffer: *const Buffer,
+    vk_buffer: *const Buffer,
+    ctx: *mut *mut RLN,
+) -> bool {
+    match RLN::new_with_params(
+        circom_buffer.process().to_vec(),
+        zkey_buffer.process().to_vec(),
+        vk_buffer.process().to_vec(),
+    ) {
+        Ok(rln) => {
+            unsafe { *ctx = Box::into_raw(Box::new(rln)) };
+            true
+        }
+        Err(err) => {
+            eprintln!("could not instantiate rln: {err}");
+            false
+        }
+    }
+}
+
 ////////////////////////////////////////////////////////
 // Merkle tree APIs
 ////////////////////////////////////////////////////////
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn set_tree(ctx: *mut RLN, tree_height: usize) -> bool {
    call!(ctx, set_tree, tree_height)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn delete_leaf(ctx: *mut RLN, index: usize) -> bool {
    call!(ctx, delete_leaf, index)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn set_leaf(ctx: *mut RLN, index: usize, input_buffer: *const Buffer) -> bool {
    call!(ctx, set_leaf, index, input_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn get_leaf(ctx: *mut RLN, index: usize, output_buffer: *mut Buffer) -> bool {
    call_with_output_arg!(ctx, get_leaf, output_buffer, index)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn leaves_set(ctx: *mut RLN) -> usize {
    ctx.process().leaves_set()
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn set_next_leaf(ctx: *mut RLN, input_buffer: *const Buffer) -> bool {
    call!(ctx, set_next_leaf, input_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn set_leaves_from(
    ctx: *mut RLN,
    index: usize,
@@ -285,12 +335,14 @@ pub extern "C" fn set_leaves_from(

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn init_tree_with_leaves(ctx: *mut RLN, input_buffer: *const Buffer) -> bool {
    call!(ctx, init_tree_with_leaves, input_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn atomic_operation(
    ctx: *mut RLN,
    index: usize,
@@ -302,6 +354,7 @@ pub extern "C" fn atomic_operation(

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn seq_atomic_operation(
    ctx: *mut RLN,
    leaves_buffer: *const Buffer,
@@ -318,12 +371,14 @@ pub extern "C" fn seq_atomic_operation(

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn get_root(ctx: *const RLN, output_buffer: *mut Buffer) -> bool {
    call_with_output_arg!(ctx, get_root, output_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn get_proof(ctx: *const RLN, index: usize, output_buffer: *mut Buffer) -> bool {
    call_with_output_arg!(ctx, get_proof, output_buffer, index)
 }
@@ -353,6 +408,7 @@ pub extern "C" fn verify(

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn generate_rln_proof(
    ctx: *mut RLN,
    input_buffer: *const Buffer,
@@ -378,6 +434,7 @@ pub extern "C" fn generate_rln_proof_with_witness(

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn verify_rln_proof(
    ctx: *const RLN,
    proof_buffer: *const Buffer,
@@ -461,18 +518,21 @@ pub extern "C" fn recover_id_secret(

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn set_metadata(ctx: *mut RLN, input_buffer: *const Buffer) -> bool {
    call!(ctx, set_metadata, input_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn get_metadata(ctx: *const RLN, output_buffer: *mut Buffer) -> bool {
    call_with_output_arg!(ctx, get_metadata, output_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
+#[cfg(not(feature = "stateless"))]
 pub extern "C" fn flush(ctx: *mut RLN) -> bool {
    call!(ctx, flush)
 }
--- a/rln/src/protocol.rs
+++ b/rln/src/protocol.rs
@@ -739,11 +739,11 @@ where
    a.map_err(serde::de::Error::custom)
 }

-/// Converts a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object to the corresponding JSON serialization.
+/// Converts a JSON value into [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object.
 ///
 /// # Errors
 ///
-/// Returns an error if `message_id` is not within `user_message_limit`.
+/// Returns an error if `rln_witness.message_id` is not within `rln_witness.user_message_limit`.
 pub fn rln_witness_from_json(input_json: serde_json::Value) -> Result<RLNWitnessInput> {
    let rln_witness: RLNWitnessInput = serde_json::from_value(input_json).unwrap();
    message_id_range_check(&rln_witness.message_id, &rln_witness.user_message_limit)?;
@@ -751,11 +751,11 @@ pub fn rln_witness_from_json(input_json: serde_json::Value) -> Result<RLNWitness
    Ok(rln_witness)
 }

-/// Converts a JSON value into [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object.
+/// Converts a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object to the corresponding JSON serialization.
 ///
 /// # Errors
 ///
-/// Returns an error if `rln_witness.message_id` is not within `rln_witness.user_message_limit`.
+/// Returns an error if `message_id` is not within `user_message_limit`.
 pub fn rln_witness_to_json(rln_witness: &RLNWitnessInput) -> Result<serde_json::Value> {
    message_id_range_check(&rln_witness.message_id, &rln_witness.user_message_limit)?;

@@ -763,6 +763,40 @@ pub fn rln_witness_to_json(rln_witness: &RLNWitnessInput) -> Result<serde_json::
    Ok(rln_witness_json)
 }

+/// Converts a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object to the corresponding JSON serialization.
+/// Before serialisation the data should be translated into big int for further calculation in the witness calculator.
+///
+/// # Errors
+///
+/// Returns an error if `message_id` is not within `user_message_limit`.
+pub fn rln_witness_to_bigint_json(rln_witness: &RLNWitnessInput) -> Result<serde_json::Value> {
+    message_id_range_check(&rln_witness.message_id, &rln_witness.user_message_limit)?;
+
+    let mut path_elements = Vec::new();
+
+    for v in rln_witness.path_elements.iter() {
+        path_elements.push(to_bigint(v)?.to_str_radix(10));
+    }
+
+    let mut identity_path_index = Vec::new();
+    rln_witness
+        .identity_path_index
+        .iter()
+        .for_each(|v| identity_path_index.push(BigInt::from(*v).to_str_radix(10)));
+
+    let inputs = serde_json::json!({
+        "identitySecret": to_bigint(&rln_witness.identity_secret)?.to_str_radix(10),
+        "userMessageLimit": to_bigint(&rln_witness.user_message_limit)?.to_str_radix(10),
+        "messageId": to_bigint(&rln_witness.message_id)?.to_str_radix(10),
+        "pathElements": path_elements,
+        "identityPathIndex": identity_path_index,
+        "x": to_bigint(&rln_witness.x)?.to_str_radix(10),
+        "externalNullifier":  to_bigint(&rln_witness.external_nullifier)?.to_str_radix(10),
+    });
+
+    Ok(inputs)
+}
+
 pub fn message_id_range_check(message_id: &Fr, user_message_limit: &Fr) -> Result<()> {
    if message_id > user_message_limit {
        return Err(color_eyre::Report::msg(
--- a/rln/src/public.rs
+++ b/rln/src/public.rs
@@ -1,10 +1,9 @@
 use crate::circuit::{vk_from_raw, zkey_from_raw, Curve, Fr};
 use crate::hashers::{hash_to_field, poseidon_hash as utils_poseidon_hash};
-use crate::poseidon_tree::PoseidonTree;
 use crate::protocol::*;
 use crate::utils::*;
 /// This is the main public API for RLN module. It is used by the FFI, and should be
-/// used by tests etc as well
+/// used by tests etc. as well
 use ark_groth16::Proof as ArkProof;
 use ark_groth16::{ProvingKey, VerifyingKey};
 use ark_relations::r1cs::ConstraintMatrices;
@@ -20,8 +19,10 @@ cfg_if! {
        use std::sync::Mutex;
        use crate::circuit::{circom_from_folder, vk_from_folder, circom_from_raw, zkey_from_folder, TEST_TREE_HEIGHT};
        use ark_circom::WitnessCalculator;
+        use crate::poseidon_tree::PoseidonTree;
        use serde_json::{json, Value};
        use utils::{Hasher};
+        use std::sync::Arc;
        use std::str::FromStr;
    } else {
        use std::marker::*;
@@ -39,38 +40,40 @@ pub const RLN_IDENTIFIER: &[u8] = b"zerokit/rln/010203040506070809";
 /// It implements the methods required to update the internal Merkle Tree, generate and verify RLN ZK proofs.
 ///
 /// I/O is mostly done using writers and readers implementing `std::io::Write` and `std::io::Read`, respectively.
-pub struct RLN<'a> {
+pub struct RLN {
    proving_key: (ProvingKey<Curve>, ConstraintMatrices<Fr>),
    pub(crate) verification_key: VerifyingKey<Curve>,
+    #[cfg(not(feature = "stateless"))]
    pub(crate) tree: PoseidonTree,

    // The witness calculator can't be loaded in zerokit. Since this struct
    // contains a lifetime, a PhantomData is necessary to avoid a compiler
    // error since the lifetime is not being used
    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) witness_calculator: &'a Mutex<WitnessCalculator>,
+    pub(crate) witness_calculator: Arc<Mutex<WitnessCalculator>>,
    #[cfg(target_arch = "wasm32")]
-    _marker: PhantomData<&'a ()>,
+    _marker: PhantomData<()>,
 }

-impl RLN<'_> {
+impl RLN {
    /// Creates a new RLN object by loading circuit resources from a folder.
    ///
    /// Input parameters are
    /// - `tree_height`: the height of the internal Merkle tree
    /// - `input_data`: include `tree_config` a reader for a string containing a json with the merkle tree configuration
+    ///
    /// Example:
    /// ```
    /// use std::io::Cursor;
    ///
    /// let tree_height = 20;
-    /// let input = Cursor::new(json!({}).to_string());;
+    /// let input = Cursor::new(json!({}).to_string());
    ///
    /// // We create a new RLN instance
    /// let mut rln = RLN::new(tree_height, input);
    /// ```
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn new<R: Read>(tree_height: usize, mut input_data: R) -> Result<RLN<'static>> {
+    #[cfg(all(not(target_arch = "wasm32"), not(feature = "stateless")))]
+    pub fn new<R: Read>(tree_height: usize, mut input_data: R) -> Result<RLN> {
        // We read input
        let mut input: Vec<u8> = Vec::new();
        input_data.read_to_end(&mut input)?;
@@ -78,10 +81,10 @@ impl RLN<'_> {
        let rln_config: Value = serde_json::from_str(&String::from_utf8(input)?)?;
        let tree_config = rln_config["tree_config"].to_string();

-        let witness_calculator = circom_from_folder()?;
-        let proving_key = zkey_from_folder()?;
+        let witness_calculator = circom_from_folder();
+        let proving_key = zkey_from_folder();

-        let verification_key = vk_from_folder()?;
+        let verification_key = vk_from_folder();

        let tree_config: <PoseidonTree as ZerokitMerkleTree>::Config = if tree_config.is_empty() {
            <PoseidonTree as ZerokitMerkleTree>::Config::default()
@@ -97,22 +100,48 @@ impl RLN<'_> {
        )?;

        Ok(RLN {
-            witness_calculator,
-            proving_key,
-            verification_key,
+            witness_calculator: witness_calculator.to_owned(),
+            proving_key: proving_key.to_owned(),
+            verification_key: verification_key.to_owned(),
+            #[cfg(not(feature = "stateless"))]
            tree,
            #[cfg(target_arch = "wasm32")]
            _marker: PhantomData,
        })
    }

+    /// Creates a new stateless RLN object by loading circuit resources from a folder.
+    ///
+    /// Example:
+    ///
+    /// ```
+    /// // We create a new RLN instance
+    /// let mut rln = RLN::new();
+    /// ```
+    #[cfg_attr(docsrs, doc(cfg(feature = "stateless")))]
+    #[cfg(all(not(target_arch = "wasm32"), feature = "stateless"))]
+    pub fn new() -> Result<RLN> {
+        #[cfg(not(target_arch = "wasm32"))]
+        let witness_calculator = circom_from_folder();
+        let proving_key = zkey_from_folder();
+        let verification_key = vk_from_folder();
+
+        Ok(RLN {
+            witness_calculator: witness_calculator.to_owned(),
+            proving_key: proving_key.to_owned(),
+            verification_key: verification_key.to_owned(),
+            #[cfg(target_arch = "wasm32")]
+            _marker: PhantomData,
+        })
+    }
+
    /// Creates a new RLN object by passing circuit resources as byte vectors.
    ///
    /// Input parameters are
    /// - `tree_height`: the height of the internal Merkle tree
    /// - `circom_vec`: a byte vector containing the ZK circuit (`rln.wasm`) as binary file
    /// - `zkey_vec`: a byte vector containing to the proving key (`rln_final.zkey`)  or (`rln_final.arkzkey`) as binary file
-    /// - `vk_vec`: a byte vector containing to the verification key (`verification_key.json`) as binary file
+    /// - `vk_vec`: a byte vector containing to the verification key (`verification_key.arkvkey`) as binary file
    /// - `tree_config_input`: a reader for a string containing a json with the merkle tree configuration
    ///
    /// Example:
@@ -124,7 +153,7 @@ impl RLN<'_> {
    /// let resources_folder = "./resources/tree_height_20/";
    ///
    /// let mut resources: Vec<Vec<u8>> = Vec::new();
-    /// for filename in ["rln.wasm", "rln_final.zkey", "verification_key.json"] {
+    /// for filename in ["rln.wasm", "rln_final.zkey", "verification_key.arkvkey"] {
    ///     let fullpath = format!("{resources_folder}{filename}");
    ///     let mut file = File::open(&fullpath).expect("no file found");
    ///     let metadata = std::fs::metadata(&fullpath).expect("unable to read metadata");
@@ -143,16 +172,16 @@ impl RLN<'_> {
    ///     tree_config_input,
    /// );
    /// ```
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_arch = "wasm32"), not(feature = "stateless")))]
    pub fn new_with_params<R: Read>(
        tree_height: usize,
        circom_vec: Vec<u8>,
        zkey_vec: Vec<u8>,
        vk_vec: Vec<u8>,
        mut tree_config_input: R,
-    ) -> Result<RLN<'static>> {
+    ) -> Result<RLN> {
        #[cfg(not(target_arch = "wasm32"))]
-        let witness_calculator = circom_from_raw(circom_vec)?;
+        let witness_calculator = circom_from_raw(&circom_vec)?;

        let proving_key = zkey_from_raw(&zkey_vec)?;
        let verification_key = vk_from_raw(&vk_vec, &zkey_vec)?;
@@ -178,29 +207,93 @@ impl RLN<'_> {
            witness_calculator,
            proving_key,
            verification_key,
+            #[cfg(not(feature = "stateless"))]
            tree,
+            #[cfg(target_arch = "wasm32")]
+            _marker: PhantomData,
        })
    }

-    #[cfg(target_arch = "wasm32")]
-    pub fn new_with_params(
-        tree_height: usize,
-        zkey_vec: Vec<u8>,
-        vk_vec: Vec<u8>,
-    ) -> Result<RLN<'static>> {
-        #[cfg(not(target_arch = "wasm32"))]
-        let witness_calculator = circom_from_raw(circom_vec)?;
+    /// Creates a new stateless RLN object by passing circuit resources as byte vectors.
+    ///
+    /// Input parameters are
+    /// - `circom_vec`: a byte vector containing the ZK circuit (`rln.wasm`) as binary file
+    /// - `zkey_vec`: a byte vector containing to the proving key (`rln_final.zkey`)  or (`rln_final.arkzkey`) as binary file
+    /// - `vk_vec`: a byte vector containing to the verification key (`verification_key.arkvkey`) as binary file
+    ///
+    /// Example:
+    /// ```
+    /// use std::fs::File;
+    /// use std::io::Read;
+    ///
+    /// let resources_folder = "./resources/tree_height_20/";
+    ///
+    /// let mut resources: Vec<Vec<u8>> = Vec::new();
+    /// for filename in ["rln.wasm", "rln_final.zkey", "verification_key.arkvkey"] {
+    ///     let fullpath = format!("{resources_folder}{filename}");
+    ///     let mut file = File::open(&fullpath).expect("no file found");
+    ///     let metadata = std::fs::metadata(&fullpath).expect("unable to read metadata");
+    ///     let mut buffer = vec![0; metadata.len() as usize];
+    ///     file.read_exact(&mut buffer).expect("buffer overflow");
+    ///     resources.push(buffer);
+    /// }
+    ///
+    /// let mut rln = RLN::new_with_params(
+    ///     resources[0].clone(),
+    ///     resources[1].clone(),
+    ///     resources[2].clone(),
+    /// );
+    /// ```
+    #[cfg(all(not(target_arch = "wasm32"), feature = "stateless"))]
+    pub fn new_with_params(circom_vec: Vec<u8>, zkey_vec: Vec<u8>, vk_vec: Vec<u8>) -> Result<RLN> {
+        let witness_calculator = circom_from_raw(&circom_vec)?;

        let proving_key = zkey_from_raw(&zkey_vec)?;
        let verification_key = vk_from_raw(&vk_vec, &zkey_vec)?;

-        // We compute a default empty tree
-        let tree = PoseidonTree::default(tree_height)?;
+        Ok(RLN {
+            witness_calculator,
+            proving_key,
+            verification_key,
+        })
+    }
+
+    /// Creates a new stateless RLN object by passing circuit resources as byte vectors.
+    ///
+    /// Input parameters are
+    /// - `zkey_vec`: a byte vector containing to the proving key (`rln_final.zkey`)  or (`rln_final.arkzkey`) as binary file
+    /// - `vk_vec`: a byte vector containing to the verification key (`verification_key.arkvkey`) as binary file
+    ///
+    /// Example:
+    /// ```
+    /// use std::fs::File;
+    /// use std::io::Read;
+    ///
+    /// let resources_folder = "./resources/tree_height_20/";
+    ///
+    /// let mut resources: Vec<Vec<u8>> = Vec::new();
+    /// for filename in ["rln_final.zkey", "verification_key.arkvkey"] {
+    ///     let fullpath = format!("{resources_folder}{filename}");
+    ///     let mut file = File::open(&fullpath).expect("no file found");
+    ///     let metadata = std::fs::metadata(&fullpath).expect("unable to read metadata");
+    ///     let mut buffer = vec![0; metadata.len() as usize];
+    ///     file.read_exact(&mut buffer).expect("buffer overflow");
+    ///     resources.push(buffer);
+    /// }
+    ///
+    /// let mut rln = RLN::new_with_params(
+    ///     resources[0].clone(),
+    ///     resources[1].clone(),
+    /// );
+    /// ```
+    #[cfg(all(target_arch = "wasm32", feature = "stateless"))]
+    pub fn new_with_params(zkey_vec: Vec<u8>, vk_vec: Vec<u8>) -> Result<RLN> {
+        let proving_key = zkey_from_raw(&zkey_vec)?;
+        let verification_key = vk_from_raw(&vk_vec, &zkey_vec)?;

        Ok(RLN {
            proving_key,
            verification_key,
-            tree,
            _marker: PhantomData,
        })
    }
@@ -214,6 +307,7 @@ impl RLN<'_> {
    ///
    /// Input values are:
    /// - `tree_height`: the height of the Merkle tree.
+    #[cfg(not(feature = "stateless"))]
    pub fn set_tree(&mut self, tree_height: usize) -> Result<()> {
        // We compute a default empty tree of desired height
        self.tree = PoseidonTree::default(tree_height)?;
@@ -244,6 +338,7 @@ impl RLN<'_> {
    /// let mut buffer = Cursor::new(serialize_field_element(rate_commitment));
    /// rln.set_leaf(id_index, &mut buffer).unwrap();
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn set_leaf<R: Read>(&mut self, index: usize, mut input_data: R) -> Result<()> {
        // We read input
        let mut leaf_byte: Vec<u8> = Vec::new();
@@ -273,6 +368,7 @@ impl RLN<'_> {
    /// let mut buffer = Cursor::new(Vec::<u8>::new());
    /// rln.get_leaf(id_index, &mut buffer).unwrap();
    /// let rate_commitment = deserialize_field_element(&buffer.into_inner()).unwrap();
+    #[cfg(not(feature = "stateless"))]
    pub fn get_leaf<W: Write>(&self, index: usize, mut output_data: W) -> Result<()> {
        // We get the leaf at input index
        let leaf = self.tree.get(index)?;
@@ -315,6 +411,7 @@ impl RLN<'_> {
    /// let mut buffer = Cursor::new(vec_fr_to_bytes_le(&leaves));
    /// rln.set_leaves_from(index, &mut buffer).unwrap();
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn set_leaves_from<R: Read>(&mut self, index: usize, mut input_data: R) -> Result<()> {
        // We read input
        let mut leaves_byte: Vec<u8> = Vec::new();
@@ -335,6 +432,7 @@ impl RLN<'_> {
    ///
    /// Input values are:
    /// - `input_data`: a reader for the serialization of multiple leaf values (serialization done with [`rln::utils::vec_fr_to_bytes_le`](crate::utils::vec_fr_to_bytes_le))
+    #[cfg(not(feature = "stateless"))]
    pub fn init_tree_with_leaves<R: Read>(&mut self, input_data: R) -> Result<()> {
        // reset the tree
        // NOTE: this requires the tree to be initialized with the correct height initially
@@ -385,6 +483,7 @@ impl RLN<'_> {
    /// let mut indices_buffer = Cursor::new(vec_u8_to_bytes_le(&indices));
    /// rln.atomic_operation(index, &mut leaves_buffer, indices_buffer).unwrap();
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn atomic_operation<R: Read>(
        &mut self,
        index: usize,
@@ -410,6 +509,7 @@ impl RLN<'_> {
        Ok(())
    }

+    #[cfg(not(feature = "stateless"))]
    pub fn leaves_set(&mut self) -> usize {
        self.tree.leaves_set()
    }
@@ -457,6 +557,7 @@ impl RLN<'_> {
    /// let mut buffer = Cursor::new(fr_to_bytes_le(&rate_commitment));
    /// rln.set_next_leaf(&mut buffer).unwrap();
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn set_next_leaf<R: Read>(&mut self, mut input_data: R) -> Result<()> {
        // We read input
        let mut leaf_byte: Vec<u8> = Vec::new();
@@ -469,7 +570,7 @@ impl RLN<'_> {
        Ok(())
    }

-    /// Sets the value of the leaf at position index to the harcoded default value.
+    /// Sets the value of the leaf at position index to the hardcoded default value.
    ///
    /// This function does not change the internal Merkle tree `next_index` value.
    ///
@@ -482,6 +583,7 @@ impl RLN<'_> {
    /// let index = 10;
    /// rln.delete_leaf(index).unwrap();
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn delete_leaf(&mut self, index: usize) -> Result<()> {
        self.tree.delete(index)?;
        Ok(())
@@ -499,6 +601,7 @@ impl RLN<'_> {
    /// let metadata = b"some metadata";
    /// rln.set_metadata(metadata).unwrap();
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn set_metadata(&mut self, metadata: &[u8]) -> Result<()> {
        self.tree.set_metadata(metadata)?;
        Ok(())
@@ -518,6 +621,7 @@ impl RLN<'_> {
    /// rln.get_metadata(&mut buffer).unwrap();
    /// let metadata = buffer.into_inner();
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn get_metadata<W: Write>(&self, mut output_data: W) -> Result<()> {
        let metadata = self.tree.metadata()?;
        output_data.write_all(&metadata)?;
@@ -537,6 +641,7 @@ impl RLN<'_> {
    /// rln.get_root(&mut buffer).unwrap();
    /// let (root, _) = bytes_le_to_fr(&buffer.into_inner());
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn get_root<W: Write>(&self, mut output_data: W) -> Result<()> {
        let root = self.tree.root();
        output_data.write_all(&fr_to_bytes_le(&root))?;
@@ -559,6 +664,7 @@ impl RLN<'_> {
    /// rln.get_subtree_root(level, index, &mut buffer).unwrap();
    /// let (subroot, _) = bytes_le_to_fr(&buffer.into_inner());
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn get_subtree_root<W: Write>(
        &self,
        level: usize,
@@ -592,6 +698,7 @@ impl RLN<'_> {
    /// let (path_elements, read) = bytes_le_to_vec_fr(&buffer_inner);
    /// let (identity_path_index, _) = bytes_le_to_vec_u8(&buffer_inner[read..].to_vec());
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn get_proof<W: Write>(&self, index: usize, mut output_data: W) -> Result<()> {
        let merkle_proof = self.tree.proof(index).expect("proof should exist");
        let path_elements = merkle_proof.get_path_elements();
@@ -635,6 +742,7 @@ impl RLN<'_> {
    /// let idxs = bytes_le_to_vec_usize(&buffer.into_inner()).unwrap();
    /// assert_eq!(idxs, [0, 1, 2, 3, 4]);
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn get_empty_leaves_indices<W: Write>(&self, mut output_data: W) -> Result<()> {
        let idxs = self.tree.get_empty_leaves_indices();
        idxs.serialize_compressed(&mut output_data)?;
@@ -682,7 +790,7 @@ impl RLN<'_> {
        }
        */

-        let proof = generate_proof(self.witness_calculator, &self.proving_key, &rln_witness)?;
+        let proof = generate_proof(&self.witness_calculator, &self.proving_key, &rln_witness)?;

        // Note: we export a serialization of ark-groth16::Proof not semaphore::Proof
        proof.serialize_compressed(&mut output_data)?;
@@ -694,7 +802,7 @@ impl RLN<'_> {
    ///
    /// Input values are:
    /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values,
-    ///  i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`, where <_> indicates the byte length.
+    ///   i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`, where <_> indicates the byte length.
    ///
    /// The function returns true if the zkSNARK proof is valid with respect to the provided circuit output values, false otherwise.
    ///
@@ -793,7 +901,7 @@ impl RLN<'_> {
    /// // proof_data is [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]
    /// let mut proof_data = output_buffer.into_inner();
    /// ```
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_arch = "wasm32"), not(feature = "stateless")))]
    pub fn generate_rln_proof<R: Read, W: Write>(
        &mut self,
        mut input_data: R,
@@ -805,7 +913,7 @@ impl RLN<'_> {
        let (rln_witness, _) = proof_inputs_to_rln_witness(&mut self.tree, &witness_byte)?;
        let proof_values = proof_values_from_witness(&rln_witness)?;

-        let proof = generate_proof(self.witness_calculator, &self.proving_key, &rln_witness)?;
+        let proof = generate_proof(&self.witness_calculator, &self.proving_key, &rln_witness)?;

        // Note: we export a serialization of ark-groth16::Proof not semaphore::Proof
        // This proof is compressed, i.e. 128 bytes long
@@ -853,7 +961,7 @@ impl RLN<'_> {
        let (rln_witness, _) = deserialize_witness(&witness_byte)?;
        let proof_values = proof_values_from_witness(&rln_witness)?;

-        let proof = generate_proof(self.witness_calculator, &self.proving_key, &rln_witness)?;
+        let proof = generate_proof(&self.witness_calculator, &self.proving_key, &rln_witness)?;

        // Note: we export a serialization of ark-groth16::Proof not semaphore::Proof
        // This proof is compressed, i.e. 128 bytes long
@@ -866,11 +974,11 @@ impl RLN<'_> {
    ///
    /// Input values are:
    /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values and the signal information,
-    ///  i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var>]`, where <_> indicates the byte length.
+    ///   i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var>]`, where <_> indicates the byte length.
    ///
    /// The function returns true if the zkSNARK proof is valid with respect to the provided circuit output values and signal. Returns false otherwise.
    ///
-    /// Note that contrary to [`verify`](crate::public::RLN::verify), this function takes additionaly as input the signal and further verifies if
+    /// Note that contrary to [`verify`](crate::public::RLN::verify), this function takes additionally as input the signal and further verifies if
    /// - the Merkle tree root corresponds to the root provided as input;
    /// - the input signal corresponds to the Shamir's x coordinate provided as input
    /// - the hardcoded application [RLN identifier](crate::public::RLN_IDENTIFIER) corresponds to the RLN identifier provided as input
@@ -890,6 +998,7 @@ impl RLN<'_> {
    ///
    /// assert!(verified);
    /// ```
+    #[cfg(not(feature = "stateless"))]
    pub fn verify_rln_proof<R: Read>(&self, mut input_data: R) -> Result<bool> {
        let mut serialized: Vec<u8> = Vec::new();
        input_data.read_to_end(&mut serialized)?;
@@ -918,7 +1027,7 @@ impl RLN<'_> {
    ///
    /// Input values are:
    /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values and the signal information, i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var>]`
-    /// - `roots_data`: a reader for the serialization of a vector of roots, i.e. `[ number_of_roots<8> | root_1<32> | ... | root_n<32> ]` (number_of_roots is a uint64 in little-endian, roots are serialized using `rln::utils::fr_to_bytes_le`))
+    /// - `roots_data`: a reader for the serialization of a vector of roots, i.e. `[ number_of_roots<8> | root_1<32> | ... | root_n<32> ]` (number_of_roots is an uint64 in little-endian, roots are serialized using `rln::utils::fr_to_bytes_le`)
    ///
    /// The function returns true if the zkSNARK proof is valid with respect to the provided circuit output values, signal and roots. Returns false otherwise.
    ///
@@ -1063,7 +1172,7 @@ impl RLN<'_> {
    /// Generated credentials are compatible with [Semaphore](https://semaphore.appliedzkp.org/docs/guides/identities)'s credentials.
    ///
    /// Output values are:
-    /// - `output_data`: a writer receiving the serialization of the identity tapdoor, identity nullifier, identity secret and identity commitment (serialization done with `rln::utils::fr_to_bytes_le`)
+    /// - `output_data`: a writer receiving the serialization of the identity trapdoor, identity nullifier, identity secret and identity commitment (serialization done with `rln::utils::fr_to_bytes_le`)
    ///
    /// Example
    /// ```
@@ -1138,7 +1247,7 @@ impl RLN<'_> {
    /// - `input_data`: a reader for the byte vector containing the seed
    ///
    /// Output values are:
-    /// - `output_data`: a writer receiving the serialization of the identity tapdoor, identity nullifier, identity secret and identity commitment (serialization done with `rln::utils::fr_to_bytes_le`)
+    /// - `output_data`: a writer receiving the serialization of the identity trapdoor, identity nullifier, identity secret and identity commitment (serialization done with `rln::utils::fr_to_bytes_le`)
    ///
    /// Example
    /// ```
@@ -1176,8 +1285,8 @@ impl RLN<'_> {
    ///
    /// Input values are:
    /// - `input_proof_data_1`: a reader for the serialization of a RLN zkSNARK proof concatenated with a serialization of the circuit output values and -optionally- the signal information,
-    /// i.e. either `[proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`
-    /// or `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var> ]` (to maintain compatibility with both output of [`generate_rln_proof`](crate::public::RLN::generate_rln_proof) and input of [`verify_rln_proof`](crate::public::RLN::verify_rln_proof))
+    ///   i.e. either `[proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`
+    ///   or `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var> ]` (to maintain compatibility with both output of [`generate_rln_proof`](crate::public::RLN::generate_rln_proof) and input of [`verify_rln_proof`](crate::public::RLN::verify_rln_proof))
    /// - `input_proof_data_2`: same as `input_proof_data_1`
    ///
    /// Output values are:
@@ -1212,7 +1321,7 @@ impl RLN<'_> {
        mut input_proof_data_2: R,
        mut output_data: W,
    ) -> Result<()> {
-        // We serialize_compressed the two proofs and we get the corresponding RLNProofValues objects
+        // We serialize_compressed the two proofs, and we get the corresponding RLNProofValues objects
        let mut serialized: Vec<u8> = Vec::new();
        input_proof_data_1.read_to_end(&mut serialized)?;
        // We skip deserialization of the zk-proof at the beginning
@@ -1228,7 +1337,7 @@ impl RLN<'_> {
        // We continue only if the proof values are for the same external nullifier (which includes epoch and rln identifier)
        // The idea is that proof values that go as input to this function are verified first (with zk-proof verify), hence ensuring validity of external nullifier and other fields.
        // Only in case all fields are valid, an external_nullifier for the message will be stored (otherwise signal/proof will be simply discarded)
-        // If the nullifier matches one already seen, we can recovery of identity secret.
+        // If the nullifier matches one already seen, we can recover of identity secret.
        if external_nullifier_1 == external_nullifier_2 {
            // We extract the two shares
            let share1 = (proof_values_1.x, proof_values_1.y);
@@ -1253,7 +1362,8 @@ impl RLN<'_> {
    /// Input values are:
    /// - `input_data`: a reader for the serialization of `[ identity_secret<32> | id_index<8> | user_message_limit<32> | message_id<32> | external_nullifier<32> | signal_len<8> | signal<var> ]`
    ///
-    /// The function returns the corresponding [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object serialized using [`rln::protocol::serialize_witness`](crate::protocol::serialize_witness)).
+    /// The function returns the corresponding [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object serialized using [`rln::protocol::serialize_witness`](crate::protocol::serialize_witness).
+    #[cfg(not(feature = "stateless"))]
    pub fn get_serialized_rln_witness<R: Read>(&mut self, mut input_data: R) -> Result<Vec<u8>> {
        // We read input RLN witness and we serialize_compressed it
        let mut witness_byte: Vec<u8> = Vec::new();
@@ -1274,21 +1384,42 @@ impl RLN<'_> {
        rln_witness_to_json(&rln_witness)
    }

+    /// Converts a byte serialization of a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object to the corresponding JSON serialization.
+    /// Before serialization the data will be translated into big int for further calculation in the witness calculator.
+    ///
+    /// Input values are:
+    /// - `serialized_witness`: the byte serialization of a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object (serialization done with  [`rln::protocol::serialize_witness`](crate::protocol::serialize_witness)).
+    ///
+    /// The function returns the corresponding JSON encoding of the input [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object.
+    pub fn get_rln_witness_bigint_json(
+        &mut self,
+        serialized_witness: &[u8],
+    ) -> Result<serde_json::Value> {
+        let (rln_witness, _) = deserialize_witness(serialized_witness)?;
+        rln_witness_to_bigint_json(&rln_witness)
+    }
+
    /// Closes the connection to the Merkle tree database.
    /// This function should be called before the RLN object is dropped.
    /// If not called, the connection will be closed when the RLN object is dropped.
    /// This improves robustness of the tree.
+    #[cfg(not(feature = "stateless"))]
    pub fn flush(&mut self) -> Result<()> {
        self.tree.close_db_connection()
    }
 }

 #[cfg(not(target_arch = "wasm32"))]
-impl Default for RLN<'_> {
+impl Default for RLN {
    fn default() -> Self {
-        let tree_height = TEST_TREE_HEIGHT;
-        let buffer = Cursor::new(json!({}).to_string());
-        Self::new(tree_height, buffer).unwrap()
+        #[cfg(not(feature = "stateless"))]
+        {
+            let tree_height = TEST_TREE_HEIGHT;
+            let buffer = Cursor::new(json!({}).to_string());
+            Self::new(tree_height, buffer).unwrap()
+        }
+        #[cfg(feature = "stateless")]
+        Self::new().unwrap()
    }
 }

--- a/rln/src/public_api_tests.rs
+++ b/rln/src/public_api_tests.rs
--- a/rln/tests/ffi.rs
+++ b/rln/tests/ffi.rs
@@ -1,4 +1,5 @@
 #[cfg(test)]
+#[cfg(not(feature = "stateless"))]
 mod test {
    use ark_std::{rand::thread_rng, UniformRand};
    use rand::Rng;
@@ -16,7 +17,7 @@ mod test {

    const NO_OF_LEAVES: usize = 256;

-    fn create_rln_instance() -> &'static mut RLN<'static> {
+    fn create_rln_instance() -> &'static mut RLN {
        let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
        let input_config = json!({}).to_string();
        let input_buffer = &Buffer::from(input_config.as_bytes());
@@ -427,7 +428,7 @@ mod test {
            .read_exact(&mut zkey_buffer)
            .expect("buffer overflow");

-        let vk_path = "./resources/tree_height_20/verification_key.json";
+        let vk_path = "./resources/tree_height_20/verification_key.arkvkey";
        let mut vk_file = File::open(&vk_path).expect("no file found");
        let metadata = std::fs::metadata(&vk_path).expect("unable to read metadata");
        let mut vk_buffer = vec![0; metadata.len() as usize];
@@ -529,7 +530,7 @@ mod test {

    #[test]
    // Computes and verifies an RLN ZK proof by checking proof's root against an input roots buffer
-    fn test_verify_with_roots() {
+    fn test_verify_with_roots_ffi() {
        // First part similar to test_rln_proof_ffi
        let user_message_limit = Fr::from(100);

@@ -905,7 +906,7 @@ mod test {
    }

    #[test]
-    fn test_get_leaf() {
+    fn test_get_leaf_ffi() {
        // We create a RLN instance
        let no_of_leaves = 1 << TEST_TREE_HEIGHT;

@@ -945,7 +946,7 @@ mod test {
    }

    #[test]
-    fn test_valid_metadata() {
+    fn test_valid_metadata_ffi() {
        // We create a RLN instance
        let rln_pointer = create_rln_instance();

@@ -966,7 +967,7 @@ mod test {
    }

    #[test]
-    fn test_empty_metadata() {
+    fn test_empty_metadata_ffi() {
        // We create a RLN instance
        let rln_pointer = create_rln_instance();

@@ -978,3 +979,471 @@ mod test {
        assert_eq!(output_buffer.len, 0);
    }
 }
+
+#[cfg(test)]
+#[cfg(feature = "stateless")]
+mod stateless_test {
+    use ark_std::{rand::thread_rng, UniformRand};
+    use rand::Rng;
+    use rln::circuit::*;
+    use rln::ffi::generate_rln_proof_with_witness;
+    use rln::ffi::{hash as ffi_hash, poseidon_hash as ffi_poseidon_hash, *};
+    use rln::hashers::{hash_to_field, poseidon_hash as utils_poseidon_hash, ROUND_PARAMS};
+    use rln::poseidon_tree::PoseidonTree;
+    use rln::protocol::*;
+    use rln::public::RLN;
+    use rln::utils::*;
+    use std::mem::MaybeUninit;
+    use std::time::{Duration, Instant};
+    use utils::ZerokitMerkleTree;
+
+    type ConfigOf<T> = <T as ZerokitMerkleTree>::Config;
+
+    fn create_rln_instance() -> &'static mut RLN {
+        let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
+        let success = new(rln_pointer.as_mut_ptr());
+        assert!(success, "RLN object creation failed");
+        unsafe { &mut *rln_pointer.assume_init() }
+    }
+
+    fn identity_pair_gen(rln_pointer: &mut RLN) -> (Fr, Fr) {
+        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
+        let success = key_gen(rln_pointer, output_buffer.as_mut_ptr());
+        assert!(success, "key gen call failed");
+        let output_buffer = unsafe { output_buffer.assume_init() };
+        let result_data = <&[u8]>::from(&output_buffer).to_vec();
+        let (identity_secret_hash, read) = bytes_le_to_fr(&result_data);
+        let (id_commitment, _) = bytes_le_to_fr(&result_data[read..].to_vec());
+        (identity_secret_hash, id_commitment)
+    }
+
+    fn rln_proof_gen_with_witness(rln_pointer: &mut RLN, serialized: &[u8]) -> Vec<u8> {
+        let input_buffer = &Buffer::from(serialized);
+        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
+        let success =
+            generate_rln_proof_with_witness(rln_pointer, input_buffer, output_buffer.as_mut_ptr());
+        assert!(success, "generate rln proof call failed");
+        let output_buffer = unsafe { output_buffer.assume_init() };
+        <&[u8]>::from(&output_buffer).to_vec()
+    }
+
+    #[test]
+    fn test_recover_id_secret_stateless_ffi() {
+        let default_leaf = Fr::from(0);
+        let mut tree = PoseidonTree::new(
+            TEST_TREE_HEIGHT,
+            default_leaf,
+            ConfigOf::<PoseidonTree>::default(),
+        )
+        .unwrap();
+
+        let rln_pointer = create_rln_instance();
+
+        // We generate a new identity pair
+        let (identity_secret_hash, id_commitment) = identity_pair_gen(rln_pointer);
+
+        let user_message_limit = Fr::from(100);
+        let rate_commitment = utils_poseidon_hash(&[id_commitment, user_message_limit]);
+        tree.update_next(rate_commitment).unwrap();
+
+        // We generate a random epoch
+        let epoch = hash_to_field(b"test-epoch");
+        let rln_identifier = hash_to_field(b"test-rln-identifier");
+        let external_nullifier = utils_poseidon_hash(&[epoch, rln_identifier]);
+
+        // We generate two proofs using same epoch but different signals.
+        // We generate a random signal
+        let mut rng = thread_rng();
+        let signal1: [u8; 32] = rng.gen();
+        let x1 = hash_to_field(&signal1);
+
+        let signal2: [u8; 32] = rng.gen();
+        let x2 = hash_to_field(&signal2);
+
+        let identity_index = tree.leaves_set();
+        let merkle_proof = tree.proof(identity_index).expect("proof should exist");
+
+        // We prepare input for generate_rln_proof API
+        let rln_witness1 = rln_witness_from_values(
+            identity_secret_hash,
+            &merkle_proof,
+            x1,
+            external_nullifier,
+            user_message_limit,
+            Fr::from(1),
+        )
+        .unwrap();
+        let serialized1 = serialize_witness(&rln_witness1).unwrap();
+
+        let rln_witness2 = rln_witness_from_values(
+            identity_secret_hash,
+            &merkle_proof,
+            x2,
+            external_nullifier,
+            user_message_limit,
+            Fr::from(1),
+        )
+        .unwrap();
+        let serialized2 = serialize_witness(&rln_witness2).unwrap();
+
+        // We call generate_rln_proof for first proof values
+        // result_data is [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> ]
+        let proof_data_1 = rln_proof_gen_with_witness(rln_pointer, serialized1.as_ref());
+
+        // We call generate_rln_proof
+        // result_data is [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> ]
+        let proof_data_2 = rln_proof_gen_with_witness(rln_pointer, serialized2.as_ref());
+
+        let input_proof_buffer_1 = &Buffer::from(proof_data_1.as_ref());
+        let input_proof_buffer_2 = &Buffer::from(proof_data_2.as_ref());
+        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
+        let success = recover_id_secret(
+            rln_pointer,
+            input_proof_buffer_1,
+            input_proof_buffer_2,
+            output_buffer.as_mut_ptr(),
+        );
+        assert!(success, "recover id secret call failed");
+        let output_buffer = unsafe { output_buffer.assume_init() };
+        let serialized_identity_secret_hash = <&[u8]>::from(&output_buffer).to_vec();
+
+        // We passed two shares for the same secret, so recovery should be successful
+        // To check it, we ensure that recovered identity secret hash is empty
+        assert!(!serialized_identity_secret_hash.is_empty());
+
+        // We check if the recovered identity secret hash corresponds to the original one
+        let (recovered_identity_secret_hash, _) = bytes_le_to_fr(&serialized_identity_secret_hash);
+        assert_eq!(recovered_identity_secret_hash, identity_secret_hash);
+
+        // We now test that computing identity_secret_hash is unsuccessful if shares computed from two different identity secret hashes but within same epoch are passed
+
+        // We generate a new identity pair
+        let (identity_secret_hash_new, id_commitment_new) = identity_pair_gen(rln_pointer);
+        let rate_commitment_new = utils_poseidon_hash(&[id_commitment_new, user_message_limit]);
+        tree.update_next(rate_commitment_new).unwrap();
+
+        // We generate a random signals
+        let signal3: [u8; 32] = rng.gen();
+        let x3 = hash_to_field(&signal3);
+
+        let identity_index_new = tree.leaves_set();
+        let merkle_proof_new = tree.proof(identity_index_new).expect("proof should exist");
+
+        let rln_witness3 = rln_witness_from_values(
+            identity_secret_hash_new,
+            &merkle_proof_new,
+            x3,
+            external_nullifier,
+            user_message_limit,
+            Fr::from(1),
+        )
+        .unwrap();
+        let serialized3 = serialize_witness(&rln_witness3).unwrap();
+
+        // We call generate_rln_proof
+        // result_data is [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> ]
+        let proof_data_3 = rln_proof_gen_with_witness(rln_pointer, serialized3.as_ref());
+
+        // We attempt to recover the secret using share1 (coming from identity_secret_hash) and share3 (coming from identity_secret_hash_new)
+
+        let input_proof_buffer_1 = &Buffer::from(proof_data_1.as_ref());
+        let input_proof_buffer_3 = &Buffer::from(proof_data_3.as_ref());
+        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
+        let success = recover_id_secret(
+            rln_pointer,
+            input_proof_buffer_1,
+            input_proof_buffer_3,
+            output_buffer.as_mut_ptr(),
+        );
+        assert!(success, "recover id secret call failed");
+        let output_buffer = unsafe { output_buffer.assume_init() };
+        let serialized_identity_secret_hash = <&[u8]>::from(&output_buffer).to_vec();
+        let (recovered_identity_secret_hash_new, _) =
+            bytes_le_to_fr(&serialized_identity_secret_hash);
+
+        // ensure that the recovered secret does not match with either of the
+        // used secrets in proof generation
+        assert_ne!(recovered_identity_secret_hash_new, identity_secret_hash_new);
+    }
+
+    #[test]
+    fn test_verify_with_roots_stateless_ffi() {
+        let default_leaf = Fr::from(0);
+        let mut tree = PoseidonTree::new(
+            TEST_TREE_HEIGHT,
+            default_leaf,
+            ConfigOf::<PoseidonTree>::default(),
+        )
+        .unwrap();
+
+        let rln_pointer = create_rln_instance();
+
+        // We generate a new identity pair
+        let (identity_secret_hash, id_commitment) = identity_pair_gen(rln_pointer);
+
+        let identity_index = tree.leaves_set();
+        let user_message_limit = Fr::from(100);
+        let rate_commitment = utils_poseidon_hash(&[id_commitment, user_message_limit]);
+        tree.update_next(rate_commitment).unwrap();
+
+        // We generate a random epoch
+        let epoch = hash_to_field(b"test-epoch");
+        let rln_identifier = hash_to_field(b"test-rln-identifier");
+        let external_nullifier = utils_poseidon_hash(&[epoch, rln_identifier]);
+
+        // We generate two proofs using same epoch but different signals.
+        // We generate a random signal
+        let mut rng = thread_rng();
+        let signal: [u8; 32] = rng.gen();
+        let x = hash_to_field(&signal);
+
+        let merkle_proof = tree.proof(identity_index).expect("proof should exist");
+
+        // We prepare input for generate_rln_proof API
+        let rln_witness = rln_witness_from_values(
+            identity_secret_hash,
+            &merkle_proof,
+            x,
+            external_nullifier,
+            user_message_limit,
+            Fr::from(1),
+        )
+        .unwrap();
+
+        let serialized = serialize_witness(&rln_witness).unwrap();
+        let mut proof_data = rln_proof_gen_with_witness(rln_pointer, serialized.as_ref());
+
+        proof_data.append(&mut normalize_usize(signal.len()));
+        proof_data.append(&mut signal.to_vec());
+
+        // If no roots is provided, proof validation is skipped and if the remaining proof values are valid, the proof will be correctly verified
+        let mut roots_data: Vec<u8> = Vec::new();
+
+        let input_buffer = &Buffer::from(proof_data.as_ref());
+        let roots_buffer = &Buffer::from(roots_data.as_ref());
+        let mut proof_is_valid: bool = false;
+        let proof_is_valid_ptr = &mut proof_is_valid as *mut bool;
+        let success =
+            verify_with_roots(rln_pointer, input_buffer, roots_buffer, proof_is_valid_ptr);
+        assert!(success, "verify call failed");
+        // Proof should be valid
+        assert_eq!(proof_is_valid, true);
+
+        // We serialize in the roots buffer some random values and we check that the proof is not verified since doesn't contain the correct root the proof refers to
+        for _ in 0..5 {
+            roots_data.append(&mut fr_to_bytes_le(&Fr::rand(&mut rng)));
+        }
+        let input_buffer = &Buffer::from(proof_data.as_ref());
+        let roots_buffer = &Buffer::from(roots_data.as_ref());
+        let mut proof_is_valid: bool = false;
+        let proof_is_valid_ptr = &mut proof_is_valid as *mut bool;
+        let success =
+            verify_with_roots(rln_pointer, input_buffer, roots_buffer, proof_is_valid_ptr);
+        assert!(success, "verify call failed");
+        // Proof should be invalid.
+        assert_eq!(proof_is_valid, false);
+
+        // We get the root of the tree obtained adding one leaf per time
+        let root = tree.root();
+
+        // We add the real root and we check if now the proof is verified
+        roots_data.append(&mut fr_to_bytes_le(&root));
+        let input_buffer = &Buffer::from(proof_data.as_ref());
+        let roots_buffer = &Buffer::from(roots_data.as_ref());
+        let mut proof_is_valid: bool = false;
+        let proof_is_valid_ptr = &mut proof_is_valid as *mut bool;
+        let success =
+            verify_with_roots(rln_pointer, input_buffer, roots_buffer, proof_is_valid_ptr);
+        assert!(success, "verify call failed");
+        // Proof should be valid.
+        assert_eq!(proof_is_valid, true);
+    }
+
+    #[test]
+    fn test_groth16_proofs_performance_stateless_ffi() {
+        // We create a RLN instance
+        let rln_pointer = create_rln_instance();
+
+        // We compute some benchmarks regarding proof and verify API calls
+        // Note that circuit loading requires some initial overhead.
+        // Once the circuit is loaded (i.e., when the RLN object is created), proof generation and verification times should be similar at each call.
+        let sample_size = 100;
+        let mut prove_time: u128 = 0;
+        let mut verify_time: u128 = 0;
+
+        for _ in 0..sample_size {
+            // We generate random witness instances and relative proof values
+            let rln_witness = random_rln_witness(TEST_TREE_HEIGHT);
+            let proof_values = proof_values_from_witness(&rln_witness).unwrap();
+
+            // We prepare id_commitment and we set the leaf at provided index
+            let rln_witness_ser = serialize_witness(&rln_witness).unwrap();
+            let input_buffer = &Buffer::from(rln_witness_ser.as_ref());
+            let mut output_buffer = MaybeUninit::<Buffer>::uninit();
+            let now = Instant::now();
+            let success = prove(rln_pointer, input_buffer, output_buffer.as_mut_ptr());
+            prove_time += now.elapsed().as_nanos();
+            assert!(success, "prove call failed");
+            let output_buffer = unsafe { output_buffer.assume_init() };
+
+            // We read the returned proof and we append proof values for verify
+            let serialized_proof = <&[u8]>::from(&output_buffer).to_vec();
+            let serialized_proof_values = serialize_proof_values(&proof_values);
+            let mut verify_data = Vec::<u8>::new();
+            verify_data.extend(&serialized_proof);
+            verify_data.extend(&serialized_proof_values);
+
+            // We prepare input proof values and we call verify
+            let input_buffer = &Buffer::from(verify_data.as_ref());
+            let mut proof_is_valid: bool = false;
+            let proof_is_valid_ptr = &mut proof_is_valid as *mut bool;
+            let now = Instant::now();
+            let success = verify(rln_pointer, input_buffer, proof_is_valid_ptr);
+            verify_time += now.elapsed().as_nanos();
+            assert!(success, "verify call failed");
+            assert_eq!(proof_is_valid, true);
+        }
+
+        println!(
+            "Average prove API call time: {:?}",
+            Duration::from_nanos((prove_time / sample_size).try_into().unwrap())
+        );
+        println!(
+            "Average verify API call time: {:?}",
+            Duration::from_nanos((verify_time / sample_size).try_into().unwrap())
+        );
+    }
+
+    #[test]
+    // Tests hash to field using FFI APIs
+    fn test_seeded_keygen_stateless_ffi() {
+        // We create a RLN instance
+        let rln_pointer = create_rln_instance();
+
+        // We generate a new identity pair from an input seed
+        let seed_bytes: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let input_buffer = &Buffer::from(seed_bytes);
+        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
+        let success = seeded_key_gen(rln_pointer, input_buffer, output_buffer.as_mut_ptr());
+        assert!(success, "seeded key gen call failed");
+        let output_buffer = unsafe { output_buffer.assume_init() };
+        let result_data = <&[u8]>::from(&output_buffer).to_vec();
+        let (identity_secret_hash, read) = bytes_le_to_fr(&result_data);
+        let (id_commitment, _) = bytes_le_to_fr(&result_data[read..].to_vec());
+
+        // We check against expected values
+        let expected_identity_secret_hash_seed_bytes = str_to_fr(
+            "0x766ce6c7e7a01bdf5b3f257616f603918c30946fa23480f2859c597817e6716",
+            16,
+        );
+        let expected_id_commitment_seed_bytes = str_to_fr(
+            "0xbf16d2b5c0d6f9d9d561e05bfca16a81b4b873bb063508fae360d8c74cef51f",
+            16,
+        );
+
+        assert_eq!(
+            identity_secret_hash,
+            expected_identity_secret_hash_seed_bytes.unwrap()
+        );
+        assert_eq!(id_commitment, expected_id_commitment_seed_bytes.unwrap());
+    }
+
+    #[test]
+    // Tests hash to field using FFI APIs
+    fn test_seeded_extended_keygen_stateless_ffi() {
+        // We create a RLN instance
+        let rln_pointer = create_rln_instance();
+
+        // We generate a new identity tuple from an input seed
+        let seed_bytes: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let input_buffer = &Buffer::from(seed_bytes);
+        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
+        let success =
+            seeded_extended_key_gen(rln_pointer, input_buffer, output_buffer.as_mut_ptr());
+        assert!(success, "seeded key gen call failed");
+        let output_buffer = unsafe { output_buffer.assume_init() };
+        let result_data = <&[u8]>::from(&output_buffer).to_vec();
+        let (identity_trapdoor, identity_nullifier, identity_secret_hash, id_commitment) =
+            deserialize_identity_tuple(result_data);
+
+        // We check against expected values
+        let expected_identity_trapdoor_seed_bytes = str_to_fr(
+            "0x766ce6c7e7a01bdf5b3f257616f603918c30946fa23480f2859c597817e6716",
+            16,
+        );
+        let expected_identity_nullifier_seed_bytes = str_to_fr(
+            "0x1f18714c7bc83b5bca9e89d404cf6f2f585bc4c0f7ed8b53742b7e2b298f50b4",
+            16,
+        );
+        let expected_identity_secret_hash_seed_bytes = str_to_fr(
+            "0x2aca62aaa7abaf3686fff2caf00f55ab9462dc12db5b5d4bcf3994e671f8e521",
+            16,
+        );
+        let expected_id_commitment_seed_bytes = str_to_fr(
+            "0x68b66aa0a8320d2e56842581553285393188714c48f9b17acd198b4f1734c5c",
+            16,
+        );
+
+        assert_eq!(
+            identity_trapdoor,
+            expected_identity_trapdoor_seed_bytes.unwrap()
+        );
+        assert_eq!(
+            identity_nullifier,
+            expected_identity_nullifier_seed_bytes.unwrap()
+        );
+        assert_eq!(
+            identity_secret_hash,
+            expected_identity_secret_hash_seed_bytes.unwrap()
+        );
+        assert_eq!(id_commitment, expected_id_commitment_seed_bytes.unwrap());
+    }
+
+    #[test]
+    // Tests hash to field using FFI APIs
+    fn test_hash_to_field_stateless_ffi() {
+        let mut rng = rand::thread_rng();
+        let signal: [u8; 32] = rng.gen();
+
+        // We prepare id_commitment and we set the leaf at provided index
+        let input_buffer = &Buffer::from(signal.as_ref());
+        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
+        let success = ffi_hash(input_buffer, output_buffer.as_mut_ptr());
+        assert!(success, "hash call failed");
+        let output_buffer = unsafe { output_buffer.assume_init() };
+
+        // We read the returned proof and we append proof values for verify
+        let serialized_hash = <&[u8]>::from(&output_buffer).to_vec();
+        let (hash1, _) = bytes_le_to_fr(&serialized_hash);
+
+        let hash2 = hash_to_field(&signal);
+
+        assert_eq!(hash1, hash2);
+    }
+
+    #[test]
+    // Test Poseidon hash FFI
+    fn test_poseidon_hash_stateless_ffi() {
+        // generate random number between 1..ROUND_PARAMS.len()
+        let mut rng = thread_rng();
+        let number_of_inputs = rng.gen_range(1..ROUND_PARAMS.len());
+        let mut inputs = Vec::with_capacity(number_of_inputs);
+        for _ in 0..number_of_inputs {
+            inputs.push(Fr::rand(&mut rng));
+        }
+        let inputs_ser = vec_fr_to_bytes_le(&inputs).unwrap();
+        let input_buffer = &Buffer::from(inputs_ser.as_ref());
+
+        let expected_hash = utils_poseidon_hash(inputs.as_ref());
+
+        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
+        let success = ffi_poseidon_hash(input_buffer, output_buffer.as_mut_ptr());
+        assert!(success, "poseidon hash call failed");
+
+        let output_buffer = unsafe { output_buffer.assume_init() };
+        let result_data = <&[u8]>::from(&output_buffer).to_vec();
+        let (received_hash, _) = bytes_le_to_fr(&result_data);
+
+        assert_eq!(received_hash, expected_hash);
+    }
+}
--- a/rln/tests/protocol.rs
+++ b/rln/tests/protocol.rs
@@ -127,9 +127,9 @@ mod test {
    // We test a RLN proof generation and verification
    fn test_witness_from_json() {
        // We generate all relevant keys
-        let proving_key = zkey_from_folder().unwrap();
-        let verification_key = vk_from_folder().unwrap();
-        let builder = circom_from_folder().unwrap();
+        let proving_key = zkey_from_folder();
+        let verification_key = vk_from_folder();
+        let builder = circom_from_folder();

        // We compute witness from the json input
        let rln_witness = get_test_witness();
@@ -156,9 +156,9 @@ mod test {
        assert_eq!(rln_witness_deser, rln_witness);

        // We generate all relevant keys
-        let proving_key = zkey_from_folder().unwrap();
-        let verification_key = vk_from_folder().unwrap();
-        let builder = circom_from_folder().unwrap();
+        let proving_key = zkey_from_folder();
+        let verification_key = vk_from_folder();
+        let builder = circom_from_folder();

        // Let's generate a zkSNARK proof
        let proof = generate_proof(builder, &proving_key, &rln_witness_deser).unwrap();
--- a/rln/tests/public.rs
+++ b/rln/tests/public.rs
@@ -12,6 +12,7 @@ mod test {

    #[test]
    // This test is similar to the one in lib, but uses only public API
+    #[cfg(not(feature = "stateless"))]
    fn test_merkle_proof() {
        let leaf_index = 3;
        let user_message_limit = 1;
--- a/1
+++ b/1
@@ -0,0 +1 @@
+1.82
--- a/utils/Cargo.toml
+++ b/utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zerokit_utils"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Various utilities for Zerokit"
@@ -13,9 +13,11 @@ bench = false

 [dependencies]
 ark-ff = { version = "=0.4.1", default-features = false, features = ["asm"] }
-num-bigint = { version = "=0.4.3", default-features = false, features = ["rand"] }
+num-bigint = { version = "=0.4.3", default-features = false, features = [
+    "rand",
+] }
 color-eyre = "=0.6.2"
-pmtree = { package = "vacp2p_pmtree", version = "=2.0.2", optional = true}
+pmtree = { package = "vacp2p_pmtree", version = "=2.0.2", optional = true }
 sled = "=0.34.7"
 serde = "=1.0.163"
 lazy_static = "1.4.0"
--- a/utils/src/merkle_tree/full_merkle_tree.rs
+++ b/utils/src/merkle_tree/full_merkle_tree.rs
@@ -8,7 +8,7 @@ use std::{
 };

 ////////////////////////////////////////////////////////////
-/// Full Merkle Tree Implementation
+///// Full Merkle Tree Implementation
 ////////////////////////////////////////////////////////////

 /// Merkle tree with all leaf and intermediate hashes stored
--- a/utils/src/merkle_tree/optimal_merkle_tree.rs
+++ b/utils/src/merkle_tree/optimal_merkle_tree.rs
@@ -6,7 +6,7 @@ use std::str::FromStr;
 use std::{cmp::max, fmt::Debug};

 ////////////////////////////////////////////////////////////
-/// Optimal Merkle Tree Implementation
+///// Optimal Merkle Tree Implementation
 ////////////////////////////////////////////////////////////

 /// The Merkle tree structure
@@ -55,7 +55,9 @@ impl FromStr for OptimalMerkleConfig {
    }
 }

-/// Implementations
+////////////////////////////////////////////////////////////
+///// Implementations
+////////////////////////////////////////////////////////////

 impl<H: Hasher> ZerokitMerkleTree for OptimalMerkleTree<H>
 where
Author	SHA1	Message	Date
vinhtc27	53264098b4	feat(rln-wasm): add browser benchmark with simple HTML file and default data	2025-04-01 17:35:29 +07:00
vinhtc27	d78e87c4bd	feat(rln-wasm): add simple benchmark for rln-wasm module	2025-03-29 17:10:28 +07:00
Ekaterina Broslavskaya	88f8a80faa	Freeze rust version (#272 )	2025-02-19 18:19:38 +07:00
seemenkina	0cce9f92d9	chore(release): bump rln and rln-wasm versions Increment package versions: - rln: 0.5.1 -> 0.6.1 - rln-wasm: 0.0.13 -> 0.1.0 Update Cargo.lock and Cargo.toml files to reflect new versions and dependencies	2025-02-19 18:17:03 +07:00
Ekaterina Broslavskaya	b9d27039c3	chore(rln): add uncompressed key and benches (#269 ) * chore(rln): add uncompressed key and benches * chore(rln): refactor * chore(rln): update to uncompressed arkzkey	2024-10-01 14:16:03 +07:00
Ekaterina Broslavskaya	49e2517e15	fix(CI): add ci test for all features (#270 )	2024-09-24 19:18:35 +07:00
Ekaterina Broslavskaya	6621efd0bb	fix(CI): update actions version (#268 ) * fix(CI): update actions upload version * fix(CI): update actions upload version * fix(CI): update actions download version	2024-09-17 13:21:58 +07:00
Ekaterina Broslavskaya	4a74ff0d6c	chore(rln-wasm): Make rln-wasm stateless (#266 ) * make rln-wasm stateless * chore(rln-wasm): fix docs * chore(rln-wasm): fix missing dependency	2024-09-16 12:55:19 +07:00
Ekaterina Broslavskaya	fc823e7187	fix(CI): add condition for stateless feature (#267 ) * fix(CI): add conditional to nightly build * fix(CI): add include into matrix build	2024-09-11 13:29:54 +07:00
Ekaterina Broslavskaya	0d5642492a	Stateless Feature (#265 ) * add stateless feature and tests * update docs and new function	2024-08-28 13:41:18 +03:00
Aaryamann Challani	c4579e1917	fix(rln-wasm): run tests again (#264 ) * fix(rln-wasm): run tests again * fix linter * fix serialization for rln-wasm * add comment --------- Co-authored-by: seemenkina <seemenkina@gmail.com>	2024-08-20 12:16:14 +03:00
Aaryamann Challani	e6238fd722	chore: Release (#262 )	2024-06-20 16:44:46 +05:30
Aaryamann Challani	5540ddc993	chore(rln): further refactoring of interface (#261 )	2024-06-18 11:56:23 +05:30
Aaryamann Challani	d8f813bc2e	chore(rln): refactor resource initialization (#260 ) * chore(rln): optimize into Lazy OnceCells * fix * fix: dont change duration * fix: increase duration? * chore: add backtrace * fix: remove plotter to avoid f64 range failure * fix: remove ci alteration * fix: use arc over witness calc * fix: remove more lifetimes * fix: benchmark correct fn call, not the getter * fix: bench config	2024-06-17 13:43:09 +05:30
Aaryamann Challani	c6493bd10f	chore(rln): use ark serialized verification key for faster serde (#259 ) * chore(rln): use ark serialized verification key for faster serde * fix: unused imports * fix: rm verification_key.json * fix: s/vk_from_slice/vk_from_ark_serialized/g	2024-06-14 11:03:55 +05:30
Aaryamann Challani	dd5edd6818	chore(rln): add verifying key deser benchmark (#258 )	2024-06-07 15:16:44 +05:30