rm commented line

as gakonst updated the version, doing the same
update wasm
2026-01-09 13:47:58 -05:00 · 2023-03-20 23:14:29 +01:00 · 2023-03-20 21:51:56 +01:00 · 2023-03-20 18:27:01 +01:00 · 2023-03-20 12:55:42 +01:00 · 2023-03-20 12:47:56 +01:00
76 changed files with 11059 additions and 5785 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,13 +2,41 @@ on:
  push:
    branches:
      - master
+    paths-ignore:
+      - '**.md'
+      - '!.github/workflows/*.yml'
+      - '!multiplier/src/**'
+      - '!private-settlement/src/**'
+      - '!rln-wasm/**'
+      - '!rln/src/**'
+      - '!rln/resources/**'
+      - '!semaphore/src/**'
+      - '!utils/src/**'
  pull_request:
+    paths-ignore:
+      - '**.md'
+      - '!.github/workflows/*.yml'
+      - '!multiplier/src/**'
+      - '!private-settlement/src/**'
+      - '!rln-wasm/**'
+      - '!rln/src/**'
+      - '!rln/resources/**'
+      - '!semaphore/src/**'
+      - '!utils/src/**'
+

 name: Tests

 jobs:
-  tests:
-    runs-on: ubuntu-latest
+
+  multiplier:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 60
+  
+    name: multiplier - ${{ matrix.platform }}
    steps:
      - name: Checkout sources
        uses: actions/checkout@v2
@@ -18,13 +46,124 @@ jobs:
          profile: minimal
          toolchain: stable
          override: true
-      - name: Update git submodules
-        run: git submodule update --init --recursive
-      - name: cargo test
+      - uses: Swatinem/rust-cache@v2
+      - name: Install dependencies
+        run: make installdeps
+      - name: cargo-make test
        run: |
-            cargo test
+            cargo make test --release
+        working-directory: multiplier
+  
+  semaphore:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 60
+  
+    name: semaphore - ${{ matrix.platform }}
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+      - 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 --release
+        working-directory: semaphore
+
+  rln-wasm:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 60
+  
+    name: rln-wasm - ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+      - 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: Install wasm-pack
+        uses: jetli/wasm-pack-action@v0.3.0
+      - run: cargo make build
+        working-directory: rln-wasm
+      - run: cargo-make test
+        working-directory: rln-wasm
+
+  rln:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 60
+  
+    name: rln - ${{ matrix.platform }}
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+      - 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 --release
+        working-directory: rln
+
+  utils:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 60
+  
+    name: utils - ${{ matrix.platform }}
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+      - 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 --release
+        working-directory: utils
+
  lint:
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        # we run lint tests only on ubuntu
+        platform: [ubuntu-latest]
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 60
+
+    name: lint - ${{ matrix.platform }}  
    steps:
      - name: Checkout sources
        uses: actions/checkout@v2
@@ -35,11 +174,32 @@ jobs:
          toolchain: stable
          override: true
          components: rustfmt, clippy
-      - name: Update git submodules
-        run: git submodule update --init --recursive
+      - uses: Swatinem/rust-cache@v2
+      - name: Install Dependencies
+        run: make installdeps
      - name: cargo fmt
+        if: success() || failure()
        run: cargo fmt --all -- --check
-      - name: cargo clippy
-        run: cargo clippy
+      - name: multiplier - cargo clippy
+        if: success() || failure()
+        run: |
+            cargo clippy --release -- -D warnings
+        working-directory: multiplier
+      - name: semaphore - cargo clippy
+        if: success() || failure()
+        run: |
+            cargo clippy --release -- -D warnings
+        working-directory: semaphore
+      - name: rln - cargo clippy
+        if: success() || failure()
+        run: |
+            cargo clippy --release -- -D warnings
+        working-directory: rln
+      - name: utils - cargo clippy
+        if: success() || failure()
+        run: |
+            cargo clippy --release -- -D warnings
+        working-directory: utils
+        # We skip clippy on rln-wasm, since wasm target is managed by cargo make
        # Currently not treating warnings as error, too noisy
-        # -- -D warnings
+        # -- -D warnings
--- a/.github/workflows/nightly-release.yml
+++ b/.github/workflows/nightly-release.yml
@@ -0,0 +1,148 @@
+name: Nightly build
+on:
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+jobs:
+  linux:
+    strategy:
+      matrix:
+        target: 
+          - x86_64-unknown-linux-gnu
+          - aarch64-unknown-linux-gnu
+          - i686-unknown-linux-gnu
+    name: Linux build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Install dependencies
+        run: make installdeps
+      - name: cross build
+        run: |
+          cross build --release --target ${{ matrix.target }} --workspace --exclude rln-wasm
+          mkdir release
+          cp target/${{ matrix.target }}/release/librln* release/
+          tar -czvf ${{ matrix.target }}-rln.tar.gz release/
+
+      - name: Upload archive artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ matrix.target }}-archive
+          path: ${{ matrix.target }}-rln.tar.gz
+          retention-days: 2
+
+  macos:
+    name: MacOS build
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        target: 
+          - x86_64-apple-darwin
+          - aarch64-apple-darwin
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Install dependencies
+        run: make installdeps
+      - name: cross build
+        run: |
+          cross build --release --target ${{ matrix.target }} --workspace --exclude rln-wasm
+          mkdir release
+          cp target/${{ matrix.target }}/release/librln* release/
+          tar -czvf ${{ matrix.target }}-rln.tar.gz release/
+
+      - name: Upload archive artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ matrix.target }}-archive
+          path: ${{ matrix.target }}-rln.tar.gz
+          retention-days: 2
+  
+  browser-rln-wasm:
+    name: Browser build (RLN WASM)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+      - 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: Install wasm-pack
+        uses: jetli/wasm-pack-action@v0.3.0
+      - name: cross make build
+        run: |
+          cross make build
+          mkdir release
+          cp pkg/** release/
+          tar -czvf browser-rln-wasm.tar.gz release/
+        working-directory: rln-wasm
+
+      - name: Upload archive artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: browser-rln-wasm-archive
+          path: rln-wasm/browser-rln-wasm.tar.gz
+          retention-days: 2
+
+
+  prepare-prerelease:
+    name: Prepare pre-release
+    needs: [linux, macos, browser-rln-wasm]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+        with:
+          ref: master
+      - name: Download artifacts
+        uses: actions/download-artifact@v2
+          
+      - name: Delete tag
+        uses: dev-drprasad/delete-tag-and-release@v0.2.0
+        with:
+          delete_release: true
+          tag_name: nightly
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create prerelease
+        run: |
+          start_tag=$(gh release list -L 2 --exclude-drafts | grep -v nightly | cut -d$'\t' -f3 | sed -n '1p')
+          gh release create nightly --prerelease --target master \
+            --title 'Nightly build ("master" branch)' \
+            --generate-notes \
+            --notes-start-tag $start_tag \
+            *-archive/*.tar.gz \
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Delete artifacts
+        uses: geekyeggo/delete-artifact@v1
+        with:
+          failOnError: false
+          name: |
+            *-archive
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
 .idea
 *.log
 tmp/
+rln/pmtree_db

 # Generated by Cargo
 # will have compiled files and executables
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,7 +1,7 @@
 [submodule "rln/vendor/rln"]
 	path = rln/vendor/rln
 	ignore = dirty
-	url = https://github.com/Rate-Limiting-Nullifier/rln_circuits
+	url = https://github.com/Rate-Limiting-Nullifier/rln_circuits.git
 [submodule "semaphore/vendor/semaphore"]
 	path = semaphore/vendor/semaphore
 	ignore = dirty
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -0,0 +1,28 @@
+## 2023-02-28 v0.2
+
+This release contains:
+
+- Improved code quality
+- Allows consumers of zerokit RLN to set leaves to the Merkle Tree from an arbitrary index. Useful for batching updates to the Merkle Tree.
+- Improved performance for proof generation and verification
+- rln_wasm which allows for the consumption of RLN through a WebAssembly interface
+- Refactored to generate Semaphore-compatible credentials
+- Dual License under Apache 2.0 and MIT
+- RLN compiles as a static library, which can be consumed through a C FFI
+
+
+## 2022-09-19 v0.1
+
+Initial beta release.
+
+This release contains:
+
+- RLN Module with API to manage, compute and verify [RLN](https://rfc.vac.dev/spec/32/) zkSNARK proofs and RLN primitives.
+- This can be consumed either as a Rust API or as a C FFI. The latter means it can be easily consumed through other environments, such as [Go](https://github.com/status-im/go-zerokit-rln/blob/master/rln/librln.h) or [Nim](https://github.com/status-im/nwaku/blob/4745c7872c69b5fd5c6ddab36df9c5c3d55f57c3/waku/v2/protocol/waku_rln_relay/waku_rln_relay_types.nim).
+
+It also contains the following examples and experiments:
+
+- Basic [example wrapper](https://github.com/vacp2p/zerokit/tree/master/multiplier) around a simple Circom circuit to show Circom integration through ark-circom and FFI.
+- Experimental [Semaphore wrapper](https://github.com/vacp2p/zerokit/tree/master/semaphore).
+
+Feedback welcome! You can either [open an issue](https://github.com/vacp2p/zerokit/issues) or come talk to us in our [Vac Discord](https://discord.gg/PQFdubGt6d) #zerokit channel.
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,22 @@
 [workspace]
 members = [
  "multiplier",
+  "private-settlement",
  "semaphore",
  "rln",
+  "rln-wasm",
+  "utils",
 ]
+
+# Compilation profile for any non-workspace member.
+# Dependencies are optimized, even in a dev build. This improves dev performance
+# while having neglible impact on incremental build times.
+[profile.dev.package."*"]
+opt-level = 3
+
+[profile.release.package."rln-wasm"]
+# Tell `rustc` to optimize for small code size.
+opt-level = "s"
+
+[profile.release.package."semaphore"]
+codegen-units = 1
--- a/Cross.toml
+++ b/Cross.toml
@@ -0,0 +1,32 @@
+[target.x86_64-pc-windows-gnu]
+image = "ghcr.io/cross-rs/x86_64-pc-windows-gnu:latest"
+
+[target.aarch64-unknown-linux-gnu]
+image = "ghcr.io/cross-rs/aarch64-unknown-linux-gnu:latest"
+
+[target.x86_64-unknown-linux-gnu]
+image = "ghcr.io/cross-rs/x86_64-unknown-linux-gnu:latest"
+
+[target.arm-unknown-linux-gnueabi]
+image = "ghcr.io/cross-rs/arm-unknown-linux-gnueabi:latest"
+
+[target.i686-pc-windows-gnu]
+image = "ghcr.io/cross-rs/i686-pc-windows-gnu:latest"
+
+[target.i686-unknown-linux-gnu]
+image = "ghcr.io/cross-rs/i686-unknown-linux-gnu:latest"
+
+[target.arm-unknown-linux-gnueabihf]
+image = "ghcr.io/cross-rs/arm-unknown-linux-gnueabihf:latest"
+
+[target.mips-unknown-linux-gnu]
+image = "ghcr.io/cross-rs/mips-unknown-linux-gnu:latest"
+
+[target.mips64-unknown-linux-gnuabi64]
+image = "ghcr.io/cross-rs/mips64-unknown-linux-gnuabi64:latest"
+
+[target.mips64el-unknown-linux-gnuabi64]
+image = "ghcr.io/cross-rs/mips64el-unknown-linux-gnuabi64:latest"
+
+[target.mipsel-unknown-linux-gnu]
+image = "ghcr.io/cross-rs/mipsel-unknown-linux-gnu:latest"
--- a/203
+++ b/203
@@ -0,0 +1,203 @@
+Copyright (c) 2022 Vac Research
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
--- a/25
+++ b/25
@@ -0,0 +1,25 @@
+Copyright (c) 2022 Vac Research
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE O THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/23
+++ b/23
@@ -0,0 +1,23 @@
+.PHONY: all installdeps build test clean
+
+all: .pre-build build
+
+.fetch-submodules:
+	@git submodule update --init --recursive
+
+.pre-build: .fetch-submodules
+	@cargo install cargo-make
+ifdef CI
+	@cargo install cross --git https://github.com/cross-rs/cross --branch main
+endif
+
+installdeps: .pre-build
+
+build: .pre-build
+	@cargo make build
+
+test: .pre-build
+	@cargo make test
+
+clean:
+	@cargo clean
--- a/Makefile.toml
+++ b/Makefile.toml
@@ -0,0 +1,2 @@
+[env]
+CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
--- a/README.md
+++ b/README.md
@@ -17,3 +17,19 @@ in Rust.
 - [RLN library](https://github.com/kilic/rln) written in Rust based on Bellman.

 - [semaphore-rs](https://github.com/worldcoin/semaphore-rs) written in Rust based on ark-circom.
+
+## Build and Test
+
+To install missing dependencies, run the following commands from the root folder
+```bash
+make installdeps
+```
+To build and test all crates, run the following commands from the root folder
+```bash
+make build
+make test
+```
+
+## Release assets
+
+We use [`cross-rs`](https://github.com/cross-rs/cross) to cross-compile and generate release assets for rln. 
--- a/multiplier/Cargo.toml
+++ b/multiplier/Cargo.toml
@@ -2,6 +2,7 @@
 name = "multiplier"
 version = "0.1.0"
 edition = "2018"
+license = "MIT OR Apache-2.0"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -12,23 +13,19 @@ edition = "2018"
 # fnv = { version = "1.0.3", default-features = false }
 # num = { version = "0.4.0" }
 # num-traits = { version = "0.2.0", default-features = false }
-num-bigint = { version = "0.4", default-features = false, features = ["rand"] }

 # ZKP Generation
-ark-ec = { version = "0.3.0", default-features = false, features = ["parallel"] }
 # ark-ff = { version = "0.3.0", default-features = false, features = ["parallel", "asm"] }
 ark-std = { version = "0.3.0", default-features = false, features = ["parallel"] }
 ark-bn254 = { version = "0.3.0" }
 ark-groth16 = { git = "https://github.com/arkworks-rs/groth16", rev = "765817f", features = ["parallel"] }
 # ark-poly = { version = "^0.3.0", default-features = false, features = ["parallel"] }
-ark-relations = { version = "0.3.0", default-features = false }
 ark-serialize = { version = "0.3.0", default-features = false }

 ark-circom = { git = "https://github.com/gakonst/ark-circom", features = ["circom-2"] }

 # error handling
-# thiserror = "1.0.26"
-color-eyre = "0.5"
+color-eyre = "0.6.1"

 # decoding of data
 # hex = "0.4.3"
--- a/multiplier/Makefile.toml
+++ b/multiplier/Makefile.toml
@@ -0,0 +1,7 @@
+[tasks.build]
+command = "cargo"
+args = ["build", "--release"]
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--release"]
--- a/multiplier/README.md
+++ b/multiplier/README.md
@@ -3,7 +3,15 @@
 Example wrapper around a basic Circom circuit to test Circom 2 integration
 through ark-circom and FFI.

-# FFI
+## Build and Test
+
+To build and test, run the following commands within the module folder
+```bash
+cargo make build
+cargo make test
+```
+
+## FFI

 To generate C or Nim bindings from Rust FFI, use `cbindgen` or `nbindgen`:

--- a/multiplier/src/ffi.rs
+++ b/multiplier/src/ffi.rs
@@ -31,12 +31,12 @@ impl<'a> From<&Buffer> for &'a [u8] {
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn new_circuit(ctx: *mut *mut Multiplier) -> bool {
-    println!("multiplier ffi: new");
-    let mul = Multiplier::new();
-
-    unsafe { *ctx = Box::into_raw(Box::new(mul)) };
-
-    true
+    if let Ok(mul) = Multiplier::new() {
+        unsafe { *ctx = Box::into_raw(Box::new(mul)) };
+        true
+    } else {
+        false
+    }
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
--- a/multiplier/src/main.rs
+++ b/multiplier/src/main.rs
@@ -1,6 +1,6 @@
 use ark_circom::{CircomBuilder, CircomConfig};
 use ark_std::rand::thread_rng;
-use color_eyre::Result;
+use color_eyre::{Report, Result};

 use ark_bn254::Bn254;
 use ark_groth16::{
@@ -25,17 +25,18 @@ fn groth16_proof_example() -> Result<()> {

    let circom = builder.build()?;

-    let inputs = circom.get_public_inputs().unwrap();
+    let inputs = circom
+        .get_public_inputs()
+        .ok_or(Report::msg("no public inputs"))?;

    let proof = prove(circom, &params, &mut rng)?;

    let pvk = prepare_verifying_key(&params.vk);

-    let verified = verify_proof(&pvk, &proof, &inputs)?;
-
-    assert!(verified);
-
-    Ok(())
+    match verify_proof(&pvk, &proof, &inputs) {
+        Ok(_) => Ok(()),
+        Err(_) => Err(Report::msg("not verified")),
+    }
 }

 fn main() {
--- a/multiplier/src/public.rs
+++ b/multiplier/src/public.rs
@@ -7,9 +7,8 @@ use ark_groth16::{
    Proof, ProvingKey,
 };
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
-// , SerializationError};
-
-use std::io::{self, Read, Write};
+use color_eyre::{Report, Result};
+use std::io::{Read, Write};

 pub struct Multiplier {
    circom: CircomCircuit<Bn254>,
@@ -18,12 +17,11 @@ pub struct Multiplier {

 impl Multiplier {
    // TODO Break this apart here
-    pub fn new() -> Multiplier {
+    pub fn new() -> Result<Multiplier> {
        let cfg = CircomConfig::<Bn254>::new(
            "./resources/circom2_multiplier2.wasm",
            "./resources/circom2_multiplier2.r1cs",
-        )
-        .unwrap();
+        )?;

        let mut builder = CircomBuilder::new(cfg);
        builder.push_input("a", 3);
@@ -34,40 +32,41 @@ impl Multiplier {

        let mut rng = thread_rng();

-        let params = generate_random_parameters::<Bn254, _, _>(circom, &mut rng).unwrap();
+        let params = generate_random_parameters::<Bn254, _, _>(circom, &mut rng)?;

-        let circom = builder.build().unwrap();
+        let circom = builder.build()?;

-        //let inputs = circom.get_public_inputs().unwrap();
-
-        Multiplier { circom, params }
+        Ok(Multiplier { circom, params })
    }

    // TODO Input Read
-    pub fn prove<W: Write>(&self, result_data: W) -> io::Result<()> {
+    pub fn prove<W: Write>(&self, result_data: W) -> Result<()> {
        let mut rng = thread_rng();

        // XXX: There's probably a better way to do this
        let circom = self.circom.clone();
        let params = self.params.clone();

-        let proof = prove(circom, &params, &mut rng).unwrap();
+        let proof = prove(circom, &params, &mut rng)?;

        // XXX: Unclear if this is different from other serialization(s)
-        let _ = proof.serialize(result_data).unwrap();
+        proof.serialize(result_data)?;

        Ok(())
    }

-    pub fn verify<R: Read>(&self, input_data: R) -> io::Result<bool> {
-        let proof = Proof::deserialize(input_data).unwrap();
+    pub fn verify<R: Read>(&self, input_data: R) -> Result<bool> {
+        let proof = Proof::deserialize(input_data)?;

        let pvk = prepare_verifying_key(&self.params.vk);

        // XXX Part of input data?
-        let inputs = self.circom.get_public_inputs().unwrap();
+        let inputs = self
+            .circom
+            .get_public_inputs()
+            .ok_or(Report::msg("no public inputs"))?;

-        let verified = verify_proof(&pvk, &proof, &inputs).unwrap();
+        let verified = verify_proof(&pvk, &proof, &inputs)?;

        Ok(verified)
    }
@@ -75,24 +74,6 @@ impl Multiplier {

 impl Default for Multiplier {
    fn default() -> Self {
-        Self::new()
+        Self::new().unwrap()
    }
 }
-
-#[test]
-fn multiplier_proof() {
-    let mul = Multiplier::new();
-    //let inputs = mul.circom.get_public_inputs().unwrap();
-
-    let mut output_data: Vec<u8> = Vec::new();
-    let _ = mul.prove(&mut output_data);
-
-    let proof_data = &output_data[..];
-
-    // XXX Pass as arg?
-    //let pvk = prepare_verifying_key(&mul.params.vk);
-
-    let verified = mul.verify(proof_data).unwrap();
-
-    assert!(verified);
-}
--- a/multiplier/tests/public.rs
+++ b/multiplier/tests/public.rs
@@ -0,0 +1,21 @@
+#[cfg(test)]
+mod tests {
+    use multiplier::public::Multiplier;
+
+    #[test]
+    fn multiplier_proof() {
+        let mul = Multiplier::new().unwrap();
+
+        let mut output_data: Vec<u8> = Vec::new();
+        let _ = mul.prove(&mut output_data);
+
+        let proof_data = &output_data[..];
+
+        // XXX Pass as arg?
+        //let pvk = prepare_verifying_key(&mul.params.vk);
+
+        let verified = mul.verify(proof_data).unwrap();
+
+        assert!(verified);
+    }
+}
--- a/private-settlement/Cargo.toml
+++ b/private-settlement/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "private-settlement"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
--- a/private-settlement/Makefile.toml
+++ b/private-settlement/Makefile.toml
@@ -0,0 +1,7 @@
+[tasks.build]
+command = "cargo"
+args = ["build", "--release"]
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--release"]
--- a/private-settlement/README.md
+++ b/private-settlement/README.md
@@ -0,0 +1,11 @@
+# Private Settlement  Module
+
+This module is to provide APIs to manage, compute and verify [Private Settlement](https://rfc.vac.dev/spec/44/) zkSNARK proofs and primitives.
+
+## Build and Test
+
+To build and test, run the following commands within the module folder
+```bash
+cargo make build
+cargo make test
+```
--- a/private-settlement/src/lib.rs
+++ b/private-settlement/src/lib.rs
@@ -0,0 +1 @@
+
--- a/private-settlement/tests/private-settlement.rs
+++ b/private-settlement/tests/private-settlement.rs
@@ -0,0 +1,11 @@
+#[cfg(test)]
+mod tests {
+    #[cfg(test)]
+    mod tests {
+        #[test]
+        fn it_works() {
+            let result = 2 + 2;
+            assert_eq!(result, 4);
+        }
+    }
+}
--- a/rln-wasm/.gitignore
+++ b/rln-wasm/.gitignore
@@ -0,0 +1,6 @@
+/target
+**/*.rs.bk
+Cargo.lock
+bin/
+pkg/
+wasm-pack.log
--- a/rln-wasm/Cargo.toml
+++ b/rln-wasm/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "rln-wasm"
+version = "0.0.7"
+edition = "2021"
+license = "MIT or Apache2"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+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"] }
+wasmer = { version = "2.3", default-features = false, features = ["js", "std"] }
+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"
+js-sys = "0.3.59"
+serde_json = "1.0.85"
+
+# The `console_error_panic_hook` crate provides better debugging of panics by
+# logging them with `console.error`. This is great for development, but requires
+# 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 }
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3.13"
+wasm-bindgen-futures = "0.4.33"
+
--- a/rln-wasm/Makefile.toml
+++ b/rln-wasm/Makefile.toml
@@ -0,0 +1,26 @@
+[tasks.pack-build]
+command = "wasm-pack"
+args = ["build", "--release", "--target", "web", "--scope", "waku"]
+
+[tasks.pack-rename]
+script = "sed -i.bak 's/rln-wasm/zerokit-rln-wasm/g' pkg/package.json && rm pkg/package.json.bak"
+
+[tasks.build]
+clear = true
+dependencies = [
+    "pack-build",
+    "pack-rename"
+]
+
+[tasks.test]
+command = "wasm-pack"
+args = ["test", "--release", "--node"]
+dependencies = ["build"]
+
+[tasks.login]
+command = "wasm-pack"
+args = ["login"]
+
+[tasks.publish]
+command = "wasm-pack"
+args = ["publish", "--access", "public", "--target", "web"]
--- a/rln-wasm/README.md
+++ b/rln-wasm/README.md
@@ -0,0 +1,36 @@
+# RLN for WASM
+This library is used in [waku-org/js-rln](https://github.com/waku-org/js-rln/)
+
+## Building the library
+1. Install `wasm-pack`
+```
+curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+```
+2. Install `cargo-make`
+```
+cargo install cargo-make
+```
+
+OR
+
+```
+make installdeps
+```
+3. Compile zerokit for `wasm32-unknown-unknown`:
+```
+cd rln-wasm
+cargo make build
+```
+
+## Running tests
+```
+cd rln-wasm
+cargo make test
+```
+
+## Publishing a npm package
+```
+cd rln-wasm
+cargo make login
+cargo make publish
+```
--- a/rln-wasm/resources/witness_calculator.js
+++ b/rln-wasm/resources/witness_calculator.js
@@ -0,0 +1,331 @@
+module.exports = async function builder(code, options) {
+
+    options = options || {};
+
+    let wasmModule;
+    try {
+	wasmModule = await WebAssembly.compile(code);
+    }  catch (err) {
+	console.log(err);
+	console.log("\nTry to run circom --c in order to generate c++ code instead\n");
+	throw new Error(err);
+    }
+
+    let wc;
+
+    let errStr = "";
+    let msgStr = "";
+    
+    const instance = await WebAssembly.instantiate(wasmModule, {
+        runtime: {
+            exceptionHandler : function(code) {
+		let err;
+                if (code == 1) {
+                    err = "Signal not found.\n";
+                } else if (code == 2) {
+                    err = "Too many signals set.\n";
+                } else if (code == 3) {
+                    err = "Signal already set.\n";
+		} else if (code == 4) {
+                    err = "Assert Failed.\n";
+		} else if (code == 5) {
+                    err = "Not enough memory.\n";
+		} else if (code == 6) {
+                    err = "Input signal array access exceeds the size.\n";
+		} else {
+		    err = "Unknown error.\n";
+                }
+                throw new Error(err + errStr);
+            },
+	    printErrorMessage : function() {
+		errStr += getMessage() + "\n";
+                // console.error(getMessage());
+	    },
+	    writeBufferMessage : function() {
+			const msg = getMessage();
+			// Any calls to `log()` will always end with a `\n`, so that's when we print and reset
+			if (msg === "\n") {
+				console.log(msgStr);
+				msgStr = "";
+			} else {
+				// If we've buffered other content, put a space in between the items
+				if (msgStr !== "") {
+					msgStr += " "
+				}
+				// Then append the message to the message we are creating
+				msgStr += msg;
+			}
+	    },
+	    showSharedRWMemory : function() {
+		printSharedRWMemory ();
+            }
+
+        }
+    });
+
+    const sanityCheck =
+        options
+//        options &&
+//        (
+//            options.sanityCheck ||
+//            options.logGetSignal ||
+//            options.logSetSignal ||
+//            options.logStartComponent ||
+//            options.logFinishComponent
+//        );
+
+    
+    wc = new WitnessCalculator(instance, sanityCheck);
+    return wc;
+
+    function getMessage() {
+        var message = "";
+	var c = instance.exports.getMessageChar();
+        while ( c != 0 ) {
+	    message += String.fromCharCode(c);
+	    c = instance.exports.getMessageChar();
+	}
+        return message;
+    }
+	
+    function printSharedRWMemory () {
+	const shared_rw_memory_size = instance.exports.getFieldNumLen32();
+	const arr = new Uint32Array(shared_rw_memory_size);
+	for (let j=0; j<shared_rw_memory_size; j++) {
+	    arr[shared_rw_memory_size-1-j] = instance.exports.readSharedRWMemory(j);
+	}
+
+	// If we've buffered other content, put a space in between the items
+	if (msgStr !== "") {
+		msgStr += " "
+	}
+	// Then append the value to the message we are creating
+	msgStr += (fromArray32(arr).toString());
+	}
+
+};
+
+class WitnessCalculator {
+    constructor(instance, sanityCheck) {
+        this.instance = instance;
+
+	this.version = this.instance.exports.getVersion();
+        this.n32 = this.instance.exports.getFieldNumLen32();
+
+        this.instance.exports.getRawPrime();
+        const arr = new Uint32Array(this.n32);
+        for (let i=0; i<this.n32; i++) {
+            arr[this.n32-1-i] = this.instance.exports.readSharedRWMemory(i);
+        }
+        this.prime = fromArray32(arr);
+
+        this.witnessSize = this.instance.exports.getWitnessSize();
+
+        this.sanityCheck = sanityCheck;
+    }
+    
+    circom_version() {
+	return this.instance.exports.getVersion();
+    }
+
+    async _doCalculateWitness(input, sanityCheck) {
+	//input is assumed to be a map from signals to arrays of bigints
+        this.instance.exports.init((this.sanityCheck || sanityCheck) ? 1 : 0);
+        const keys = Object.keys(input);
+	var input_counter = 0;
+        keys.forEach( (k) => {
+            const h = fnvHash(k);
+            const hMSB = parseInt(h.slice(0,8), 16);
+            const hLSB = parseInt(h.slice(8,16), 16);
+            const fArr = flatArray(input[k]);
+	    let signalSize = this.instance.exports.getInputSignalSize(hMSB, hLSB);
+	    if (signalSize < 0){
+		throw new Error(`Signal ${k} not found\n`);
+	    }
+	    if (fArr.length < signalSize) {
+		throw new Error(`Not enough values for input signal ${k}\n`);
+	    }
+	    if (fArr.length > signalSize) {
+		throw new Error(`Too many values for input signal ${k}\n`);
+	    }
+            for (let i=0; i<fArr.length; i++) {
+                const arrFr = toArray32(BigInt(fArr[i])%this.prime,this.n32)
+                for (let j=0; j<this.n32; j++) {
+		    this.instance.exports.writeSharedRWMemory(j,arrFr[this.n32-1-j]);
+		}
+		try {
+                    this.instance.exports.setInputSignal(hMSB, hLSB,i);
+		    input_counter++;
+		} catch (err) {
+		    // console.log(`After adding signal ${i} of ${k}`)
+                    throw new Error(err);
+		}
+            }
+
+        });
+	if (input_counter < this.instance.exports.getInputSize()) {
+	    throw new Error(`Not all inputs have been set. Only ${input_counter} out of ${this.instance.exports.getInputSize()}`);
+	}
+    }
+
+    async calculateWitness(input, sanityCheck) {
+
+        const w = [];
+
+        await this._doCalculateWitness(input, sanityCheck);
+
+        for (let i=0; i<this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+	    const arr = new Uint32Array(this.n32);
+            for (let j=0; j<this.n32; j++) {
+            arr[this.n32-1-j] = this.instance.exports.readSharedRWMemory(j);
+            }
+            w.push(fromArray32(arr));
+        }
+
+        return w;
+    }
+    
+
+    async calculateBinWitness(input, sanityCheck) {
+
+        const buff32 = new Uint32Array(this.witnessSize*this.n32);
+	const buff = new  Uint8Array( buff32.buffer);
+        await this._doCalculateWitness(input, sanityCheck);
+
+        for (let i=0; i<this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+	    const pos = i*this.n32;
+            for (let j=0; j<this.n32; j++) {
+		buff32[pos+j] = this.instance.exports.readSharedRWMemory(j);
+            }
+        }
+
+	return buff;
+    }
+    
+
+    async calculateWTNSBin(input, sanityCheck) {
+
+        const buff32 = new Uint32Array(this.witnessSize*this.n32+this.n32+11);
+	const buff = new  Uint8Array( buff32.buffer);
+        await this._doCalculateWitness(input, sanityCheck);
+  
+	//"wtns"
+	buff[0] = "w".charCodeAt(0)
+	buff[1] = "t".charCodeAt(0)
+	buff[2] = "n".charCodeAt(0)
+	buff[3] = "s".charCodeAt(0)
+
+	//version 2
+	buff32[1] = 2;
+
+	//number of sections: 2
+	buff32[2] = 2;
+
+	//id section 1
+	buff32[3] = 1;
+
+	const n8 = this.n32*4;
+	//id section 1 length in 64bytes
+	const idSection1length = 8 + n8;
+	const idSection1lengthHex = idSection1length.toString(16);
+        buff32[4] = parseInt(idSection1lengthHex.slice(0,8), 16);
+        buff32[5] = parseInt(idSection1lengthHex.slice(8,16), 16);
+
+	//this.n32
+	buff32[6] = n8;
+
+	//prime number
+	this.instance.exports.getRawPrime();
+
+	var pos = 7;
+        for (let j=0; j<this.n32; j++) {
+	    buff32[pos+j] = this.instance.exports.readSharedRWMemory(j);
+        }
+	pos += this.n32;
+
+	// witness size
+	buff32[pos] = this.witnessSize;
+	pos++;
+
+	//id section 2
+	buff32[pos] = 2;
+	pos++;
+
+	// section 2 length
+	const idSection2length = n8*this.witnessSize;
+	const idSection2lengthHex = idSection2length.toString(16);
+        buff32[pos] = parseInt(idSection2lengthHex.slice(0,8), 16);
+        buff32[pos+1] = parseInt(idSection2lengthHex.slice(8,16), 16);
+
+	pos += 2;
+        for (let i=0; i<this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+            for (let j=0; j<this.n32; j++) {
+		buff32[pos+j] = this.instance.exports.readSharedRWMemory(j);
+            }
+	    pos += this.n32;
+        }
+
+	return buff;
+    }
+
+}
+
+
+function toArray32(rem,size) {
+    const res = []; //new Uint32Array(size); //has no unshift
+    const radix = BigInt(0x100000000);
+    while (rem) {
+        res.unshift( Number(rem % radix));
+        rem = rem / radix;
+    }
+    if (size) {
+	var i = size - res.length;
+	while (i>0) {
+	    res.unshift(0);
+	    i--;
+	}
+    }
+    return res;
+}
+
+function fromArray32(arr) { //returns a BigInt
+    var res = BigInt(0);
+    const radix = BigInt(0x100000000);
+    for (let i = 0; i<arr.length; i++) {
+        res = res*radix + BigInt(arr[i]);
+    }
+    return res;
+}
+
+function flatArray(a) {
+    var res = [];
+    fillArray(res, a);
+    return res;
+
+    function fillArray(res, a) {
+        if (Array.isArray(a)) {
+            for (let i=0; i<a.length; i++) {
+                fillArray(res, a[i]);
+            }
+        } else {
+            res.push(a);
+        }
+    }
+}
+
+function fnvHash(str) {
+    const uint64_max = BigInt(2) ** BigInt(64);
+    let hash = BigInt("0xCBF29CE484222325");
+    for (var i = 0; i < str.length; i++) {
+	hash ^= BigInt(str[i].charCodeAt());
+	hash *= BigInt(0x100000001B3);
+	hash %= uint64_max;
+    }
+    let shash = hash.toString(16);
+    let n = 16 - shash.length;
+    shash = '0'.repeat(n).concat(shash);
+    return shash;
+}
--- a/rln-wasm/src/lib.rs
+++ b/rln-wasm/src/lib.rs
@@ -0,0 +1,296 @@
+#![cfg(target_arch = "wasm32")]
+
+extern crate wasm_bindgen;
+extern crate web_sys;
+
+use js_sys::{BigInt as JsBigInt, Object, Uint8Array};
+use num_bigint::BigInt;
+use rln::public::RLN;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn init_panic_hook() {
+    console_error_panic_hook::set_once();
+}
+
+#[wasm_bindgen(js_name = RLN)]
+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>,
+}
+
+#[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))?;
+    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 wrapper = unsafe { &mut *ctx };
+    let rln_witness = wrapper
+        .instance
+        .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> {
+    let wrapper = unsafe { &mut *ctx };
+    if wrapper.instance.set_next_leaf(&input.to_vec()[..]).is_ok() {
+        Ok(())
+    } else {
+        Err("could not insert member into merkle tree".into())
+    }
+}
+
+#[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> {
+    let wrapper = unsafe { &mut *ctx };
+    if wrapper
+        .instance
+        .set_leaves_from(index as usize, &input.to_vec()[..])
+        .is_ok()
+    {
+        Ok(())
+    } else {
+        Err("could not set multiple leaves".into())
+    }
+}
+
+#[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> {
+    let wrapper = unsafe { &mut *ctx };
+    if wrapper
+        .instance
+        .init_tree_with_leaves(&input.to_vec()[..])
+        .is_ok()
+    {
+        Ok(())
+    } else {
+        Err("could not init merkle tree".into())
+    }
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[wasm_bindgen(js_name = RLNWitnessToJson)]
+pub fn rln_witness_to_json(
+    ctx: *mut RLNWrapper,
+    serialized_witness: Uint8Array,
+) -> Result<Object, String> {
+    let wrapper = unsafe { &mut *ctx };
+    let inputs = wrapper
+        .instance
+        .get_rln_witness_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(
+    ctx: *mut RLNWrapper,
+    calculated_witness: Vec<JsBigInt>,
+    serialized_witness: Uint8Array,
+) -> Result<Uint8Array, String> {
+    let wrapper = unsafe { &mut *ctx };
+
+    let mut witness_vec: Vec<BigInt> = vec![];
+
+    for v in calculated_witness {
+        witness_vec.push(
+            v.to_string(10)
+                .map_err(|err| format!("{:#?}", err))?
+                .as_string()
+                .ok_or("not a string error")?
+                .parse::<BigInt>()
+                .map_err(|err| format!("{:#?}", err))?,
+        );
+    }
+
+    let mut output_data: Vec<u8> = Vec::new();
+
+    if wrapper
+        .instance
+        .generate_rln_proof_with_witness(witness_vec, serialized_witness.to_vec(), &mut output_data)
+        .is_ok()
+    {
+        let result = Uint8Array::from(&output_data[..]);
+        std::mem::forget(output_data);
+        Ok(result)
+    } else {
+        std::mem::forget(output_data);
+        Err("could not generate proof".into())
+    }
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[wasm_bindgen(js_name = generateMembershipKey)]
+pub fn wasm_key_gen(ctx: *const RLNWrapper) -> Result<Uint8Array, String> {
+    let wrapper = unsafe { &*ctx };
+    let mut output_data: Vec<u8> = Vec::new();
+    if wrapper.instance.key_gen(&mut output_data).is_ok() {
+        let result = Uint8Array::from(&output_data[..]);
+        std::mem::forget(output_data);
+        Ok(result)
+    } else {
+        std::mem::forget(output_data);
+        Err("could not generate membership keys".into())
+    }
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[wasm_bindgen(js_name = generateExtendedMembershipKey)]
+pub fn wasm_extended_key_gen(ctx: *const RLNWrapper) -> Result<Uint8Array, String> {
+    let wrapper = unsafe { &*ctx };
+    let mut output_data: Vec<u8> = Vec::new();
+    if wrapper.instance.extended_key_gen(&mut output_data).is_ok() {
+        let result = Uint8Array::from(&output_data[..]);
+        std::mem::forget(output_data);
+        Ok(result)
+    } else {
+        std::mem::forget(output_data);
+        Err("could not generate membership keys".into())
+    }
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[wasm_bindgen(js_name = generateSeededMembershipKey)]
+pub fn wasm_seeded_key_gen(ctx: *const RLNWrapper, seed: Uint8Array) -> Result<Uint8Array, String> {
+    let wrapper = unsafe { &*ctx };
+    let mut output_data: Vec<u8> = Vec::new();
+    if wrapper
+        .instance
+        .seeded_key_gen(&seed.to_vec()[..], &mut output_data)
+        .is_ok()
+    {
+        let result = Uint8Array::from(&output_data[..]);
+        std::mem::forget(output_data);
+        Ok(result)
+    } else {
+        std::mem::forget(output_data);
+        Err("could not generate membership key".into())
+    }
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[wasm_bindgen(js_name = generateSeededExtendedMembershipKey)]
+pub fn wasm_seeded_extended_key_gen(
+    ctx: *const RLNWrapper,
+    seed: Uint8Array,
+) -> Result<Uint8Array, String> {
+    let wrapper = unsafe { &*ctx };
+    let mut output_data: Vec<u8> = Vec::new();
+    if wrapper
+        .instance
+        .seeded_extended_key_gen(&seed.to_vec()[..], &mut output_data)
+        .is_ok()
+    {
+        let result = Uint8Array::from(&output_data[..]);
+        std::mem::forget(output_data);
+        Ok(result)
+    } else {
+        std::mem::forget(output_data);
+        Err("could not generate membership key".into())
+    }
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[wasm_bindgen(js_name = recovedIDSecret)]
+pub fn wasm_recover_id_secret(
+    ctx: *const RLNWrapper,
+    input_proof_data_1: Uint8Array,
+    input_proof_data_2: Uint8Array,
+) -> Result<Uint8Array, String> {
+    let wrapper = unsafe { &*ctx };
+    let mut output_data: Vec<u8> = Vec::new();
+    if wrapper
+        .instance
+        .recover_id_secret(
+            &input_proof_data_1.to_vec()[..],
+            &input_proof_data_2.to_vec()[..],
+            &mut output_data,
+        )
+        .is_ok()
+    {
+        let result = Uint8Array::from(&output_data[..]);
+        std::mem::forget(output_data);
+        Ok(result)
+    } else {
+        std::mem::forget(output_data);
+        Err("could not recover id secret".into())
+    }
+}
+
+#[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> {
+    let wrapper = unsafe { &*ctx };
+    if match wrapper.instance.verify_rln_proof(&proof.to_vec()[..]) {
+        Ok(verified) => verified,
+        Err(_) => return Err("error while verifying rln proof".into()),
+    } {
+        return Ok(true);
+    }
+
+    Ok(false)
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[wasm_bindgen(js_name = verifyWithRoots)]
+pub fn wasm_verify_with_roots(
+    ctx: *const RLNWrapper,
+    proof: Uint8Array,
+    roots: Uint8Array,
+) -> Result<bool, String> {
+    let wrapper = unsafe { &*ctx };
+    if match wrapper
+        .instance
+        .verify_with_roots(&proof.to_vec()[..], &roots.to_vec()[..])
+    {
+        Ok(verified) => verified,
+        Err(_) => return Err("error while verifying proof with roots".into()),
+    } {
+        return Ok(true);
+    }
+
+    Ok(false)
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[wasm_bindgen(js_name = getRoot)]
+pub fn wasm_get_root(ctx: *const RLNWrapper) -> Result<Uint8Array, String> {
+    let wrapper = unsafe { &*ctx };
+    let mut output_data: Vec<u8> = Vec::new();
+    if wrapper.instance.get_root(&mut output_data).is_ok() {
+        let result = Uint8Array::from(&output_data[..]);
+        std::mem::forget(output_data);
+        Ok(result)
+    } else {
+        std::mem::forget(output_data);
+        Err("could not obtain root".into())
+    }
+}
--- a/rln-wasm/src/utils.js
+++ b/rln-wasm/src/utils.js
@@ -0,0 +1,18 @@
+const fs = require("fs");
+
+// Utils functions for loading circom witness calculator and reading files from test
+
+module.exports = {
+    read_file: function (path) {
+        return fs.readFileSync(path);
+    },
+
+    calculateWitness: async function(circom_path, inputs){
+        const wc = require("resources/witness_calculator.js");
+        const wasmFile = fs.readFileSync(circom_path);
+        const wasmFileBuffer = wasmFile.slice(wasmFile.byteOffset, wasmFile.byteOffset + wasmFile.byteLength);
+        const witnessCalculator = await wc(wasmFileBuffer);
+        const calculatedWitness = await witnessCalculator.calculateWitness(inputs, false);
+        return JSON.stringify(calculatedWitness, (key, value) => typeof value === "bigint" ? value.toString() : value);
+    }
+}
--- a/rln-wasm/tests/rln-wasm.rs
+++ b/rln-wasm/tests/rln-wasm.rs
@@ -0,0 +1,111 @@
+#![cfg(target_arch = "wasm32")]
+
+#[cfg(test)]
+mod tests {
+    use js_sys::{BigInt as JsBigInt, Object, Uint8Array};
+    use rln::circuit::TEST_TREE_HEIGHT;
+    use rln::utils::normalize_usize;
+    use rln_wasm::*;
+    use wasm_bindgen::prelude::*;
+    use wasm_bindgen::JsValue;
+    use wasm_bindgen_test::wasm_bindgen_test;
+
+    #[wasm_bindgen(module = "src/utils.js")]
+    extern "C" {
+        #[wasm_bindgen(catch)]
+        fn read_file(path: &str) -> Result<Uint8Array, JsValue>;
+
+        #[wasm_bindgen(catch)]
+        async fn calculateWitness(circom_path: &str, input: Object) -> Result<JsValue, JsValue>;
+    }
+
+    #[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();
+
+        // Creating an instance of RLN
+        let rln_instance = wasm_new(tree_height, zkey, vk);
+
+        // Creating membership key
+        let mem_keys = wasm_key_gen(rln_instance).unwrap();
+        let idkey = mem_keys.subarray(0, 32);
+        let idcommitment = mem_keys.subarray(32, 64);
+
+        // Insert PK
+        wasm_set_next_leaf(rln_instance, idcommitment).unwrap();
+
+        // Prepare the message
+        let signal = "Hello World".as_bytes();
+
+        // Setting up the epoch (With 0s for the test)
+        let epoch = Uint8Array::new_with_length(32);
+        epoch.fill(0, 0, 32);
+
+        let identity_index: usize = 0;
+
+        // Serializing the message
+        let mut serialized_vec: Vec<u8> = Vec::new();
+        serialized_vec.append(&mut idkey.to_vec());
+        serialized_vec.append(&mut normalize_usize(identity_index));
+        serialized_vec.append(&mut epoch.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);
+
+        // Obtaining inputs that should be sent to circom witness calculator
+        let json_inputs = rln_witness_to_json(rln_instance, serialized_rln_witness.clone());
+
+        // 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)
+            .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();
+
+        // Generating proof
+        let proof = generate_rln_proof_with_witness(
+            rln_instance,
+            calculated_witness.into(),
+            serialized_rln_witness,
+        )
+        .unwrap();
+
+        // Add signal_len | signal
+        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 proof_with_signal = Uint8Array::from(&proof_bytes[..]);
+
+        let is_proof_valid = wasm_verify_with_roots(rln_instance, proof_with_signal, roots);
+        assert!(is_proof_valid.unwrap(), "verifying proof with roots failed");
+    }
+}
--- a/rln/Cargo.toml
+++ b/rln/Cargo.toml
@@ -2,41 +2,57 @@
 name = "rln"
 version = "0.1.0"
 edition = "2021"
+license = "MIT OR Apache-2.0"

 [lib]
-crate-type = ["cdylib", "rlib", "staticlib"]
+crate-type = ["rlib", "staticlib"]
+
+# This flag disable cargo doctests, i.e. testing example code-snippets in documentation
+doctest = false
+

 [dependencies]
-
 # ZKP Generation
-ark-ff = { version = "0.3.0", default-features = false, features = ["parallel", "asm"] }
-ark-std = { version = "0.3.0", default-features = false, features = ["parallel"] }
-ark-bn254 = { version = "0.3.0" }
-ark-groth16 = { git = "https://github.com/arkworks-rs/groth16", rev = "765817f", features = ["parallel"] }
-ark-relations = { version = "0.3.0", default-features = false, features = [ "std" ] }
-ark-serialize = { version = "0.3.0", default-features = false }
-ark-circom = { git = "https://github.com/gakonst/ark-circom", rev = "06eb075", features = ["circom-2"] }
-#ark-circom = { git = "https://github.com/vacp2p/ark-circom", branch = "no-ethers-core", features = ["circom-2"] }
-wasmer = "2.3.0"
+ark-ec = { version = "=0.4.1", default-features = false }
+ark-ff = { version = "=0.4.1", default-features = false, features = [ "asm"] }
+ark-std = { version = "=0.4.0", default-features = false }
+ark-bn254 = { version = "=0.4.0" }
+ark-groth16 = { version = "=0.4.0", features = ["parallel"], default-features = false }
+ark-relations = { version = "=0.4.0", default-features = false, features = [ "std" ] }
+ark-serialize = { version = "=0.4.1", default-features = false }
+ark-circom = { git = "https://github.com/gakonst/ark-circom", default-features = false, features = ["circom-2"] }
+
+# WASM
+wasmer = { version = "2.3.0", default-features = false }

 # error handling
-color-eyre = "0.5.11"
-thiserror = "1.0.0"
+color-eyre = "=0.6.2"
+thiserror = "=1.0.38"

 # utilities
-cfg-if = "1.0"
-num-bigint = { version = "0.4.3", default-features = false, features = ["rand"] }
+cfg-if = "=1.0"
+num-bigint = { version = "=0.4.3", default-features = false, features = ["rand"] }
 num-traits = "0.2.11"
 once_cell = "1.14.0"
-rand = "0.8"
-tiny-keccak = { version = "2.0.2", features = ["keccak"] }
+rand = "=0.8.5"
+rand_chacha = "=0.3.1"
+tiny-keccak = { version = "=2.0.2", features = ["keccak"] }
+utils = { path = "../utils/", default-features = false }
+pmtree = { git = "https://github.com/Rate-Limiting-Nullifier/pmtree", rev = "f6d1a1fecad72cd39e6808e78085091d541dc882", optional = true}

 # serialization
 serde_json = "1.0.48"

-[dev-dependencies]
+include_dir = "=0.7.3"

-hex-literal = "0.3.4"
+[dev-dependencies]
+sled = "=0.34.7"

 [features]
-fullmerkletree = []
+default = ["parallel", "wasmer/sys-default"]
+parallel = ["ark-ec/parallel", "ark-ff/parallel", "ark-std/parallel", "ark-groth16/parallel", "utils/parallel"]
+wasm = ["wasmer/js", "wasmer/std"]
+fullmerkletree = ["default"]
+
+# Note: pmtree feature is still experimental
+pmtree-ft = ["default", "pmtree"]
--- a/rln/Makefile.toml
+++ b/rln/Makefile.toml
@@ -0,0 +1,7 @@
+[tasks.build]
+command = "cargo"
+args = ["build", "--release"]
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--release"]
--- a/rln/README.md
+++ b/rln/README.md
@@ -2,15 +2,28 @@

 This module provides APIs to manage, compute and verify [RLN](https://rfc.vac.dev/spec/32/) zkSNARK proofs and RLN primitives.

-Currently, this module comes with three [pre-compiled](https://github.com/vacp2p/zerokit/tree/master/rln/resources) RLN circuits having Merkle tree of height `15`, `19` and `20`, respectively.
+## Pre-requisites
+### Install dependencies and clone repo

-Implemented tests can be executed by running within the module folder
+```sh
+make installdeps
+git clone https://github.com/vacp2p/zerokit.git
+cd zerokit/rln
+```

-`cargo test --release`
+### Build and Test

-## Compiling circuits
+To build and test, run the following commands within the module folder
+```bash
+cargo make build
+cargo make test
+```

-`rln` (https://github.com/privacy-scaling-explorations/rln) repo with Circuits is contained as a submodule. 
+### Compile ZK circuits
+
+The `rln` (https://github.com/privacy-scaling-explorations/rln) repository, which contains the RLN circuit implementation is a submodule of zerokit RLN. 
+
+To compile the RLN circuit

 ``` sh
 # Update submodules
@@ -27,9 +40,9 @@ cp build/zkeyFiles/rln-final.zkey ../../resources/tree_height_15
 cp build/zkeyFiles/rln.wasm ../../resources/tree_height_15
 ```

-Note that the above code snippet will compile a RLN circuit with a Merkle tree of height equal `15` based on the default value set in `rln/circuit/rln.circom`.
+Note that the above code snippet will compile a RLN circuit with a Merkle tree of height equal `15` based on the default value set in `vendor/rln/circuit/rln.circom`.

-To compile a RLN circuit with Merkle tree height `N`, it suffices to change `rln/circuit/rln.circom` to
+In order to compile a RLN circuit with Merkle tree height `N`, it suffices to change `vendor/rln/circuit/rln.circom` to

 ```
 pragma circom 2.0.0;
@@ -40,4 +53,144 @@ component main {public [x, epoch, rln_identifier ]} = RLN(N);
 ```

 However, if `N` is too big, this might require a bigger Powers of Tau ceremony than the one hardcoded in `./scripts/build-circuits.sh`, which is `2^14`. 
-In such case we refer to the official [Circom documentation](https://docs.circom.io/getting-started/proving-circuits/#powers-of-tau) for instructions on how to run an appropriate Powers of Tau ceremony and Phase 2 in order to compile the desired circuit.
+In such case we refer to the official [Circom documentation](https://docs.circom.io/getting-started/proving-circuits/#powers-of-tau) for instructions on how to run an appropriate Powers of Tau ceremony and Phase 2 in order to compile the desired circuit.
+
+
+Currently, the `rln` module comes with three [pre-compiled](https://github.com/vacp2p/zerokit/tree/master/rln/resources) RLN circuits having Merkle tree of height `15`, `19` and `20`, respectively.
+
+## Getting started
+
+### Add RLN as dependency
+
+We start by adding zerokit RLN to our `Cargo.toml`
+
+```toml
+[dependencies]
+rln = { git = "https://github.com/vacp2p/zerokit" }
+```
+
+### Create a RLN object
+
+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`) and verification key (`verification_key.json`, 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.
+
+```rust
+use rln::protocol::*;
+use rln::public::*;
+use std::io::Cursor;
+
+// We set the RLN parameters: 
+// - the tree height;
+// - the circuit resource folder (requires a trailing "/").
+let tree_height = 20;
+let resources = Cursor::new("../zerokit/rln/resources/tree_height_20/");
+
+// We create a new RLN instance
+let mut rln = RLN::new(tree_height, resources);
+```
+
+### Generate an identity keypair
+
+We generate an identity keypair
+
+```rust
+// We generate an identity pair
+let mut buffer = Cursor::new(Vec::<u8>::new());
+rln.key_gen(&mut buffer).unwrap();
+
+// We deserialize the keygen output to obtain
+// the identiy_secret and id_commitment
+let (identity_secret_hash, id_commitment) = deserialize_identity_pair(buffer.into_inner());
+```
+
+### Add ID commitment to the RLN Merkle tree
+
+```rust
+// We define the tree index where id_commitment will be added
+let id_index = 10;
+
+// We serialize id_commitment and pass it to set_leaf
+let mut buffer = Cursor::new(serialize_field_element(id_commitment));
+rln.set_leaf(id_index, &mut buffer).unwrap();
+```
+
+Note that when tree leaves are not explicitly set by the user (in this example, all those with index less and greater than `10`), their values is set to an hardcoded default (all-`0` bytes in current implementation).
+
+### Set epoch
+
+The epoch, sometimes referred to as _external nullifier_, is used to identify messages received in a certain time frame. It usually corresponds to the current UNIX time but can also be set to a random value or generated by a seed, provided that it corresponds to a field element.
+
+```rust
+// We generate epoch from a date seed and we ensure is
+// mapped to a field element by hashing-to-field its content
+let epoch = hash_to_field(b"Today at noon, this year");
+```
+### Set signal
+
+The signal is the message for which we are computing a RLN proof.
+
+```rust
+// We set our signal 
+let signal = b"RLN is awesome";
+```
+
+### Generate a RLN proof
+
+We prepare the input to the proof generation routine. 
+
+Input buffer is serialized as `[ identity_key | id_index | epoch | signal_len | signal ]`.
+
+```rust
+// We prepare input to the proof generation routine
+let proof_input = prepare_prove_input(identity_secret_hash, id_index, epoch, signal);
+```
+
+We are now ready to generate a RLN ZK proof along with the _public outputs_ of the ZK circuit evaluation.
+
+```rust
+
+// We generate a RLN proof for proof_input
+let mut in_buffer = Cursor::new(proof_input);
+let mut out_buffer = Cursor::new(Vec::<u8>::new());
+rln.generate_rln_proof(&mut in_buffer, &mut out_buffer)
+    .unwrap();
+
+// We get the public outputs returned by the circuit evaluation
+let proof_data = out_buffer.into_inner();
+```
+
+The byte vector `proof_data` is serialized as `[ zk-proof | tree_root | epoch | share_x | share_y | nullifier | rln_identifier ]`.
+
+
+### Verify a RLN proof
+
+We prepare the input to the proof verification routine. 
+
+Input buffer is serialized as `[proof_data | signal_len | signal ]`, where `proof_data` is (computed as) the output obtained by `generate_rln_proof`.
+
+```rust
+// We prepare input to the proof verification routine
+let verify_data = prepare_verify_input(proof_data, signal);
+
+// We verify the zk-proof against the provided proof values
+let mut in_buffer = Cursor::new(verify_data);
+let verified = rln.verify(&mut in_buffer).unwrap();
+```
+
+We check if the proof verification was successful: 
+```rust
+// We ensure the proof is valid
+assert!(verified);
+```
+
+## Get involved!
+Zerokit RLN public and FFI APIs allow interaction with many more features than what briefly showcased above.
+
+We invite you to check our API documentation by running
+```rust
+cargo doc --no-deps
+```
+and look at unit tests to have an hint on how to interface and use them.
--- a/rln/resources/tree_height_15/rln.wasm
+++ b/rln/resources/tree_height_15/rln.wasm
--- a/rln/resources/tree_height_15/rln_final.zkey
+++ b/rln/resources/tree_height_15/rln_final.zkey
--- a/rln/resources/tree_height_15/verification_key.json
+++ b/rln/resources/tree_height_15/verification_key.json
@@ -0,0 +1,119 @@
+{
+ "protocol": "groth16",
+ "curve": "bn128",
+ "nPublic": 6,
+ "vk_alpha_1": [
+  "20124996762962216725442980738609010303800849578410091356605067053491763969391",
+  "9118593021526896828671519912099489027245924097793322973632351264852174143923",
+  "1"
+ ],
+ "vk_beta_2": [
+  [
+   "4693952934005375501364248788849686435240706020501681709396105298107971354382",
+   "14346958885444710485362620645446987998958218205939139994511461437152241966681"
+  ],
+  [
+   "16851772916911573982706166384196538392731905827088356034885868448550849804972",
+   "823612331030938060799959717749043047845343400798220427319188951998582076532"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "vk_gamma_2": [
+  [
+   "10857046999023057135944570762232829481370756359578518086990519993285655852781",
+   "11559732032986387107991004021392285783925812861821192530917403151452391805634"
+  ],
+  [
+   "8495653923123431417604973247489272438418190587263600148770280649306958101930",
+   "4082367875863433681332203403145435568316851327593401208105741076214120093531"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "vk_delta_2": [
+  [
+   "1361919643088555407518565462732544232965454074504004321739078395285189557133",
+   "20823246840633598579879223919854294301857184404415306521912631074982696570306"
+  ],
+  [
+   "7088590198103342249937795923142619828109070290720888704402714617857746884833",
+   "8191367139632195506244169264298620546181137131063303219908889318280111188437"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "vk_alphabeta_12": [
+  [
+   [
+    "12608968655665301215455851857466367636344427685631271961542642719683786103711",
+    "9849575605876329747382930567422916152871921500826003490242628251047652318086"
+   ],
+   [
+    "6322029441245076030714726551623552073612922718416871603535535085523083939021",
+    "8700115492541474338049149013125102281865518624059015445617546140629435818912"
+   ],
+   [
+    "10674973475340072635573101639867487770811074181475255667220644196793546640210",
+    "2926286967251299230490668407790788696102889214647256022788211245826267484824"
+   ]
+  ],
+  [
+   [
+    "9660441540778523475944706619139394922744328902833875392144658911530830074820",
+    "19548113127774514328631808547691096362144426239827206966690021428110281506546"
+   ],
+   [
+    "1870837942477655969123169532603615788122896469891695773961478956740992497097",
+    "12536105729661705698805725105036536744930776470051238187456307227425796690780"
+   ],
+   [
+    "21811903352654147452884857281720047789720483752548991551595462057142824037334",
+    "19021616763967199151052893283384285352200445499680068407023236283004353578353"
+   ]
+  ]
+ ],
+ "IC": [
+  [
+   "17643142412395322664866141827318671249236739056291610144830020671604112279111",
+   "13273439661778801509295280274403992505521239023074387826870538372514206268318",
+   "1"
+  ],
+  [
+   "12325966053136615826793633393742326952102053533176311103856731330114882211366",
+   "6439956820140153832120005353467272867287237423425778281905068783317736451260",
+   "1"
+  ],
+  [
+   "20405310272367450124741832665322768131899487413829191383721623069139009993137",
+   "21336772016824870564600007750206596010566056069977718959140462128560786193566",
+   "1"
+  ],
+  [
+   "4007669092231576644992949839487535590075070172447826102934640178940614212519",
+   "7597503385395289202372182678960254605827199004598882158153019657732525465207",
+   "1"
+  ],
+  [
+   "4545695279389338758267531646940033299700127241196839077811942492841603458462",
+   "6635771967009274882904456432128877995932122611166121203658485990305433499873",
+   "1"
+  ],
+  [
+   "7876954805169515500747828488548350352651069599547377092970620945851311591012",
+   "7571431725691513008054581132582771105743462534789373657638701712901679323321",
+   "1"
+  ],
+  [
+   "5563973122249220346301217166900152021860462617567141574881706390202619333219",
+   "5147729144109676590873823097632042430451708874867871369293332620382492068692",
+   "1"
+  ]
+ ]
+}
--- a/rln/resources/tree_height_19/rln.wasm
+++ b/rln/resources/tree_height_19/rln.wasm
--- a/rln/resources/tree_height_19/rln_final.zkey
+++ b/rln/resources/tree_height_19/rln_final.zkey
--- a/rln/resources/tree_height_19/verification_key.json
+++ b/rln/resources/tree_height_19/verification_key.json
@@ -3,18 +3,18 @@
 "curve": "bn128",
 "nPublic": 6,
 "vk_alpha_1": [
-  "1805378556360488226980822394597799963030511477964155500103132920745199284516",
-  "11990395240534218699464972016456017378439762088320057798320175886595281336136",
+  "20124996762962216725442980738609010303800849578410091356605067053491763969391",
+  "9118593021526896828671519912099489027245924097793322973632351264852174143923",
  "1"
 ],
 "vk_beta_2": [
  [
-   "11031529986141021025408838211017932346992429731488270384177563837022796743627",
-   "16042159910707312759082561183373181639420894978640710177581040523252926273854"
+   "4693952934005375501364248788849686435240706020501681709396105298107971354382",
+   "14346958885444710485362620645446987998958218205939139994511461437152241966681"
  ],
  [
-   "20112698439519222240302944148895052359035104222313380895334495118294612255131",
-   "19441583024670359810872018179190533814486480928824742448673677460151702019379"
+   "16851772916911573982706166384196538392731905827088356034885868448550849804972",
+   "823612331030938060799959717749043047845343400798220427319188951998582076532"
  ],
  [
   "1",
@@ -37,12 +37,12 @@
 ],
 "vk_delta_2": [
  [
-   "1342791402398183550129987853701397066695422166542200371137242980909975744720",
-   "19885954793721639146517398722913034453263197732511169431324269951156805454588"
+   "16125279975606773676640811113051624654121459921695914044301154938920321009721",
+   "14844345250267029614093295465313288254479124604567709177260777529651293576873"
  ],
  [
-   "16612518449808520746616592899100682320852224744311197908486719118388461103870",
-   "13039435290897389787786546960964558630619663289413586834851804020863949546009"
+   "20349277326920398483890518242229158117668855310237215044647746783223259766294",
+   "19338776107510040969200058390413661029003750817172740054990168933780935479540"
  ],
  [
   "1",
@@ -52,67 +52,67 @@
 "vk_alphabeta_12": [
  [
   [
-    "5151991366823434428398919091000210787450832786814248297320989361921939794156",
-    "15735191313289001022885148627913534790382722933676436876510746491415970766821"
+    "12608968655665301215455851857466367636344427685631271961542642719683786103711",
+    "9849575605876329747382930567422916152871921500826003490242628251047652318086"
   ],
   [
-    "3387907257437913904447588318761906430938415556102110876587455322225272831272",
-    "1998779853452712881084781956683721603875246565720647583735935725110674288056"
+    "6322029441245076030714726551623552073612922718416871603535535085523083939021",
+    "8700115492541474338049149013125102281865518624059015445617546140629435818912"
   ],
   [
-    "14280074182991498185075387990446437410077692353432005297922275464876153151820",
-    "17092408446352310039633488224969232803092763095456307462247653153107223117633"
+    "10674973475340072635573101639867487770811074181475255667220644196793546640210",
+    "2926286967251299230490668407790788696102889214647256022788211245826267484824"
   ]
  ],
  [
   [
-    "4359046709531668109201634396816565829237358165496082832279660960675584351266",
-    "4511888308846208349307186938266411423935335853916317436093178288331845821336"
+    "9660441540778523475944706619139394922744328902833875392144658911530830074820",
+    "19548113127774514328631808547691096362144426239827206966690021428110281506546"
   ],
   [
-    "11429499807090785857812316277335883295048773373068683863667725283965356423273",
-    "16232274853200678548795010078253506586114563833318973594428907292096178657392"
+    "1870837942477655969123169532603615788122896469891695773961478956740992497097",
+    "12536105729661705698805725105036536744930776470051238187456307227425796690780"
   ],
   [
-    "18068999605870933925311275504102553573815570223888590384919752303726860800970",
-    "17309569111965782732372130116757295842160193489132771344011460471298173784984"
+    "21811903352654147452884857281720047789720483752548991551595462057142824037334",
+    "19021616763967199151052893283384285352200445499680068407023236283004353578353"
   ]
  ]
 ],
 "IC": [
  [
-   "15907620619058468322652190166474219459106695372760190199814463422116003944385",
-   "15752765921940703867480319151728055971288798043197983667046402260506178676501",
+   "5645604624116784480262312750033349186912223090668673154853165165224747369512",
+   "5656337658385597582701340925622307146226708710361427687425735166776477641124",
   "1"
  ],
  [
-   "12004081423498474638814710157503496372594892372197913146719480190853290407272",
-   "17759993271504587923309435837545182941635937261719294500288793819648071033469",
+   "8216930132302312821663833393171053651364962198587857550991047765311607638330",
+   "19934865864074163318938688021560358348660709566570123384268356491416384822148",
   "1"
  ],
  [
-   "878120019311612655450010384994897394984265086410869146105626241891073100410",
-   "17631186298933191134732246976686754514124819009836710500647157641262968661294",
+   "11046959016591768534564223076484566731774575511709349452804727872479525392631",
+   "9401797690410912638766111919371607085248054251975419812613989999345815833269",
   "1"
  ],
  [
-   "14710016919630225372037989028011020715054625029990218653012745498368446893907",
-   "2581293501049347486538806758240731445964309309490885835380825245889909387041",
+   "13216594148914395028254776738842380005944817065680915990743659996725367876414",
+   "11541283802841111343960351782994043892623551381569479006737253908665900144087",
   "1"
  ],
  [
-   "766327921864693063481261933507417084013182964450768912480746815296334678928",
-   "18104222034822903557262264275808261481286672296559910954337205847153944954509",
+   "6957074593219251760608960101283708711892008557897337713430173510328411964571",
+   "21673833055087220750009279957462375662312260098732685145862504142183400549467",
   "1"
  ],
  [
-   "8877686447180479408315100041907552504213694351585462004774320248566787828012",
-   "15836202093850379814510995758762098170932781831518064786308541653541698178373",
+   "20795071270535109448604057031148356571036039566776607847840379441839742201050",
+   "21654952744643117202636583766828639581880877547772465264383291983528268115687",
   "1"
  ],
  [
-   "19567388833538990982537236781224917793757180861915757860561618079730704818311",
-   "3535132838196675082818592669173684593624477421910576112671761297886253127546",
+   "19143058772755719660075704757531991493801758701561469885274062297246796623789",
+   "3996020163280925980543600106196205910576345230982361007978823537163123181007",
   "1"
  ]
 ]
--- a/rln/resources/tree_height_20/rln.wasm
+++ b/rln/resources/tree_height_20/rln.wasm
--- a/rln/resources/tree_height_20/rln_final.zkey
+++ b/rln/resources/tree_height_20/rln_final.zkey
--- a/rln/resources/tree_height_20/verification_key.json
+++ b/rln/resources/tree_height_20/verification_key.json
@@ -3,18 +3,18 @@
 "curve": "bn128",
 "nPublic": 6,
 "vk_alpha_1": [
-  "1805378556360488226980822394597799963030511477964155500103132920745199284516",
-  "11990395240534218699464972016456017378439762088320057798320175886595281336136",
+  "20124996762962216725442980738609010303800849578410091356605067053491763969391",
+  "9118593021526896828671519912099489027245924097793322973632351264852174143923",
  "1"
 ],
 "vk_beta_2": [
  [
-   "11031529986141021025408838211017932346992429731488270384177563837022796743627",
-   "16042159910707312759082561183373181639420894978640710177581040523252926273854"
+   "4693952934005375501364248788849686435240706020501681709396105298107971354382",
+   "14346958885444710485362620645446987998958218205939139994511461437152241966681"
  ],
  [
-   "20112698439519222240302944148895052359035104222313380895334495118294612255131",
-   "19441583024670359810872018179190533814486480928824742448673677460151702019379"
+   "16851772916911573982706166384196538392731905827088356034885868448550849804972",
+   "823612331030938060799959717749043047845343400798220427319188951998582076532"
  ],
  [
   "1",
@@ -37,12 +37,12 @@
 ],
 "vk_delta_2": [
  [
-   "1948496782571164085469528023647105317580208688174386157591917599801657832035",
-   "20445814069256658101339037520922621162739470138213615104905368409238414511981"
+   "8353516066399360694538747105302262515182301251524941126222712285088022964076",
+   "9329524012539638256356482961742014315122377605267454801030953882967973561832"
  ],
  [
-   "10024680869920840984813249386422727863826862577760330492647062850849851925340",
-   "10512156247842686783409460795717734694774542185222602679117887145206209285142"
+   "16805391589556134376869247619848130874761233086443465978238468412168162326401",
+   "10111259694977636294287802909665108497237922060047080343914303287629927847739"
  ],
  [
   "1",
@@ -52,67 +52,67 @@
 "vk_alphabeta_12": [
  [
   [
-    "5151991366823434428398919091000210787450832786814248297320989361921939794156",
-    "15735191313289001022885148627913534790382722933676436876510746491415970766821"
+    "12608968655665301215455851857466367636344427685631271961542642719683786103711",
+    "9849575605876329747382930567422916152871921500826003490242628251047652318086"
   ],
   [
-    "3387907257437913904447588318761906430938415556102110876587455322225272831272",
-    "1998779853452712881084781956683721603875246565720647583735935725110674288056"
+    "6322029441245076030714726551623552073612922718416871603535535085523083939021",
+    "8700115492541474338049149013125102281865518624059015445617546140629435818912"
   ],
   [
-    "14280074182991498185075387990446437410077692353432005297922275464876153151820",
-    "17092408446352310039633488224969232803092763095456307462247653153107223117633"
+    "10674973475340072635573101639867487770811074181475255667220644196793546640210",
+    "2926286967251299230490668407790788696102889214647256022788211245826267484824"
   ]
  ],
  [
   [
-    "4359046709531668109201634396816565829237358165496082832279660960675584351266",
-    "4511888308846208349307186938266411423935335853916317436093178288331845821336"
+    "9660441540778523475944706619139394922744328902833875392144658911530830074820",
+    "19548113127774514328631808547691096362144426239827206966690021428110281506546"
   ],
   [
-    "11429499807090785857812316277335883295048773373068683863667725283965356423273",
-    "16232274853200678548795010078253506586114563833318973594428907292096178657392"
+    "1870837942477655969123169532603615788122896469891695773961478956740992497097",
+    "12536105729661705698805725105036536744930776470051238187456307227425796690780"
   ],
   [
-    "18068999605870933925311275504102553573815570223888590384919752303726860800970",
-    "17309569111965782732372130116757295842160193489132771344011460471298173784984"
+    "21811903352654147452884857281720047789720483752548991551595462057142824037334",
+    "19021616763967199151052893283384285352200445499680068407023236283004353578353"
   ]
  ]
 ],
 "IC": [
  [
-   "18693301901828818437917730940595978397160482710354161265484535387752523310572",
-   "17985273354976640088538673802000794244421192643855111089693820179790551470769",
+   "11992897507809711711025355300535923222599547639134311050809253678876341466909",
+   "17181525095924075896332561978747020491074338784673526378866503154966799128110",
   "1"
  ],
  [
-   "21164641723988537620541455173278629777250883365474191521194244273980931825942",
-   "998385854410718613441067082771678946155853656328717326195057262123686425518",
+   "17018665030246167677911144513385572506766200776123272044534328594850561667818",
+   "18601114175490465275436712413925513066546725461375425769709566180981674884464",
   "1"
  ],
  [
-   "21666968581672145768705229094968410656430989593283335488162701230986314747515",
-   "17996457608540683483506630273632100555125353447506062045735279661096094677264",
+   "18799470100699658367834559797874857804183288553462108031963980039244731716542",
+   "13064227487174191981628537974951887429496059857753101852163607049188825592007",
   "1"
  ],
  [
-   "20137761979695192602424300886442379728165712610493092740175904438282083668117",
-   "19184814924890679891263780109959113289320127263583260218200636509492157834679",
+   "17432501889058124609368103715904104425610382063762621017593209214189134571156",
+   "13406815149699834788256141097399354592751313348962590382887503595131085938635",
   "1"
  ],
  [
-   "10943171273393803842589314082509655332154393332394322726077270895078286354146",
-   "10872472035685319847811233167729172672344935625121511932198535224727331126439",
+   "10320964835612716439094703312987075811498239445882526576970512041988148264481",
+   "9024164961646353611176283204118089412001502110138072989569118393359029324867",
   "1"
  ],
  [
-   "13049169779481227658517545034348883391527506091990880778783387628208561946597",
-   "10083689369261379027228809473568899816311684698866922944902456565434209079955",
+   "718355081067365548229685160476620267257521491773976402837645005858953849298",
+   "14635482993933988261008156660773180150752190597753512086153001683711587601974",
   "1"
  ],
  [
-   "19633516378466409167014413361365552102431118630694133723053441455184566611083",
-   "8059525100726933978719058611146131904598011633549012007359165766216730722269",
+   "11777720285956632126519898515392071627539405001940313098390150593689568177535",
+   "8483603647274280691250972408211651407952870456587066148445913156086740744515",
   "1"
  ]
 ]
--- a/rln/src/circuit.rs
+++ b/rln/src/circuit.rs
@@ -4,21 +4,29 @@ use ark_bn254::{
    Bn254, Fq as ArkFq, Fq2 as ArkFq2, Fr as ArkFr, G1Affine as ArkG1Affine,
    G1Projective as ArkG1Projective, G2Affine as ArkG2Affine, G2Projective as ArkG2Projective,
 };
-use ark_circom::{read_zkey, WitnessCalculator};
+use ark_circom::read_zkey;
 use ark_groth16::{ProvingKey, VerifyingKey};
 use ark_relations::r1cs::ConstraintMatrices;
+use cfg_if::cfg_if;
+use color_eyre::{Report, Result};
 use num_bigint::BigUint;
-use once_cell::sync::OnceCell;
 use serde_json::Value;
-use std::fs::File;
-use std::io::{Cursor, Error, ErrorKind, Result};
+use std::io::Cursor;
 use std::path::Path;
 use std::str::FromStr;
-use std::sync::Mutex;
-use wasmer::{Module, Store};
+
+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};
+    }
+}

 const ZKEY_FILENAME: &str = "rln_final.zkey";
-const VK_FILENAME: &str = "verifying_key.json";
+const VK_FILENAME: &str = "verification_key.json";
 const WASM_FILENAME: &str = "rln.wasm";

 // These parameters are used for tests
@@ -26,11 +34,11 @@ const WASM_FILENAME: &str = "rln.wasm";
 // Changing these parameters to other values than these defaults will cause zkSNARK proof verification to fail
 pub const TEST_PARAMETERS_INDEX: usize = 2;
 pub const TEST_TREE_HEIGHT: usize = [15, 19, 20][TEST_PARAMETERS_INDEX];
-pub const TEST_RESOURCES_FOLDER: &str = [
-    "./resources/tree_height_15/",
-    "./resources/tree_height_19/",
-    "./resources/tree_height_20/",
-][TEST_PARAMETERS_INDEX];
+pub const TEST_RESOURCES_FOLDER: &str =
+    ["tree_height_15", "tree_height_19", "tree_height_20"][TEST_PARAMETERS_INDEX];
+
+#[cfg(not(target_arch = "wasm32"))]
+static RESOURCES_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/resources");

 // 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
@@ -50,21 +58,22 @@ pub fn zkey_from_raw(zkey_data: &Vec<u8>) -> Result<(ProvingKey<Curve>, Constrai
        let proving_key_and_matrices = read_zkey(&mut c)?;
        Ok(proving_key_and_matrices)
    } else {
-        Err(Error::new(ErrorKind::NotFound, "No proving key found!"))
+        Err(Report::msg("No proving key found!"))
    }
 }

 // Loads the proving key
+#[cfg(not(target_arch = "wasm32"))]
 pub fn zkey_from_folder(
    resources_folder: &str,
 ) -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
-    let zkey_path = format!("{resources_folder}{ZKEY_FILENAME}");
-    if Path::new(&zkey_path).exists() {
-        let mut file = File::open(&zkey_path)?;
-        let proving_key_and_matrices = read_zkey(&mut file)?;
+    let zkey = RESOURCES_DIR.get_file(Path::new(resources_folder).join(ZKEY_FILENAME));
+    if let Some(zkey) = zkey {
+        let mut c = Cursor::new(zkey.contents());
+        let proving_key_and_matrices = read_zkey(&mut c)?;
        Ok(proving_key_and_matrices)
    } else {
-        Err(Error::new(ErrorKind::NotFound, "No proving key found!"))
+        Err(Report::msg("No proving key found!"))
    }
 }

@@ -73,167 +82,187 @@ pub fn vk_from_raw(vk_data: &Vec<u8>, zkey_data: &Vec<u8>) -> Result<VerifyingKe
    let verifying_key: VerifyingKey<Curve>;

    if !vk_data.is_empty() {
-        verifying_key = vk_from_vector(vk_data);
+        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(Error::new(
-            ErrorKind::NotFound,
-            "No proving/verification key found!",
-        ))
+        Err(Report::msg("No proving/verification key found!"))
    }
 }

 // Loads the verification key
+#[cfg(not(target_arch = "wasm32"))]
 pub fn vk_from_folder(resources_folder: &str) -> Result<VerifyingKey<Curve>> {
-    let vk_path = format!("{resources_folder}{VK_FILENAME}");
-    let zkey_path = format!("{resources_folder}{ZKEY_FILENAME}");
+    let vk = RESOURCES_DIR.get_file(Path::new(resources_folder).join(VK_FILENAME));
+    let zkey = RESOURCES_DIR.get_file(Path::new(resources_folder).join(ZKEY_FILENAME));

    let verifying_key: VerifyingKey<Curve>;
-
-    if Path::new(&vk_path).exists() {
-        verifying_key = vk_from_json(&vk_path);
+    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 Path::new(&zkey_path).exists() {
+    } else if let Some(_zkey) = zkey {
        let (proving_key, _matrices) = zkey_from_folder(resources_folder)?;
        verifying_key = proving_key.vk;
        Ok(verifying_key)
    } else {
-        Err(Error::new(
-            ErrorKind::NotFound,
-            "No proving/verification key found!",
-        ))
+        Err(Report::msg("No proving/verification key found!"))
    }
 }

+#[cfg(not(target_arch = "wasm32"))]
 static WITNESS_CALCULATOR: OnceCell<Mutex<WitnessCalculator>> = OnceCell::new();

 // Initializes the witness calculator using a bytes vector
-pub fn circom_from_raw(wasm_buffer: Vec<u8>) -> &'static Mutex<WitnessCalculator> {
-    WITNESS_CALCULATOR.get_or_init(|| {
+#[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).unwrap();
-        let result =
-            WitnessCalculator::from_module(module).expect("Failed to create witness calculator");
-        Mutex::new(result)
+        let module = Module::new(&store, wasm_buffer)?;
+        let result = WitnessCalculator::from_module(module)?;
+        Ok::<Mutex<WitnessCalculator>, Report>(Mutex::new(result))
    })
 }

 // Initializes the witness calculator
-pub fn circom_from_folder(resources_folder: &str) -> &'static Mutex<WitnessCalculator> {
+#[cfg(not(target_arch = "wasm32"))]
+pub fn circom_from_folder(resources_folder: &str) -> Result<&'static Mutex<WitnessCalculator>> {
    // We read the wasm file
-    let wasm_path = format!("{resources_folder}{WASM_FILENAME}");
-    let wasm_buffer = std::fs::read(&wasm_path).unwrap();
-    circom_from_raw(wasm_buffer)
+    let wasm = RESOURCES_DIR.get_file(Path::new(resources_folder).join(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!"))
+    }
 }

 // 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) -> Fq {
-    Fq::try_from(BigUint::from_str(s).unwrap()).unwrap()
+fn fq_from_str(s: &str) -> Result<Fq> {
+    Ok(Fq::try_from(BigUint::from_str(s)?)?)
 }

 // Extracts the element in G1 corresponding to its JSON serialization
-fn json_to_g1(json: &Value, key: &str) -> G1Affine {
+fn json_to_g1(json: &Value, key: &str) -> Result<G1Affine> {
    let els: Vec<String> = json
        .get(key)
-        .unwrap()
+        .ok_or(Report::msg("no json value"))?
        .as_array()
-        .unwrap()
+        .ok_or(Report::msg("value not an array"))?
        .iter()
-        .map(|i| i.as_str().unwrap().to_string())
-        .collect();
-    G1Affine::from(G1Projective::new(
-        fq_from_str(&els[0]),
-        fq_from_str(&els[1]),
-        fq_from_str(&els[2]),
-    ))
+        .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) -> Vec<G1Affine> {
+fn json_to_g1_vec(json: &Value, key: &str) -> Result<Vec<G1Affine>> {
    let els: Vec<Vec<String>> = json
        .get(key)
-        .unwrap()
+        .ok_or(Report::msg("no json value"))?
        .as_array()
-        .unwrap()
+        .ok_or(Report::msg("value not an array"))?
        .iter()
        .map(|i| {
            i.as_array()
-                .unwrap()
-                .iter()
-                .map(|x| x.as_str().unwrap().to_string())
-                .collect::<Vec<String>>()
+                .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();
+        .collect::<Result<Vec<Vec<String>>>>()?;

-    els.iter()
-        .map(|coords| {
-            G1Affine::from(G1Projective::new(
-                fq_from_str(&coords[0]),
-                fq_from_str(&coords[1]),
-                fq_from_str(&coords[2]),
-            ))
-        })
-        .collect()
+    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) -> G2Affine {
+fn json_to_g2(json: &Value, key: &str) -> Result<G2Affine> {
    let els: Vec<Vec<String>> = json
        .get(key)
-        .unwrap()
+        .ok_or(Report::msg("no json value"))?
        .as_array()
-        .unwrap()
+        .ok_or(Report::msg("value not an array"))?
        .iter()
        .map(|i| {
            i.as_array()
-                .unwrap()
-                .iter()
-                .map(|x| x.as_str().unwrap().to_string())
-                .collect::<Vec<String>>()
+                .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();
+        .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]));
-    G2Affine::from(G2Projective::new(x, y, z))
+    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) -> VerifyingKey<Curve> {
-    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"),
-    }
+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_path: &str) -> VerifyingKey<Curve> {
-    let json = std::fs::read_to_string(vk_path).unwrap();
-    let json: Value = serde_json::from_str(&json).unwrap();
-
+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]) -> VerifyingKey<Curve> {
-    let json = String::from_utf8(vk.to_vec()).expect("Found invalid UTF-8");
-    let json: Value = serde_json::from_str(&json).unwrap();
+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)
 }

 // Checks verification key to be correct with respect to proving key
-pub fn check_vk_from_zkey(resources_folder: &str, verifying_key: VerifyingKey<Curve>) {
-    let (proving_key, _matrices) = zkey_from_folder(resources_folder).unwrap();
-    assert_eq!(proving_key.vk, verifying_key);
+#[cfg(not(target_arch = "wasm32"))]
+pub fn check_vk_from_zkey(
+    resources_folder: &str,
+    verifying_key: VerifyingKey<Curve>,
+) -> Result<()> {
+    let (proving_key, _matrices) = zkey_from_folder(resources_folder)?;
+    if proving_key.vk == verifying_key {
+        Ok(())
+    } else {
+        Err(Report::msg("verifying_keys are not equal"))
+    }
 }
--- a/rln/src/ffi.rs
+++ b/rln/src/ffi.rs
@@ -2,12 +2,142 @@

 use std::slice;

-use crate::public::RLN;
+use crate::public::{hash as public_hash, poseidon_hash as public_poseidon_hash, RLN};
+
+// Macro to call methods with arbitrary amount of arguments,
+// First argument to the macro is context,
+// second is the actual method on `RLN`
+// rest are all other arguments to the method
+macro_rules! call {
+    ($instance:expr, $method:ident $(, $arg:expr)*) => {
+        {
+            let new_instance: &mut RLN = $instance.process();
+            new_instance.$method($($arg.process()),*).is_ok()
+        }
+    }
+}
+
+// Macro to call methods with arbitrary amount of arguments,
+// which have the last argument is output buffer pointer
+// First argument to the macro is context,
+// second is the actual method on `RLN`
+// third is the aforementioned output buffer argument
+// rest are all other arguments to the method
+macro_rules! call_with_output_arg {
+    // this variant is needed for the case when
+    // there are zero other arguments
+    ($instance:expr, $method:ident, $output_arg:expr) => {
+        {
+            let mut output_data: Vec<u8> = Vec::new();
+            let new_instance = $instance.process();
+            if new_instance.$method(&mut output_data).is_ok() {
+                unsafe { *$output_arg = Buffer::from(&output_data[..]) };
+                std::mem::forget(output_data);
+                true
+            } else {
+                std::mem::forget(output_data);
+                false
+            }
+        }
+    };
+    ($instance:expr, $method:ident, $output_arg:expr, $( $arg:expr ),* ) => {
+        {
+            let mut output_data: Vec<u8> = Vec::new();
+            let new_instance = $instance.process();
+            if new_instance.$method($($arg.process()),*, &mut output_data).is_ok() {
+                unsafe { *$output_arg = Buffer::from(&output_data[..]) };
+                std::mem::forget(output_data);
+                true
+            } else {
+                std::mem::forget(output_data);
+                false
+            }
+        }
+    };
+
+}
+
+// Macro to call methods with arbitrary amount of arguments,
+// which are not implemented in a ctx RLN object
+// First argument is the method to call
+// Second argument is the output buffer argument
+// The remaining arguments are all other inputs to the method
+macro_rules! no_ctx_call_with_output_arg {
+    ($method:ident, $output_arg:expr, $( $arg:expr ),* ) => {
+        {
+            let mut output_data: Vec<u8> = Vec::new();
+            if $method($($arg.process()),*, &mut output_data).is_ok() {
+                unsafe { *$output_arg = Buffer::from(&output_data[..]) };
+                std::mem::forget(output_data);
+                true
+            } else {
+                std::mem::forget(output_data);
+                false
+            }
+        }
+    }
+}
+
+// Macro to call methods with arbitrary amount of arguments,
+// which have the last argument as bool
+// First argument to the macro is context,
+// second is the actual method on `RLN`
+// third is the aforementioned bool argument
+// rest are all other arguments to the method
+macro_rules! call_with_bool_arg {
+    ($instance:expr, $method:ident, $bool_arg:expr, $( $arg:expr ),* ) => {
+        {
+            let new_instance = $instance.process();
+            if match new_instance.$method($($arg.process()),*,) {
+                Ok(verified) => verified,
+                Err(_) => return false,
+            } {
+                unsafe { *$bool_arg = true };
+            } else {
+                unsafe { *$bool_arg = false };
+            };
+            true
+        }
+    }
+}
+
+trait ProcessArg {
+    type ReturnType;
+    fn process(self) -> Self::ReturnType;
+}
+
+impl ProcessArg for usize {
+    type ReturnType = usize;
+    fn process(self) -> Self::ReturnType {
+        self
+    }
+}
+
+impl ProcessArg for *const Buffer {
+    type ReturnType = &'static [u8];
+    fn process(self) -> Self::ReturnType {
+        <&[u8]>::from(unsafe { &*self })
+    }
+}
+
+impl<'a> ProcessArg for *const RLN<'a> {
+    type ReturnType = &'a RLN<'a>;
+    fn process(self) -> Self::ReturnType {
+        unsafe { &*self }
+    }
+}
+
+impl<'a> ProcessArg for *mut RLN<'a> {
+    type ReturnType = &'a mut RLN<'a>;
+    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
+/// <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
+/// Also heavily inspired by <https://github.com/kilic/rln/blob/master/src/ffi.rs>

 #[repr(C)]
 #[derive(Clone, Debug, PartialEq)]
@@ -19,7 +149,7 @@ pub struct Buffer {
 impl From<&[u8]> for Buffer {
    fn from(src: &[u8]) -> Self {
        Self {
-            ptr: &src[0] as *const u8,
+            ptr: src.as_ptr(),
            len: src.len(),
        }
    }
@@ -41,10 +171,12 @@ impl<'a> From<&Buffer> for &'a [u8] {
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn new(tree_height: usize, input_buffer: *const Buffer, ctx: *mut *mut RLN) -> bool {
-    let input_data = <&[u8]>::from(unsafe { &*input_buffer });
-    let rln = RLN::new(tree_height, input_data);
-    unsafe { *ctx = Box::into_raw(Box::new(rln)) };
-    true
+    if let Ok(rln) = RLN::new(tree_height, input_buffer.process()) {
+        unsafe { *ctx = Box::into_raw(Box::new(rln)) };
+        true
+    } else {
+        false
+    }
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
@@ -56,12 +188,17 @@ pub extern "C" fn new_with_params(
    vk_buffer: *const Buffer,
    ctx: *mut *mut RLN,
 ) -> bool {
-    let circom_data = <&[u8]>::from(unsafe { &*circom_buffer });
-    let zkey_data = <&[u8]>::from(unsafe { &*zkey_buffer });
-    let vk_data = <&[u8]>::from(unsafe { &*vk_buffer });
-    let rln = RLN::new_with_params(tree_height, circom_data, zkey_data, vk_data);
-    unsafe { *ctx = Box::into_raw(Box::new(rln)) };
-    true
+    if let Ok(rln) = RLN::new_with_params(
+        tree_height,
+        circom_buffer.process().to_vec(),
+        zkey_buffer.process().to_vec(),
+        vk_buffer.process().to_vec(),
+    ) {
+        unsafe { *ctx = Box::into_raw(Box::new(rln)) };
+        true
+    } else {
+        false
+    }
 }

 ////////////////////////////////////////////////////////
@@ -70,69 +207,53 @@ pub extern "C" fn new_with_params(
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn set_tree(ctx: *mut RLN, tree_height: usize) -> bool {
-    let rln = unsafe { &mut *ctx };
-    rln.set_tree(tree_height).is_ok()
+    call!(ctx, set_tree, tree_height)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn delete_leaf(ctx: *mut RLN, index: usize) -> bool {
-    let rln = unsafe { &mut *ctx };
-    rln.delete_leaf(index).is_ok()
+    call!(ctx, delete_leaf, index)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn set_leaf(ctx: *mut RLN, index: usize, input_buffer: *const Buffer) -> bool {
-    let rln = unsafe { &mut *ctx };
-    let input_data = <&[u8]>::from(unsafe { &*input_buffer });
-    rln.set_leaf(index, input_data).is_ok()
+    call!(ctx, set_leaf, index, input_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn set_next_leaf(ctx: *mut RLN, input_buffer: *const Buffer) -> bool {
-    let rln = unsafe { &mut *ctx };
-    let input_data = <&[u8]>::from(unsafe { &*input_buffer });
-    rln.set_next_leaf(input_data).is_ok()
+    call!(ctx, set_next_leaf, input_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
-pub extern "C" fn set_leaves(ctx: *mut RLN, input_buffer: *const Buffer) -> bool {
-    let rln = unsafe { &mut *ctx };
-    let input_data = <&[u8]>::from(unsafe { &*input_buffer });
-    rln.set_leaves(input_data).is_ok()
+pub extern "C" fn set_leaves_from(
+    ctx: *mut RLN,
+    index: usize,
+    input_buffer: *const Buffer,
+) -> bool {
+    call!(ctx, set_leaves_from, index, input_buffer)
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+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]
 pub extern "C" fn get_root(ctx: *const RLN, output_buffer: *mut Buffer) -> bool {
-    let rln = unsafe { &*ctx };
-    let mut output_data: Vec<u8> = Vec::new();
-    if rln.get_root(&mut output_data).is_ok() {
-        unsafe { *output_buffer = Buffer::from(&output_data[..]) };
-        std::mem::forget(output_data);
-        true
-    } else {
-        std::mem::forget(output_data);
-        false
-    }
+    call_with_output_arg!(ctx, get_root, output_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn get_proof(ctx: *const RLN, index: usize, output_buffer: *mut Buffer) -> bool {
-    let rln = unsafe { &*ctx };
-    let mut output_data: Vec<u8> = Vec::new();
-    if rln.get_proof(index, &mut output_data).is_ok() {
-        unsafe { *output_buffer = Buffer::from(&output_data[..]) };
-        std::mem::forget(output_data);
-        true
-    } else {
-        std::mem::forget(output_data);
-        false
-    }
+    call_with_output_arg!(ctx, get_proof, output_buffer, index)
 }

 ////////////////////////////////////////////////////////
@@ -145,18 +266,7 @@ pub extern "C" fn prove(
    input_buffer: *const Buffer,
    output_buffer: *mut Buffer,
 ) -> bool {
-    let rln = unsafe { &mut *ctx };
-    let input_data = <&[u8]>::from(unsafe { &*input_buffer });
-    let mut output_data: Vec<u8> = Vec::new();
-
-    if rln.prove(input_data, &mut output_data).is_ok() {
-        unsafe { *output_buffer = Buffer::from(&output_data[..]) };
-        std::mem::forget(output_data);
-        true
-    } else {
-        std::mem::forget(output_data);
-        false
-    }
+    call_with_output_arg!(ctx, prove, output_buffer, input_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
@@ -166,17 +276,7 @@ pub extern "C" fn verify(
    proof_buffer: *const Buffer,
    proof_is_valid_ptr: *mut bool,
 ) -> bool {
-    let rln = unsafe { &*ctx };
-    let proof_data = <&[u8]>::from(unsafe { &*proof_buffer });
-    if match rln.verify(proof_data) {
-        Ok(verified) => verified,
-        Err(_) => return false,
-    } {
-        unsafe { *proof_is_valid_ptr = true };
-    } else {
-        unsafe { *proof_is_valid_ptr = false };
-    };
-    true
+    call_with_bool_arg!(ctx, verify, proof_is_valid_ptr, proof_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
@@ -186,18 +286,7 @@ pub extern "C" fn generate_rln_proof(
    input_buffer: *const Buffer,
    output_buffer: *mut Buffer,
 ) -> bool {
-    let rln = unsafe { &mut *ctx };
-    let input_data = <&[u8]>::from(unsafe { &*input_buffer });
-    let mut output_data: Vec<u8> = Vec::new();
-
-    if rln.generate_rln_proof(input_data, &mut output_data).is_ok() {
-        unsafe { *output_buffer = Buffer::from(&output_data[..]) };
-        std::mem::forget(output_data);
-        true
-    } else {
-        std::mem::forget(output_data);
-        false
-    }
+    call_with_output_arg!(ctx, generate_rln_proof, output_buffer, input_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
@@ -207,17 +296,24 @@ pub extern "C" fn verify_rln_proof(
    proof_buffer: *const Buffer,
    proof_is_valid_ptr: *mut bool,
 ) -> bool {
-    let rln = unsafe { &*ctx };
-    let proof_data = <&[u8]>::from(unsafe { &*proof_buffer });
-    if match rln.verify_rln_proof(proof_data) {
-        Ok(verified) => verified,
-        Err(_) => return false,
-    } {
-        unsafe { *proof_is_valid_ptr = true };
-    } else {
-        unsafe { *proof_is_valid_ptr = false };
-    };
-    true
+    call_with_bool_arg!(ctx, verify_rln_proof, proof_is_valid_ptr, proof_buffer)
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn verify_with_roots(
+    ctx: *const RLN,
+    proof_buffer: *const Buffer,
+    roots_buffer: *const Buffer,
+    proof_is_valid_ptr: *mut bool,
+) -> bool {
+    call_with_bool_arg!(
+        ctx,
+        verify_with_roots,
+        proof_is_valid_ptr,
+        proof_buffer,
+        roots_buffer
+    )
 }

 ////////////////////////////////////////////////////////
@@ -226,561 +322,60 @@ pub extern "C" fn verify_rln_proof(
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn key_gen(ctx: *const RLN, output_buffer: *mut Buffer) -> bool {
-    let rln = unsafe { &*ctx };
-    let mut output_data: Vec<u8> = Vec::new();
-    if rln.key_gen(&mut output_data).is_ok() {
-        unsafe { *output_buffer = Buffer::from(&output_data[..]) };
-        std::mem::forget(output_data);
-        true
-    } else {
-        std::mem::forget(output_data);
-        false
-    }
+    call_with_output_arg!(ctx, key_gen, output_buffer)
 }

 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
-pub extern "C" fn hash(
-    ctx: *mut RLN,
+pub extern "C" fn seeded_key_gen(
+    ctx: *const RLN,
    input_buffer: *const Buffer,
    output_buffer: *mut Buffer,
 ) -> bool {
-    let rln = unsafe { &mut *ctx };
-    let input_data = <&[u8]>::from(unsafe { &*input_buffer });
-    let mut output_data: Vec<u8> = Vec::new();
-
-    if rln.hash(input_data, &mut output_data).is_ok() {
-        unsafe { *output_buffer = Buffer::from(&output_data[..]) };
-        std::mem::forget(output_data);
-        true
-    } else {
-        std::mem::forget(output_data);
-        false
-    }
+    call_with_output_arg!(ctx, seeded_key_gen, output_buffer, input_buffer)
 }

-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::circuit::*;
-    use crate::poseidon_hash::poseidon_hash;
-    use crate::protocol::*;
-    use crate::utils::*;
-    use ark_std::{rand::thread_rng, UniformRand};
-    use rand::Rng;
-    use std::fs::File;
-    use std::io::Read;
-    use std::mem::MaybeUninit;
-    use std::time::{Duration, Instant};
-
-    #[test]
-    // We test merkle batch Merkle tree additions
-    fn test_merkle_operations_ffi() {
-        let tree_height = TEST_TREE_HEIGHT;
-        let no_of_leaves = 256;
-
-        // We generate a vector of random leaves
-        let mut leaves: Vec<Fr> = Vec::new();
-        let mut rng = thread_rng();
-        for _ in 0..no_of_leaves {
-            leaves.push(Fr::rand(&mut rng));
-        }
-
-        // We create a RLN instance
-        let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
-        let input_buffer = &Buffer::from(TEST_RESOURCES_FOLDER.as_bytes());
-        let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr());
-        assert!(success, "RLN object creation failed");
-        let rln_pointer = unsafe { &mut *rln_pointer.assume_init() };
-
-        // We first add leaves one by one specifying the index
-        for (i, leaf) in leaves.iter().enumerate() {
-            // We prepare id_commitment and we set the leaf at provided index
-            let leaf_ser = fr_to_bytes_le(&leaf);
-            let input_buffer = &Buffer::from(leaf_ser.as_ref());
-            let success = set_leaf(rln_pointer, i, input_buffer);
-            assert!(success, "set leaf call failed");
-        }
-
-        // We get the root of the tree obtained adding one leaf per time
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_root(rln_pointer, output_buffer.as_mut_ptr());
-        assert!(success, "get root call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        let result_data = <&[u8]>::from(&output_buffer).to_vec();
-        let (root_single, _) = bytes_le_to_fr(&result_data);
-
-        // We reset the tree to default
-        let success = set_tree(rln_pointer, tree_height);
-        assert!(success, "set tree call failed");
-
-        // We add leaves one by one using the internal index (new leaves goes in next available position)
-        for leaf in &leaves {
-            let leaf_ser = fr_to_bytes_le(&leaf);
-            let input_buffer = &Buffer::from(leaf_ser.as_ref());
-            let success = set_next_leaf(rln_pointer, input_buffer);
-            assert!(success, "set next leaf call failed");
-        }
-
-        // We get the root of the tree obtained adding leaves using the internal index
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_root(rln_pointer, output_buffer.as_mut_ptr());
-        assert!(success, "get root call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        let result_data = <&[u8]>::from(&output_buffer).to_vec();
-        let (root_next, _) = bytes_le_to_fr(&result_data);
-
-        // We check if roots are the same
-        assert_eq!(root_single, root_next);
-
-        // We reset the tree to default
-        let success = set_tree(rln_pointer, tree_height);
-        assert!(success, "set tree call failed");
-
-        // We add leaves in a batch into the tree
-        let leaves_ser = vec_fr_to_bytes_le(&leaves);
-        let input_buffer = &Buffer::from(leaves_ser.as_ref());
-        let success = set_leaves(rln_pointer, input_buffer);
-        assert!(success, "set leaves call failed");
-
-        // We get the root of the tree obtained adding leaves in batch
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_root(rln_pointer, output_buffer.as_mut_ptr());
-        assert!(success, "get root call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        let result_data = <&[u8]>::from(&output_buffer).to_vec();
-        let (root_batch, _) = bytes_le_to_fr(&result_data);
-
-        // We check if roots are the same
-        assert_eq!(root_single, root_batch);
-
-        // We now delete all leaves set and check if the root corresponds to the empty tree root
-        // delete calls over indexes higher than no_of_leaves are ignored and will not increase self.tree.next_index
-        let delete_range = 2 * no_of_leaves;
-        for i in 0..delete_range {
-            let success = delete_leaf(rln_pointer, i);
-            assert!(success, "delete leaf call failed");
-        }
-
-        // We get the root of the tree obtained deleting all leaves
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_root(rln_pointer, output_buffer.as_mut_ptr());
-        assert!(success, "get root call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        let result_data = <&[u8]>::from(&output_buffer).to_vec();
-        let (root_delete, _) = bytes_le_to_fr(&result_data);
-
-        // We reset the tree to default
-        let success = set_tree(rln_pointer, tree_height);
-        assert!(success, "set tree call failed");
-
-        // We get the root of the empty tree
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_root(rln_pointer, output_buffer.as_mut_ptr());
-        assert!(success, "get root call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        let result_data = <&[u8]>::from(&output_buffer).to_vec();
-        let (root_empty, _) = bytes_le_to_fr(&result_data);
-
-        // We check if roots are the same
-        assert_eq!(root_delete, root_empty);
-    }
-
-    #[test]
-    // This test is similar to the one in lib, but uses only public C API
-    fn test_merkle_proof_ffi() {
-        let tree_height = TEST_TREE_HEIGHT;
-        let leaf_index = 3;
-
-        // We create a RLN instance
-        let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
-        let input_buffer = &Buffer::from(TEST_RESOURCES_FOLDER.as_bytes());
-        let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr());
-        assert!(success, "RLN object creation failed");
-        let rln_pointer = unsafe { &mut *rln_pointer.assume_init() };
-
-        // generate identity
-        let identity_secret = hash_to_field(b"test-merkle-proof");
-        let id_commitment = poseidon_hash(&vec![identity_secret]);
-
-        // We prepare id_commitment and we set the leaf at provided index
-        let leaf_ser = fr_to_bytes_le(&id_commitment);
-        let input_buffer = &Buffer::from(leaf_ser.as_ref());
-        let success = set_leaf(rln_pointer, leaf_index, input_buffer);
-        assert!(success, "set leaf call failed");
-
-        // We obtain the Merkle tree root
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_root(rln_pointer, output_buffer.as_mut_ptr());
-        assert!(success, "get root call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        let result_data = <&[u8]>::from(&output_buffer).to_vec();
-        let (root, _) = bytes_le_to_fr(&result_data);
-
-        // We obtain the Merkle tree root
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_proof(rln_pointer, leaf_index, output_buffer.as_mut_ptr());
-        assert!(success, "get merkle proof call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        let result_data = <&[u8]>::from(&output_buffer).to_vec();
-
-        let (path_elements, read) = bytes_le_to_vec_fr(&result_data);
-        let (identity_path_index, _) = bytes_le_to_vec_u8(&result_data[read..].to_vec());
-
-        // We check correct computation of the path and indexes
-        let mut expected_path_elements = vec![
-            str_to_fr(
-                "0x0000000000000000000000000000000000000000000000000000000000000000",
-                16,
-            ),
-            str_to_fr(
-                "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
-                16,
-            ),
-            str_to_fr(
-                "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
-                16,
-            ),
-            str_to_fr(
-                "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
-                16,
-            ),
-            str_to_fr(
-                "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
-                16,
-            ),
-            str_to_fr(
-                "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
-                16,
-            ),
-            str_to_fr(
-                "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
-                16,
-            ),
-            str_to_fr(
-                "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
-                16,
-            ),
-            str_to_fr(
-                "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
-                16,
-            ),
-            str_to_fr(
-                "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
-                16,
-            ),
-            str_to_fr(
-                "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
-                16,
-            ),
-            str_to_fr(
-                "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
-                16,
-            ),
-            str_to_fr(
-                "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
-                16,
-            ),
-            str_to_fr(
-                "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
-                16,
-            ),
-            str_to_fr(
-                "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
-                16,
-            ),
-        ];
-
-        let mut expected_identity_path_index: Vec<u8> =
-            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-        // We add the remaining elements for the case TEST_TREE_HEIGHT = 19
-        if TEST_TREE_HEIGHT == 19 || TEST_TREE_HEIGHT == 20 {
-            expected_path_elements.append(&mut vec![
-                str_to_fr(
-                    "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
-                    16,
-                ),
-                str_to_fr(
-                    "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
-                    16,
-                ),
-                str_to_fr(
-                    "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
-                    16,
-                ),
-                str_to_fr(
-                    "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
-                    16,
-                ),
-            ]);
-            expected_identity_path_index.append(&mut vec![0, 0, 0, 0]);
-        }
-
-        if TEST_TREE_HEIGHT == 20 {
-            expected_path_elements.append(&mut vec![str_to_fr(
-                "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
-                16,
-            )]);
-            expected_identity_path_index.append(&mut vec![0]);
-        }
-
-        assert_eq!(path_elements, expected_path_elements);
-        assert_eq!(identity_path_index, expected_identity_path_index);
-
-        // We double check that the proof computed from public API is correct
-        let root_from_proof =
-            compute_tree_root(&id_commitment, &path_elements, &identity_path_index, false);
-
-        assert_eq!(root, root_from_proof);
-    }
-
-    #[test]
-    // Benchmarks proof generation and verification
-    fn test_groth16_proofs_performance_ffi() {
-        let tree_height = TEST_TREE_HEIGHT;
-
-        // We create a RLN instance
-        let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
-        let input_buffer = &Buffer::from(TEST_RESOURCES_FOLDER.as_bytes());
-        let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr());
-        assert!(success, "RLN object creation failed");
-        let rln_pointer = unsafe { &mut *rln_pointer.assume_init() };
-
-        // 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(tree_height);
-            let proof_values = proof_values_from_witness(&rln_witness);
-
-            // We prepare id_commitment and we set the leaf at provided index
-            let rln_witness_ser = serialize_witness(&rln_witness);
-            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]
-    // Creating a RLN with raw data should generate same results as using a path to resources
-    fn test_rln_raw_ffi() {
-        let tree_height = TEST_TREE_HEIGHT;
-
-        // We create a RLN instance using a resource folder path
-        let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
-        let input_buffer = &Buffer::from(TEST_RESOURCES_FOLDER.as_bytes());
-        let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr());
-        assert!(success, "RLN object creation failed");
-        let rln_pointer = unsafe { &mut *rln_pointer.assume_init() };
-
-        // We obtain the root from the RLN instance
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_root(rln_pointer, output_buffer.as_mut_ptr());
-        assert!(success, "get root call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        let result_data = <&[u8]>::from(&output_buffer).to_vec();
-        let (root_rln_folder, _) = bytes_le_to_fr(&result_data);
-
-        // Reading the raw data from the files required for instantiating a RLN instance using raw data
-        let circom_path = format!("./resources/tree_height_{TEST_TREE_HEIGHT}/rln.wasm");
-        let mut circom_file = File::open(&circom_path).expect("no file found");
-        let metadata = std::fs::metadata(&circom_path).expect("unable to read metadata");
-        let mut circom_buffer = vec![0; metadata.len() as usize];
-        circom_file
-            .read_exact(&mut circom_buffer)
-            .expect("buffer overflow");
-
-        let zkey_path = format!("./resources/tree_height_{TEST_TREE_HEIGHT}/rln_final.zkey");
-        let mut zkey_file = File::open(&zkey_path).expect("no file found");
-        let metadata = std::fs::metadata(&zkey_path).expect("unable to read metadata");
-        let mut zkey_buffer = vec![0; metadata.len() as usize];
-        zkey_file
-            .read_exact(&mut zkey_buffer)
-            .expect("buffer overflow");
-
-        let vk_path = format!("./resources/tree_height_{TEST_TREE_HEIGHT}/verification_key.json");
-
-        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];
-        vk_file.read_exact(&mut vk_buffer).expect("buffer overflow");
-
-        let circom_data = &Buffer::from(&circom_buffer[..]);
-        let zkey_data = &Buffer::from(&zkey_buffer[..]);
-        let vk_data = &Buffer::from(&vk_buffer[..]);
-
-        // Creating a RLN instance passing the raw data
-        let mut rln_pointer_raw_bytes = MaybeUninit::<*mut RLN>::uninit();
-        let success = new_with_params(
-            tree_height,
-            circom_data,
-            zkey_data,
-            vk_data,
-            rln_pointer_raw_bytes.as_mut_ptr(),
-        );
-        assert!(success, "RLN object creation failed");
-        let rln_pointer2 = unsafe { &mut *rln_pointer_raw_bytes.assume_init() };
-
-        // We obtain the root from the RLN instance containing raw data
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_root(rln_pointer2, output_buffer.as_mut_ptr());
-        assert!(success, "get root call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        let result_data = <&[u8]>::from(&output_buffer).to_vec();
-        let (root_rln_raw, _) = bytes_le_to_fr(&result_data);
-
-        // And compare that the same root was generated
-        assert_eq!(root_rln_folder, root_rln_raw);
-    }
-
-    #[test]
-    // Computes and verifies an RLN ZK proof using FFI APIs
-    fn test_rln_proof_ffi() {
-        let tree_height = TEST_TREE_HEIGHT;
-        let no_of_leaves = 256;
-
-        // We generate a vector of random leaves
-        let mut leaves: Vec<Fr> = Vec::new();
-        let mut rng = thread_rng();
-        for _ in 0..no_of_leaves {
-            leaves.push(Fr::rand(&mut rng));
-        }
-
-        // We create a RLN instance
-        let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
-        let input_buffer = &Buffer::from(TEST_RESOURCES_FOLDER.as_bytes());
-        let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr());
-        assert!(success, "RLN object creation failed");
-        let rln_pointer = unsafe { &mut *rln_pointer.assume_init() };
-
-        // We add leaves in a batch into the tree
-        let leaves_ser = vec_fr_to_bytes_le(&leaves);
-        let input_buffer = &Buffer::from(leaves_ser.as_ref());
-        let success = set_leaves(rln_pointer, input_buffer);
-        assert!(success, "set leaves call failed");
-
-        // We generate a new identity pair
-        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, read) = bytes_le_to_fr(&result_data);
-        let (id_commitment, _) = bytes_le_to_fr(&result_data[read..].to_vec());
-
-        // We set as leaf id_commitment, its index would be equal to no_of_leaves
-        let leaf_ser = fr_to_bytes_le(&id_commitment);
-        let input_buffer = &Buffer::from(leaf_ser.as_ref());
-        let success = set_next_leaf(rln_pointer, input_buffer);
-        assert!(success, "set next leaf call failed");
-
-        let identity_index: u64 = no_of_leaves;
-
-        // We generate a random signal
-        let mut rng = rand::thread_rng();
-        let signal: [u8; 32] = rng.gen();
-        let signal_len = u64::try_from(signal.len()).unwrap();
-
-        // We generate a random epoch
-        let epoch = hash_to_field(b"test-epoch");
-
-        // We prepare input for generate_rln_proof API
-        // input_data is [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
-        let mut serialized: Vec<u8> = Vec::new();
-        serialized.append(&mut fr_to_bytes_le(&identity_secret));
-        serialized.append(&mut identity_index.to_le_bytes().to_vec());
-        serialized.append(&mut fr_to_bytes_le(&epoch));
-        serialized.append(&mut signal_len.to_le_bytes().to_vec());
-        serialized.append(&mut signal.to_vec());
-
-        // We call generate_rln_proof
-        let input_buffer = &Buffer::from(serialized.as_ref());
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = generate_rln_proof(rln_pointer, input_buffer, output_buffer.as_mut_ptr());
-        assert!(success, "set leaves call failed");
-        let output_buffer = unsafe { output_buffer.assume_init() };
-        // result_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ]
-        let mut proof_data = <&[u8]>::from(&output_buffer).to_vec();
-
-        // We prepare input for verify_rln_proof API
-        // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
-        // that is [ proof_data | signal_len<8> | signal<var> ]
-        proof_data.append(&mut signal_len.to_le_bytes().to_vec());
-        proof_data.append(&mut signal.to_vec());
-
-        // We call generate_rln_proof
-        let input_buffer = &Buffer::from(proof_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_rln_proof(rln_pointer, input_buffer, proof_is_valid_ptr);
-        assert!(success, "verify call failed");
-        assert_eq!(proof_is_valid, true);
-    }
-
-    #[test]
-    // Tests hash to field using FFI APIs
-    fn test_hash_to_field_ffi() {
-        let tree_height = TEST_TREE_HEIGHT;
-
-        // We create a RLN instance
-        let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
-        let input_buffer = &Buffer::from(TEST_RESOURCES_FOLDER.as_bytes());
-        let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr());
-        assert!(success, "RLN object creation failed");
-        let rln_pointer = unsafe { &mut *rln_pointer.assume_init() };
-
-        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 = hash(rln_pointer, 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);
-    }
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn extended_key_gen(ctx: *const RLN, output_buffer: *mut Buffer) -> bool {
+    call_with_output_arg!(ctx, extended_key_gen, output_buffer)
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn seeded_extended_key_gen(
+    ctx: *const RLN,
+    input_buffer: *const Buffer,
+    output_buffer: *mut Buffer,
+) -> bool {
+    call_with_output_arg!(ctx, seeded_extended_key_gen, output_buffer, input_buffer)
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn recover_id_secret(
+    ctx: *const RLN,
+    input_proof_buffer_1: *const Buffer,
+    input_proof_buffer_2: *const Buffer,
+    output_buffer: *mut Buffer,
+) -> bool {
+    call_with_output_arg!(
+        ctx,
+        recover_id_secret,
+        output_buffer,
+        input_proof_buffer_1,
+        input_proof_buffer_2
+    )
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn hash(input_buffer: *const Buffer, output_buffer: *mut Buffer) -> bool {
+    no_ctx_call_with_output_arg!(public_hash, output_buffer, input_buffer)
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn poseidon_hash(input_buffer: *const Buffer, output_buffer: *mut Buffer) -> bool {
+    no_ctx_call_with_output_arg!(public_poseidon_hash, output_buffer, input_buffer)
 }
--- a/rln/src/lib.rs
+++ b/rln/src/lib.rs
@@ -1,432 +1,11 @@
 #![allow(dead_code)]

 pub mod circuit;
-pub mod ffi;
-pub mod merkle_tree;
-pub mod poseidon_constants;
 pub mod poseidon_hash;
 pub mod poseidon_tree;
 pub mod protocol;
 pub mod public;
 pub mod utils;

-#[cfg(test)]
-mod test {
-
-    use crate::circuit::{
-        circom_from_folder, vk_from_folder, zkey_from_folder, Fr, TEST_RESOURCES_FOLDER,
-        TEST_TREE_HEIGHT,
-    };
-    use crate::poseidon_hash::poseidon_hash;
-    use crate::poseidon_tree::PoseidonTree;
-    use crate::protocol::*;
-    use crate::utils::str_to_fr;
-
-    // Input generated with https://github.com/oskarth/zk-kit/commit/b6a872f7160c7c14e10a0ea40acab99cbb23c9a8
-    const WITNESS_JSON_15: &str = r#"
-            {
-              "identity_secret": "12825549237505733615964533204745049909430608936689388901883576945030025938736",
-              "path_elements": [
-                "18622655742232062119094611065896226799484910997537830749762961454045300666333",
-                "20590447254980891299813706518821659736846425329007960381537122689749540452732",
-                "7423237065226347324353380772367382631490014989348495481811164164159255474657",
-                "11286972368698509976183087595462810875513684078608517520839298933882497716792",
-                "3607627140608796879659380071776844901612302623152076817094415224584923813162",
-                "19712377064642672829441595136074946683621277828620209496774504837737984048981",
-                "20775607673010627194014556968476266066927294572720319469184847051418138353016",
-                "3396914609616007258851405644437304192397291162432396347162513310381425243293",
-                "21551820661461729022865262380882070649935529853313286572328683688269863701601",
-                "6573136701248752079028194407151022595060682063033565181951145966236778420039",
-                "12413880268183407374852357075976609371175688755676981206018884971008854919922",
-                "14271763308400718165336499097156975241954733520325982997864342600795471836726",
-                "20066985985293572387227381049700832219069292839614107140851619262827735677018",
-                "9394776414966240069580838672673694685292165040808226440647796406499139370960",
-                "11331146992410411304059858900317123658895005918277453009197229807340014528524"
-              ],
-              "identity_path_index": [
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0
-              ],
-              "x": "8143228284048792769012135629627737459844825626241842423967352803501040982",
-              "epoch": "0x0000005b612540fc986b42322f8cb91c2273afad58ed006fdba0c97b4b16b12f",
-              "rln_identifier": "11412926387081627876309792396682864042420635853496105400039841573530884328439"
-            }
-        "#;
-
-    // Input generated with protocol::random_rln_witness
-    const WITNESS_JSON_19: &str = r#"
-            {
-              "identity_secret": "922538810348594125658702672067738675294669207539999802857585668079702330450",
-              "path_elements": [
-                  "16059714054680148404543504061485737353203416489071538960876865983954285286166",
-                  "3041470753871943901334053763207316028823782848445723460227667780327106380356",
-                  "2557297527793326315072058421057853700096944625924483912548759909801348042183",
-                  "6677578602456189582427063963562590713054668181987223110955234085327917303436",
-                  "2250827150965576973906150764756422151438812678308727218463995574869267980301",
-                  "1895457427602709606993445561553433669787657053834360973759981803464906070980",
-                  "11033689991077061346803816826729204895841441316315304395980565540264104346466",
-                  "18588752216879570844240300406954267039026327526134910835334500497981810174976",
-                  "19346480964028499661277403659363466542857230928032088490855656809181891953123",
-                  "21460193770370072688835316363068413651465631481105148051902686770759127189327",
-                  "20906347653364838502964722817589315918082261023317339146393355650507243340078",
-                  "13466599592974387800162739317046838825289754472645703919149409009404541432954",
-                  "9617165663598957201253074168824246164494443748556931540348223968573884172285",
-                  "6936463137584425684797785981770877165377386163416057257854261010817156666898",
-                  "369902028235468424790098825415813437044876310542601948037281422841675126849",
-                  "13510969869821080499683463562609720931680005714401083864659516045615497273644",
-                  "2567921390740781421487331055530491683313154421589525170472201828596388395736",
-                  "14360870889466292805403568662660511177232987619663547772298178013674025998478",
-                  "4735344599616284973799984501493858013178071155960162022656706545116168334293"
-              ],
-              "identity_path_index": [
-                  1,
-                  0,
-                  1,
-                  0,
-                  1,
-                  1,
-                  0,
-                  0,
-                  1,
-                  1,
-                  1,
-                  0,
-                  0,
-                  0,
-                  1,
-                  0,
-                  1,
-                  1,
-                  0
-              ],
-              "x": "6427050788896290028100534859169645070970780055911091444144195464808120686416",
-              "epoch": "0x2bd155d9f85c741044da6909d144f9cc5ce8e0d545a9ed4921b156e8b8569bab",
-              "rln_identifier": "2193983000213424579594329476781986065965849144986973472766961413131458022566"
-            }
-        "#;
-
-    const WITNESS_JSON_20: &str = r#"
-            {
-              "identity_secret": "13732353453861280511150022598793312186188599006979552959297495195757997428306",
-              "path_elements": [
-                  "20463525608687844300981085488128968694844212760055234622292326942405619575964",
-                  "8040856403709217901175408904825741112286158901303127670929462145501210871313",
-                  "3776499751255585163563840252112871568402966629435152937692711318702338789837",
-                  "19415813252626942110541463414404411443562242499365750694284604341271149125679",
-                  "19414720788761208006634240390286942738242262010168559813148115573784354129237",
-                  "17680594732844291740094158892269696200077963275550625226493856898849422516043",
-                  "16009199741350632715210088346611798597033333293348807000623441780059543674510",
-                  "18743496911007535170857676824393811326863602477260615792503039058813338644738",
-                  "1029572792321380246989475723806770724699749375691788486434716005338938722216",
-                  "21713138150151063186050010182615713685603650963220209951496401043119768920892",
-                  "6713732504049401389983008178456811894856018247924860823028704114266363984580",
-                  "2746686888799473963221285145390361693256731812094259845879519459924507786594",
-                  "18620748467731297359505500266677881218553438497271819903304075323783392031715",
-                  "2446201221122671119406471414204229600430018713181038717206670749886932158104",
-                  "12037171942017611311954851302868199608036334625783560875426350283156617524597",
-                  "21798743392351780927808323348278035105395367759688979232116905142049921734349",
-                  "17450230289417496971557215666910229260621413088991137405744457922069827319039",
-                  "20936854099128086256353520300046664152516566958630447858438908748907198510485",
-                  "13513344965831154386658059617477268600255664386844920822248038939666265737046",
-                  "15546319496880899251450021422131511560001766832580480193115646510655765306630"
-
-              ],
-              "identity_path_index": [
-                  0,
-                  1,
-                  0,
-                  0,
-                  1,
-                  1,
-                  0,
-                  0,
-                  1,
-                  1,
-                  0,
-                  0,
-                  0,
-                  1,
-                  0,
-                  1,
-                  1,
-                  0,
-                  0,
-                  0
-              ],
-              "x": "18073935665561339809445069958310044423750771681863480888589546877024349720547",
-              "epoch": "0x147e4c23a43a1ddca78d94bcd28147f62ca74b3dc7e56bb0a314a954b9f0e567",
-              "rln_identifier": "2193983000213424579594329476781986065965849144986973472766961413131458022566"
-            }
-        "#;
-
-    #[test]
-    // We test Merkle tree generation, proofs and verification
-    fn test_merkle_proof() {
-        let tree_height = TEST_TREE_HEIGHT;
-        let leaf_index = 3;
-
-        // generate identity
-        let identity_secret = hash_to_field(b"test-merkle-proof");
-        let id_commitment = poseidon_hash(&vec![identity_secret]);
-
-        // generate merkle tree
-        let default_leaf = Fr::from(0);
-        let mut tree = PoseidonTree::new(tree_height, default_leaf);
-        tree.set(leaf_index, id_commitment.into()).unwrap();
-
-        // We check correct computation of the root
-        let root = tree.root();
-
-        if TEST_TREE_HEIGHT == 15 {
-            assert_eq!(
-                root,
-                str_to_fr(
-                    "0x1984f2e01184aef5cb974640898a5f5c25556554e2b06d99d4841badb8b198cd",
-                    16
-                )
-            );
-        } else if TEST_TREE_HEIGHT == 19 {
-            assert_eq!(
-                root,
-                str_to_fr(
-                    "0x219ceb53f2b1b7a6cf74e80d50d44d68ecb4a53c6cc65b25593c8d56343fb1fe",
-                    16
-                )
-            );
-        } else if TEST_TREE_HEIGHT == 20 {
-            assert_eq!(
-                root,
-                str_to_fr(
-                    "0x21947ffd0bce0c385f876e7c97d6a42eec5b1fe935aab2f01c1f8a8cbcc356d2",
-                    16
-                )
-            );
-        }
-
-        let merkle_proof = tree.proof(leaf_index).expect("proof should exist");
-        let path_elements = merkle_proof.get_path_elements();
-        let identity_path_index = merkle_proof.get_path_index();
-
-        // We check correct computation of the path and indexes
-        // These values refers to TEST_TREE_HEIGHT == 16
-        let mut expected_path_elements = vec![
-            str_to_fr(
-                "0x0000000000000000000000000000000000000000000000000000000000000000",
-                16,
-            ),
-            str_to_fr(
-                "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
-                16,
-            ),
-            str_to_fr(
-                "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
-                16,
-            ),
-            str_to_fr(
-                "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
-                16,
-            ),
-            str_to_fr(
-                "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
-                16,
-            ),
-            str_to_fr(
-                "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
-                16,
-            ),
-            str_to_fr(
-                "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
-                16,
-            ),
-            str_to_fr(
-                "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
-                16,
-            ),
-            str_to_fr(
-                "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
-                16,
-            ),
-            str_to_fr(
-                "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
-                16,
-            ),
-            str_to_fr(
-                "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
-                16,
-            ),
-            str_to_fr(
-                "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
-                16,
-            ),
-            str_to_fr(
-                "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
-                16,
-            ),
-            str_to_fr(
-                "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
-                16,
-            ),
-            str_to_fr(
-                "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
-                16,
-            ),
-        ];
-
-        let mut expected_identity_path_index: Vec<u8> =
-            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-        // We add the remaining elements for the case TEST_TREE_HEIGHT = 20
-        if TEST_TREE_HEIGHT == 19 || TEST_TREE_HEIGHT == 20 {
-            expected_path_elements.append(&mut vec![
-                str_to_fr(
-                    "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
-                    16,
-                ),
-                str_to_fr(
-                    "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
-                    16,
-                ),
-                str_to_fr(
-                    "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
-                    16,
-                ),
-                str_to_fr(
-                    "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
-                    16,
-                ),
-            ]);
-            expected_identity_path_index.append(&mut vec![0, 0, 0, 0]);
-        }
-
-        if TEST_TREE_HEIGHT == 20 {
-            expected_path_elements.append(&mut vec![str_to_fr(
-                "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
-                16,
-            )]);
-            expected_identity_path_index.append(&mut vec![0]);
-        }
-
-        assert_eq!(path_elements, expected_path_elements);
-        assert_eq!(identity_path_index, expected_identity_path_index);
-
-        // We check correct verification of the proof
-        assert!(tree.verify(&id_commitment, &merkle_proof).unwrap());
-    }
-
-    #[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(TEST_RESOURCES_FOLDER).unwrap();
-        let verification_key = vk_from_folder(TEST_RESOURCES_FOLDER).unwrap();
-        let builder = circom_from_folder(TEST_RESOURCES_FOLDER);
-
-        // We compute witness from the json input example
-        let mut witness_json: &str = "";
-
-        if TEST_TREE_HEIGHT == 15 {
-            witness_json = WITNESS_JSON_15;
-        } else if TEST_TREE_HEIGHT == 19 {
-            witness_json = WITNESS_JSON_19;
-        } else if TEST_TREE_HEIGHT == 20 {
-            witness_json = WITNESS_JSON_20;
-        }
-
-        let rln_witness = rln_witness_from_json(witness_json);
-
-        // Let's generate a zkSNARK proof
-        let proof = generate_proof(builder, &proving_key, &rln_witness).unwrap();
-
-        let proof_values = proof_values_from_witness(&rln_witness);
-
-        // Let's verify the proof
-        let verified = verify_proof(&verification_key, &proof, &proof_values);
-
-        assert!(verified.unwrap());
-    }
-
-    #[test]
-    // We test a RLN proof generation and verification
-    fn test_end_to_end() {
-        let tree_height = TEST_TREE_HEIGHT;
-        let leaf_index = 3;
-
-        // Generate identity pair
-        let (identity_secret, id_commitment) = keygen();
-
-        //// generate merkle tree
-        let default_leaf = Fr::from(0);
-        let mut tree = PoseidonTree::new(tree_height, default_leaf);
-        tree.set(leaf_index, id_commitment.into()).unwrap();
-
-        let merkle_proof = tree.proof(leaf_index).expect("proof should exist");
-
-        let signal = b"hey hey";
-        let x = hash_to_field(signal);
-
-        // We set the remaining values to random ones
-        let epoch = hash_to_field(b"test-epoch");
-        //let rln_identifier = hash_to_field(b"test-rln-identifier");
-
-        let rln_witness: RLNWitnessInput = rln_witness_from_values(
-            identity_secret,
-            &merkle_proof,
-            x,
-            epoch, /*, rln_identifier*/
-        );
-
-        // We generate all relevant keys
-        let proving_key = zkey_from_folder(TEST_RESOURCES_FOLDER).unwrap();
-        let verification_key = vk_from_folder(TEST_RESOURCES_FOLDER).unwrap();
-        let builder = circom_from_folder(TEST_RESOURCES_FOLDER);
-
-        // Let's generate a zkSNARK proof
-        let proof = generate_proof(builder, &proving_key, &rln_witness).unwrap();
-
-        let proof_values = proof_values_from_witness(&rln_witness);
-
-        // Let's verify the proof
-        let success = verify_proof(&verification_key, &proof, &proof_values).unwrap();
-
-        assert!(success);
-    }
-
-    #[test]
-    fn test_witness_serialization() {
-        // We test witness serialization
-        let mut witness_json: &str = "";
-
-        if TEST_TREE_HEIGHT == 15 {
-            witness_json = WITNESS_JSON_15;
-        } else if TEST_TREE_HEIGHT == 19 {
-            witness_json = WITNESS_JSON_19;
-        } else if TEST_TREE_HEIGHT == 20 {
-            witness_json = WITNESS_JSON_20;
-        }
-
-        let rln_witness = rln_witness_from_json(witness_json);
-
-        let ser = serialize_witness(&rln_witness);
-        let (deser, _) = deserialize_witness(&ser);
-        assert_eq!(rln_witness, deser);
-
-        // We test Proof values serialization
-        let proof_values = proof_values_from_witness(&rln_witness);
-        let ser = serialize_proof_values(&proof_values);
-        let (deser, _) = deserialize_proof_values(&ser);
-        assert_eq!(proof_values, deser);
-    }
-}
+#[cfg(not(target_arch = "wasm32"))]
+pub mod ffi;
--- a/rln/src/poseidon_constants.rs
+++ b/rln/src/poseidon_constants.rs
--- a/rln/src/poseidon_hash.rs
+++ b/rln/src/poseidon_hash.rs
@@ -1,126 +1,25 @@
-// This crate implements the Poseidon hash algorithm https://eprint.iacr.org/2019/458.pdf
-
-// The implementation is taken from https://github.com/arnaucube/poseidon-rs/blob/233027d6075a637c29ad84a8a44f5653b81f0410/src/lib.rs
-// and slightly adapted to work over arkworks field data type
+// This crate instantiate the Poseidon hash algorithm

 use crate::circuit::Fr;
-use crate::poseidon_constants::constants;
-use crate::utils::*;
-use ark_std::Zero;
 use once_cell::sync::Lazy;
+use utils::poseidon::Poseidon;

-#[derive(Debug)]
-pub struct Constants {
-    pub c: Vec<Vec<Fr>>,
-    pub m: Vec<Vec<Vec<Fr>>>,
-    pub n_rounds_f: usize,
-    pub n_rounds_p: Vec<usize>,
-}
-pub fn load_constants() -> Constants {
-    let (c_str, m_str) = constants();
-    let mut c: Vec<Vec<Fr>> = Vec::new();
-    for i in 0..c_str.len() {
-        let mut cci: Vec<Fr> = Vec::new();
-        for j in 0..c_str[i].len() {
-            let b: Fr = str_to_fr(c_str[i][j], 10);
-            cci.push(b);
-        }
-        c.push(cci);
-    }
-    let mut m: Vec<Vec<Vec<Fr>>> = Vec::new();
-    for i in 0..m_str.len() {
-        let mut mi: Vec<Vec<Fr>> = Vec::new();
-        for j in 0..m_str[i].len() {
-            let mut mij: Vec<Fr> = Vec::new();
-            for k in 0..m_str[i][j].len() {
-                let b: Fr = str_to_fr(m_str[i][j][k], 10);
-                mij.push(b);
-            }
-            mi.push(mij);
-        }
-        m.push(mi);
-    }
-    Constants {
-        c: c,
-        m: m,
-        n_rounds_f: 8,
-        n_rounds_p: vec![56, 57, 56, 60, 60, 63, 64, 63],
-    }
-}
-
-pub struct Poseidon {
-    constants: Constants,
-}
-impl Poseidon {
-    pub fn new() -> Poseidon {
-        Poseidon {
-            constants: load_constants(),
-        }
-    }
-    pub fn ark(&self, state: &mut [Fr], c: &[Fr], it: usize) {
-        for i in 0..state.len() {
-            state[i] += c[it + i];
-        }
-    }
-
-    pub fn sbox(&self, n_rounds_f: usize, n_rounds_p: usize, state: &mut [Fr], i: usize) {
-        if (i < n_rounds_f / 2) || (i >= n_rounds_f / 2 + n_rounds_p) {
-            for j in 0..state.len() {
-                let aux = state[j];
-                state[j] *= state[j];
-                state[j] *= state[j];
-                state[j] *= aux;
-            }
-        } else {
-            let aux = state[0];
-            state[0] *= state[0];
-            state[0] *= state[0];
-            state[0] *= aux;
-        }
-    }
-
-    pub fn mix(&self, state: &[Fr], m: &[Vec<Fr>]) -> Vec<Fr> {
-        let mut new_state: Vec<Fr> = Vec::new();
-        for i in 0..state.len() {
-            new_state.push(Fr::zero());
-            for j in 0..state.len() {
-                let mut mij = m[i][j];
-                mij *= state[j];
-                new_state[i] += mij;
-            }
-        }
-        new_state.clone()
-    }
-
-    pub fn hash(&self, inp: Vec<Fr>) -> Result<Fr, String> {
-        let t = inp.len() + 1;
-        if inp.is_empty() || (inp.len() >= self.constants.n_rounds_p.len() - 1) {
-            return Err("Wrong inputs length".to_string());
-        }
-        let n_rounds_f = self.constants.n_rounds_f;
-        let n_rounds_p = self.constants.n_rounds_p[t - 2];
-
-        let mut state = vec![Fr::zero(); t];
-        state[1..].clone_from_slice(&inp);
-
-        for i in 0..(n_rounds_f + n_rounds_p) {
-            self.ark(&mut state, &self.constants.c[t - 2], i * t);
-            self.sbox(n_rounds_f, n_rounds_p, &mut state, i);
-            state = self.mix(&state, &self.constants.m[t - 2]);
-        }
-
-        Ok(state[0])
-    }
-}
-
-impl Default for Poseidon {
-    fn default() -> Self {
-        Self::new()
-    }
-}
+// These indexed constants hardcodes the supported round parameters tuples (t, RF, RN, SKIP_MATRICES) for the Bn254 scalar field
+// SKIP_MATRICES is the index of the randomly generated secure MDS matrix. See security note in the zerokit_utils::poseidon::poseidon_constants crate on this.
+// TODO: generate these parameters
+pub const ROUND_PARAMS: [(usize, usize, usize, usize); 8] = [
+    (2, 8, 56, 0),
+    (3, 8, 57, 0),
+    (4, 8, 56, 0),
+    (5, 8, 60, 0),
+    (6, 8, 60, 0),
+    (7, 8, 63, 0),
+    (8, 8, 64, 0),
+    (9, 8, 63, 0),
+];

 // Poseidon Hash wrapper over above implementation. Adapted from semaphore-rs poseidon hash wrapper.
-static POSEIDON: Lazy<Poseidon> = Lazy::new(Poseidon::new);
+static POSEIDON: Lazy<Poseidon<Fr>> = Lazy::new(|| Poseidon::<Fr>::from(&ROUND_PARAMS));

 pub fn poseidon_hash(input: &[Fr]) -> Fr {
    POSEIDON
--- a/rln/src/poseidon_tree.rs
+++ b/rln/src/poseidon_tree.rs
@@ -3,9 +3,14 @@
 // Implementation inspired by https://github.com/worldcoin/semaphore-rs/blob/d462a4372f1fd9c27610f2acfe4841fab1d396aa/src/poseidon_tree.rs (no differences)

 use crate::circuit::Fr;
-use crate::merkle_tree::*;
 use crate::poseidon_hash::poseidon_hash;
 use cfg_if::cfg_if;
+use utils::merkle_tree::*;
+
+#[cfg(feature = "pmtree-ft")]
+use crate::utils::{bytes_le_to_fr, fr_to_bytes_le};
+#[cfg(feature = "pmtree-ft")]
+use pmtree::*;

 // The zerokit RLN default Merkle tree implementation is the OptimalMerkleTree.
 // To switch to FullMerkleTree implementation, it is enough to enable the fullmerkletree feature
@@ -20,11 +25,12 @@ cfg_if! {
    }
 }

-// The zerokit RLN default Hasher
+// The zerokit RLN Merkle tree Hasher
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct PoseidonHash;

-impl Hasher for PoseidonHash {
+// The default Hasher trait used by Merkle tree implementation in utils
+impl utils::merkle_tree::Hasher for PoseidonHash {
    type Fr = Fr;

    fn default_leaf() -> Self::Fr {
@@ -36,74 +42,25 @@ impl Hasher for PoseidonHash {
    }
 }

-////////////////////////////////////////////////////////////
-/// Tests
-////////////////////////////////////////////////////////////
+#[cfg(feature = "pmtree-ft")]
+// The pmtree Hasher trait used by pmtree Merkle tree
+impl pmtree::Hasher for PoseidonHash {
+    type Fr = Fr;

-#[cfg(test)]
-mod test {
-    use super::*;
+    fn default_leaf() -> Self::Fr {
+        Fr::from(0)
+    }

-    #[test]
-    /// A basic performance comparison between the two supported Merkle Tree implementations
-    fn test_merkle_implementations_performances() {
-        use std::time::{Duration, Instant};
+    fn serialize(value: Self::Fr) -> Value {
+        fr_to_bytes_le(&value)
+    }

-        let tree_height = 20;
-        let sample_size = 100;
+    fn deserialize(value: Value) -> Self::Fr {
+        let (fr, _) = bytes_le_to_fr(&value);
+        fr
+    }

-        let leaves: Vec<Fr> = (0..sample_size).map(|s| Fr::from(s)).collect();
-
-        let mut gen_time_full: u128 = 0;
-        let mut upd_time_full: u128 = 0;
-        let mut gen_time_opt: u128 = 0;
-        let mut upd_time_opt: u128 = 0;
-
-        for _ in 0..sample_size.try_into().unwrap() {
-            let now = Instant::now();
-            FullMerkleTree::<PoseidonHash>::default(tree_height);
-            gen_time_full += now.elapsed().as_nanos();
-
-            let now = Instant::now();
-            OptimalMerkleTree::<PoseidonHash>::default(tree_height);
-            gen_time_opt += now.elapsed().as_nanos();
-        }
-
-        let mut tree_full = FullMerkleTree::<PoseidonHash>::default(tree_height);
-        let mut tree_opt = OptimalMerkleTree::<PoseidonHash>::default(tree_height);
-        for i in 0..sample_size.try_into().unwrap() {
-            let now = Instant::now();
-            tree_full.set(i, leaves[i]).unwrap();
-            upd_time_full += now.elapsed().as_nanos();
-            let proof = tree_full.proof(i).expect("index should be set");
-            assert_eq!(proof.leaf_index(), i);
-
-            let now = Instant::now();
-            tree_opt.set(i, leaves[i]).unwrap();
-            upd_time_opt += now.elapsed().as_nanos();
-            let proof = tree_opt.proof(i).expect("index should be set");
-            assert_eq!(proof.leaf_index(), i);
-        }
-
-        println!("Average tree generation time:");
-        println!(
-            "   - Full Merkle Tree:  {:?}",
-            Duration::from_nanos((gen_time_full / sample_size).try_into().unwrap())
-        );
-        println!(
-            "   - Optimal Merkle Tree: {:?}",
-            Duration::from_nanos((gen_time_opt / sample_size).try_into().unwrap())
-        );
-
-        println!("Average update_next execution time:");
-        println!(
-            "   - Full Merkle Tree: {:?}",
-            Duration::from_nanos((upd_time_full / sample_size).try_into().unwrap())
-        );
-
-        println!(
-            "   - Optimal Merkle Tree: {:?}",
-            Duration::from_nanos((upd_time_opt / sample_size).try_into().unwrap())
-        );
+    fn hash(inputs: &[Self::Fr]) -> Self::Fr {
+        poseidon_hash(inputs)
    }
 }
--- a/rln/src/protocol.rs
+++ b/rln/src/protocol.rs
@@ -1,16 +1,15 @@
 // This crate collects all the underlying primitives used to implement RLN

 use ark_circom::{CircomReduction, WitnessCalculator};
-use ark_groth16::{
-    create_proof_with_reduction_and_matrices, prepare_verifying_key,
-    verify_proof as ark_verify_proof, Proof as ArkProof, ProvingKey, VerifyingKey,
-};
+use ark_groth16::{prepare_verifying_key, Groth16, Proof as ArkProof, ProvingKey, VerifyingKey};
 use ark_relations::r1cs::ConstraintMatrices;
 use ark_relations::r1cs::SynthesisError;
 use ark_std::{rand::thread_rng, UniformRand};
-use color_eyre::Result;
+use color_eyre::{Report, Result};
 use num_bigint::BigInt;
-use rand::Rng;
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha20Rng;
+#[cfg(not(target_arch = "wasm32"))]
 use std::sync::Mutex;
 #[cfg(debug_assertions)]
 use std::time::Instant;
@@ -22,6 +21,7 @@ use crate::poseidon_hash::poseidon_hash;
 use crate::poseidon_tree::*;
 use crate::public::RLN_IDENTIFIER;
 use crate::utils::*;
+use cfg_if::cfg_if;

 ///////////////////////////////////////////////////////
 // RLN Witness data structure and utility functions
@@ -49,44 +49,85 @@ pub struct RLNProofValues {
    pub rln_identifier: Fr,
 }

-pub fn serialize_witness(rln_witness: &RLNWitnessInput) -> Vec<u8> {
+pub fn serialize_field_element(element: Fr) -> Vec<u8> {
+    fr_to_bytes_le(&element)
+}
+
+pub fn deserialize_field_element(serialized: Vec<u8>) -> Fr {
+    let (element, _) = bytes_le_to_fr(&serialized);
+
+    element
+}
+
+pub fn deserialize_identity_pair(serialized: Vec<u8>) -> (Fr, Fr) {
+    let (identity_secret_hash, read) = bytes_le_to_fr(&serialized);
+    let (id_commitment, _) = bytes_le_to_fr(&serialized[read..]);
+
+    (identity_secret_hash, id_commitment)
+}
+
+pub fn deserialize_identity_tuple(serialized: Vec<u8>) -> (Fr, Fr, Fr, Fr) {
+    let mut all_read = 0;
+
+    let (identity_trapdoor, read) = bytes_le_to_fr(&serialized[all_read..]);
+    all_read += read;
+
+    let (identity_nullifier, read) = bytes_le_to_fr(&serialized[all_read..]);
+    all_read += read;
+
+    let (identity_secret_hash, read) = bytes_le_to_fr(&serialized[all_read..]);
+    all_read += read;
+
+    let (identity_commitment, _) = bytes_le_to_fr(&serialized[all_read..]);
+
+    (
+        identity_trapdoor,
+        identity_nullifier,
+        identity_secret_hash,
+        identity_commitment,
+    )
+}
+
+pub fn serialize_witness(rln_witness: &RLNWitnessInput) -> Result<Vec<u8>> {
    let mut serialized: Vec<u8> = Vec::new();

    serialized.append(&mut fr_to_bytes_le(&rln_witness.identity_secret));
-    serialized.append(&mut vec_fr_to_bytes_le(&rln_witness.path_elements));
-    serialized.append(&mut vec_u8_to_bytes_le(&rln_witness.identity_path_index));
+    serialized.append(&mut vec_fr_to_bytes_le(&rln_witness.path_elements)?);
+    serialized.append(&mut vec_u8_to_bytes_le(&rln_witness.identity_path_index)?);
    serialized.append(&mut fr_to_bytes_le(&rln_witness.x));
    serialized.append(&mut fr_to_bytes_le(&rln_witness.epoch));
    serialized.append(&mut fr_to_bytes_le(&rln_witness.rln_identifier));

-    serialized
+    Ok(serialized)
 }

-pub fn deserialize_witness(serialized: &[u8]) -> (RLNWitnessInput, usize) {
+pub fn deserialize_witness(serialized: &[u8]) -> Result<(RLNWitnessInput, usize)> {
    let mut all_read: usize = 0;

-    let (identity_secret, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
+    let (identity_secret, read) = bytes_le_to_fr(&serialized[all_read..]);
    all_read += read;

-    let (path_elements, read) = bytes_le_to_vec_fr(&serialized[all_read..].to_vec());
+    let (path_elements, read) = bytes_le_to_vec_fr(&serialized[all_read..])?;
    all_read += read;

-    let (identity_path_index, read) = bytes_le_to_vec_u8(&serialized[all_read..].to_vec());
+    let (identity_path_index, read) = bytes_le_to_vec_u8(&serialized[all_read..])?;
    all_read += read;

-    let (x, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
+    let (x, read) = bytes_le_to_fr(&serialized[all_read..]);
    all_read += read;

-    let (epoch, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
+    let (epoch, read) = bytes_le_to_fr(&serialized[all_read..]);
    all_read += read;

-    let (rln_identifier, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
+    let (rln_identifier, read) = bytes_le_to_fr(&serialized[all_read..]);
    all_read += read;

    // TODO: check rln_identifier against public::RLN_IDENTIFIER
-    assert_eq!(serialized.len(), all_read);
+    if serialized.len() != all_read {
+        return Err(Report::msg("serialized length is not equal to all_read"));
+    }

-    (
+    Ok((
        RLNWitnessInput {
            identity_secret,
            path_elements,
@@ -96,37 +137,34 @@ pub fn deserialize_witness(serialized: &[u8]) -> (RLNWitnessInput, usize) {
            rln_identifier,
        },
        all_read,
-    )
+    ))
 }

 // This function deserializes input for kilic's rln generate_proof public API
 // https://github.com/kilic/rln/blob/7ac74183f8b69b399e3bc96c1ae8ab61c026dc43/src/public.rs#L148
-// input_data is [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
+// input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
 // return value is a rln witness populated according to this information
 pub fn proof_inputs_to_rln_witness(
    tree: &mut PoseidonTree,
    serialized: &[u8],
-) -> (RLNWitnessInput, usize) {
+) -> Result<(RLNWitnessInput, usize)> {
    let mut all_read: usize = 0;

-    let (identity_secret, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
+    let (identity_secret, read) = bytes_le_to_fr(&serialized[all_read..]);
    all_read += read;

-    let id_index = u64::from_le_bytes(serialized[all_read..all_read + 8].try_into().unwrap());
+    let id_index = usize::from_le_bytes(serialized[all_read..all_read + 8].try_into()?);
    all_read += 8;

-    let (epoch, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
+    let (epoch, read) = bytes_le_to_fr(&serialized[all_read..]);
    all_read += read;

-    let signal_len = u64::from_le_bytes(serialized[all_read..all_read + 8].try_into().unwrap());
+    let signal_len = usize::from_le_bytes(serialized[all_read..all_read + 8].try_into()?);
    all_read += 8;

-    let signal: Vec<u8> =
-        serialized[all_read..all_read + usize::try_from(signal_len).unwrap()].to_vec();
+    let signal: Vec<u8> = serialized[all_read..all_read + signal_len].to_vec();

-    let merkle_proof = tree
-        .proof(usize::try_from(id_index).unwrap())
-        .expect("proof should exist");
+    let merkle_proof = tree.proof(id_index).expect("proof should exist");
    let path_elements = merkle_proof.get_path_elements();
    let identity_path_index = merkle_proof.get_path_index();

@@ -134,7 +172,7 @@ pub fn proof_inputs_to_rln_witness(

    let rln_identifier = hash_to_field(RLN_IDENTIFIER);

-    (
+    Ok((
        RLNWitnessInput {
            identity_secret,
            path_elements,
@@ -144,92 +182,48 @@ pub fn proof_inputs_to_rln_witness(
            rln_identifier,
        },
        all_read,
-    )
+    ))
 }

-pub fn serialize_proof_values(rln_proof_values: &RLNProofValues) -> Vec<u8> {
-    let mut serialized: Vec<u8> = Vec::new();
-
-    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.root));
-    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.epoch));
-    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.x));
-    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.y));
-    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.nullifier));
-    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.rln_identifier));
-
-    serialized
-}
-
-pub fn deserialize_proof_values(serialized: &[u8]) -> (RLNProofValues, usize) {
-    let mut all_read: usize = 0;
-
-    let (root, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
-    all_read += read;
-
-    let (epoch, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
-    all_read += read;
-
-    let (x, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
-    all_read += read;
-
-    let (y, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
-    all_read += read;
-
-    let (nullifier, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
-    all_read += read;
-
-    let (rln_identifier, read) = bytes_le_to_fr(&serialized[all_read..].to_vec());
-    all_read += read;
-
-    (
-        RLNProofValues {
-            y,
-            nullifier,
-            root,
-            x,
-            epoch,
-            rln_identifier,
-        },
-        all_read,
-    )
-}
-
-pub fn rln_witness_from_json(input_json_str: &str) -> RLNWitnessInput {
+pub fn rln_witness_from_json(input_json_str: &str) -> Result<RLNWitnessInput> {
    let input_json: serde_json::Value =
        serde_json::from_str(input_json_str).expect("JSON was not well-formatted");

-    let identity_secret = str_to_fr(&input_json["identity_secret"].to_string(), 10);
+    let identity_secret = str_to_fr(&input_json["identity_secret"].to_string(), 10)?;

    let path_elements = input_json["path_elements"]
        .as_array()
-        .unwrap()
+        .ok_or(Report::msg("not an array"))?
        .iter()
        .map(|v| str_to_fr(&v.to_string(), 10))
-        .collect();
+        .collect::<Result<_>>()?;

-    let identity_path_index = input_json["identity_path_index"]
+    let identity_path_index_array = input_json["identity_path_index"]
        .as_array()
-        .unwrap()
-        .iter()
-        .map(|v| v.as_u64().unwrap() as u8)
-        .collect();
+        .ok_or(Report::msg("not an arrray"))?;

-    let x = str_to_fr(&input_json["x"].to_string(), 10);
+    let mut identity_path_index: Vec<u8> = vec![];

-    let epoch = str_to_fr(&input_json["epoch"].to_string(), 16);
+    for v in identity_path_index_array {
+        identity_path_index.push(v.as_u64().ok_or(Report::msg("not a u64 value"))? as u8);
+    }

-    let rln_identifier = str_to_fr(&input_json["rln_identifier"].to_string(), 10);
+    let x = str_to_fr(&input_json["x"].to_string(), 10)?;
+
+    let epoch = str_to_fr(&input_json["epoch"].to_string(), 16)?;
+
+    let rln_identifier = str_to_fr(&input_json["rln_identifier"].to_string(), 10)?;

    // TODO: check rln_identifier against public::RLN_IDENTIFIER

-    RLNWitnessInput {
+    Ok(RLNWitnessInput {
        identity_secret,
        path_elements,
        identity_path_index,
        x,
        epoch,
        rln_identifier,
-    }
+    })
 }

 pub fn rln_witness_from_values(
@@ -281,13 +275,13 @@ pub fn random_rln_witness(tree_height: usize) -> RLNWitnessInput {

 pub fn proof_values_from_witness(rln_witness: &RLNWitnessInput) -> RLNProofValues {
    // y share
+    let external_nullifier = poseidon_hash(&[rln_witness.epoch, rln_witness.rln_identifier]);
    let a_0 = rln_witness.identity_secret;
-    let a_1 = poseidon_hash(&[a_0, rln_witness.epoch]);
-    let y = rln_witness.x * a_1;
-    let y = y + a_0;
+    let a_1 = poseidon_hash(&[a_0, external_nullifier]);
+    let y = a_0 + rln_witness.x * a_1;

    // Nullifier
-    let nullifier = poseidon_hash(&[a_1, rln_witness.rln_identifier]);
+    let nullifier = poseidon_hash(&[a_1]);

    // Merkle tree root computations
    let root = compute_tree_root(
@@ -307,6 +301,83 @@ pub fn proof_values_from_witness(rln_witness: &RLNWitnessInput) -> RLNProofValue
    }
 }

+pub fn serialize_proof_values(rln_proof_values: &RLNProofValues) -> Vec<u8> {
+    let mut serialized: Vec<u8> = Vec::new();
+
+    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.root));
+    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.epoch));
+    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.x));
+    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.y));
+    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.nullifier));
+    serialized.append(&mut fr_to_bytes_le(&rln_proof_values.rln_identifier));
+
+    serialized
+}
+
+// Note: don't forget to skip the 128 bytes ZK proof, if serialized contains it.
+// This proc deserialzies only proof _values_, i.e. circuit outputs, not the zk proof.
+pub fn deserialize_proof_values(serialized: &[u8]) -> (RLNProofValues, usize) {
+    let mut all_read: usize = 0;
+
+    let (root, read) = bytes_le_to_fr(&serialized[all_read..]);
+    all_read += read;
+
+    let (epoch, read) = bytes_le_to_fr(&serialized[all_read..]);
+    all_read += read;
+
+    let (x, read) = bytes_le_to_fr(&serialized[all_read..]);
+    all_read += read;
+
+    let (y, read) = bytes_le_to_fr(&serialized[all_read..]);
+    all_read += read;
+
+    let (nullifier, read) = bytes_le_to_fr(&serialized[all_read..]);
+    all_read += read;
+
+    let (rln_identifier, read) = bytes_le_to_fr(&serialized[all_read..]);
+    all_read += read;
+
+    (
+        RLNProofValues {
+            y,
+            nullifier,
+            root,
+            x,
+            epoch,
+            rln_identifier,
+        },
+        all_read,
+    )
+}
+
+pub fn prepare_prove_input(
+    identity_secret: Fr,
+    id_index: usize,
+    epoch: Fr,
+    signal: &[u8],
+) -> Vec<u8> {
+    let mut serialized: Vec<u8> = Vec::new();
+
+    serialized.append(&mut fr_to_bytes_le(&identity_secret));
+    serialized.append(&mut normalize_usize(id_index));
+    serialized.append(&mut fr_to_bytes_le(&epoch));
+    serialized.append(&mut normalize_usize(signal.len()));
+    serialized.append(&mut signal.to_vec());
+
+    serialized
+}
+
+#[allow(clippy::redundant_clone)]
+pub fn prepare_verify_input(proof_data: Vec<u8>, signal: &[u8]) -> Vec<u8> {
+    let mut serialized: Vec<u8> = Vec::new();
+
+    serialized.append(&mut proof_data.clone());
+    serialized.append(&mut normalize_usize(signal.len()));
+    serialized.append(&mut signal.to_vec());
+
+    serialized
+}
+
 ///////////////////////////////////////////////////////
 // Merkle tree utility functions
 ///////////////////////////////////////////////////////
@@ -334,16 +405,81 @@ pub fn compute_tree_root(
 }

 ///////////////////////////////////////////////////////
-// Signal/nullifier utility functions
+// Protocol utility functions
 ///////////////////////////////////////////////////////

-// Generates a tupe (identity_secret, id_commitment) where
-// identity_secret is random and id_commitment = PoseidonHash(identity_secret)
+// Generates a tuple (identity_secret_hash, id_commitment) where
+// identity_secret_hash is random and id_commitment = PoseidonHash(identity_secret_hash)
+// RNG is instantiated using thread_rng()
 pub fn keygen() -> (Fr, Fr) {
    let mut rng = thread_rng();
-    let identity_secret = Fr::rand(&mut rng);
-    let id_commitment = poseidon_hash(&[identity_secret]);
-    (identity_secret, id_commitment)
+    let identity_secret_hash = Fr::rand(&mut rng);
+    let id_commitment = poseidon_hash(&[identity_secret_hash]);
+    (identity_secret_hash, id_commitment)
+}
+
+// Generates a tuple (identity_trapdoor, identity_nullifier, identity_secret_hash, id_commitment) where
+// identity_trapdoor and identity_nullifier are random,
+// identity_secret_hash = PoseidonHash(identity_trapdoor, identity_nullifier),
+// id_commitment = PoseidonHash(identity_secret_hash),
+// RNG is instantiated using thread_rng()
+// Generated credentials are compatible with Semaphore credentials
+pub fn extended_keygen() -> (Fr, Fr, Fr, Fr) {
+    let mut rng = thread_rng();
+    let identity_trapdoor = Fr::rand(&mut rng);
+    let identity_nullifier = Fr::rand(&mut rng);
+    let identity_secret_hash = poseidon_hash(&[identity_trapdoor, identity_nullifier]);
+    let id_commitment = poseidon_hash(&[identity_secret_hash]);
+    (
+        identity_trapdoor,
+        identity_nullifier,
+        identity_secret_hash,
+        id_commitment,
+    )
+}
+
+// Generates a tuple (identity_secret_hash, id_commitment) where
+// identity_secret_hash is random and id_commitment = PoseidonHash(identity_secret_hash)
+// RNG is instantiated using 20 rounds of ChaCha seeded with the hash of the input
+pub fn seeded_keygen(signal: &[u8]) -> (Fr, Fr) {
+    // ChaCha20 requires a seed of exactly 32 bytes.
+    // We first hash the input seed signal to a 32 bytes array and pass this as seed to ChaCha20
+    let mut seed = [0; 32];
+    let mut hasher = Keccak::v256();
+    hasher.update(signal);
+    hasher.finalize(&mut seed);
+
+    let mut rng = ChaCha20Rng::from_seed(seed);
+    let identity_secret_hash = Fr::rand(&mut rng);
+    let id_commitment = poseidon_hash(&[identity_secret_hash]);
+    (identity_secret_hash, id_commitment)
+}
+
+// Generates a tuple (identity_trapdoor, identity_nullifier, identity_secret_hash, id_commitment) where
+// identity_trapdoor and identity_nullifier are random,
+// identity_secret_hash = PoseidonHash(identity_trapdoor, identity_nullifier),
+// id_commitment = PoseidonHash(identity_secret_hash),
+// RNG is instantiated using 20 rounds of ChaCha seeded with the hash of the input
+// Generated credentials are compatible with Semaphore credentials
+pub fn extended_seeded_keygen(signal: &[u8]) -> (Fr, Fr, Fr, Fr) {
+    // ChaCha20 requires a seed of exactly 32 bytes.
+    // We first hash the input seed signal to a 32 bytes array and pass this as seed to ChaCha20
+    let mut seed = [0; 32];
+    let mut hasher = Keccak::v256();
+    hasher.update(signal);
+    hasher.finalize(&mut seed);
+
+    let mut rng = ChaCha20Rng::from_seed(seed);
+    let identity_trapdoor = Fr::rand(&mut rng);
+    let identity_nullifier = Fr::rand(&mut rng);
+    let identity_secret_hash = poseidon_hash(&[identity_trapdoor, identity_nullifier]);
+    let id_commitment = poseidon_hash(&[identity_secret_hash]);
+    (
+        identity_trapdoor,
+        identity_nullifier,
+        identity_secret_hash,
+        id_commitment,
+    )
 }

 // Hashes arbitrary signal to the underlying prime field
@@ -360,6 +496,34 @@ pub fn hash_to_field(signal: &[u8]) -> Fr {
    el
 }

+pub fn compute_id_secret(
+    share1: (Fr, Fr),
+    share2: (Fr, Fr),
+    external_nullifier: Fr,
+) -> Result<Fr, String> {
+    // Assuming a0 is the identity secret and a1 = poseidonHash([a0, external_nullifier]),
+    // a (x,y) share satisfies the following relation
+    // y = a_0 + x * a_1
+    let (x1, y1) = share1;
+    let (x2, y2) = share2;
+
+    // If the two input shares were computed for the same external_nullifier and identity secret, we can recover the latter
+    // y1 = a_0 + x1 * a_1
+    // y2 = a_0 + x2 * a_1
+    let a_1 = (y1 - y2) / (x1 - x2);
+    let a_0 = y1 - x1 * a_1;
+
+    // If shares come from the same polynomial, a0 is correctly recovered and a1 = poseidonHash([a0, external_nullifier])
+    let computed_a_1 = poseidon_hash(&[a_0, external_nullifier]);
+
+    if a_1 == computed_a_1 {
+        // We successfully recovered the identity secret
+        Ok(a_0)
+    } else {
+        Err("Cannot recover identity_secret_hash from provided shares".into())
+    }
+}
+
 ///////////////////////////////////////////////////////
 // zkSNARK utility functions
 ///////////////////////////////////////////////////////
@@ -367,64 +531,48 @@ pub fn hash_to_field(signal: &[u8]) -> Fr {
 #[derive(Error, Debug)]
 pub enum ProofError {
    #[error("Error reading circuit key: {0}")]
-    CircuitKeyError(#[from] std::io::Error),
+    CircuitKeyError(#[from] Report),
    #[error("Error producing witness: {0}")]
-    WitnessError(color_eyre::Report),
+    WitnessError(Report),
    #[error("Error producing proof: {0}")]
    SynthesisError(#[from] SynthesisError),
 }

-/// Generates a RLN proof
-///
-/// # Errors
-///
-/// Returns a [`ProofError`] if proving fails.
-pub fn generate_proof(
-    witness_calculator: &Mutex<WitnessCalculator>,
+fn calculate_witness_element<E: ark_ec::pairing::Pairing>(
+    witness: Vec<BigInt>,
+) -> Result<Vec<E::ScalarField>> {
+    use ark_ff::PrimeField;
+    let modulus = <E::ScalarField as PrimeField>::MODULUS;
+
+    // convert it to field elements
+    use num_traits::Signed;
+    let mut witness_vec = vec![];
+    for w in witness.into_iter() {
+        let w = if w.sign() == num_bigint::Sign::Minus {
+            // Need to negate the witness element if negative
+            modulus.into()
+                - w.abs()
+                    .to_biguint()
+                    .ok_or(Report::msg("not a biguint value"))?
+        } else {
+            w.to_biguint().ok_or(Report::msg("not a biguint value"))?
+        };
+        witness_vec.push(E::ScalarField::from(w))
+    }
+
+    Ok(witness_vec)
+}
+
+pub fn generate_proof_with_witness(
+    witness: Vec<BigInt>,
    proving_key: &(ProvingKey<Curve>, ConstraintMatrices<Fr>),
-    rln_witness: &RLNWitnessInput,
 ) -> Result<ArkProof<Curve>, ProofError> {
-    // We confert the path indexes to field elements
-    // TODO: check if necessary
-    let mut path_elements = Vec::new();
-    rln_witness
-        .path_elements
-        .iter()
-        .for_each(|v| path_elements.push(to_bigint(v)));
-
-    let mut identity_path_index = Vec::new();
-    rln_witness
-        .identity_path_index
-        .iter()
-        .for_each(|v| identity_path_index.push(BigInt::from(*v)));
-
-    let inputs = [
-        (
-            "identity_secret",
-            vec![to_bigint(&rln_witness.identity_secret)],
-        ),
-        ("path_elements", path_elements),
-        ("identity_path_index", identity_path_index),
-        ("x", vec![to_bigint(&rln_witness.x)]),
-        ("epoch", vec![to_bigint(&rln_witness.epoch)]),
-        (
-            "rln_identifier",
-            vec![to_bigint(&rln_witness.rln_identifier)],
-        ),
-    ];
-    let inputs = inputs
-        .into_iter()
-        .map(|(name, values)| (name.to_string(), values));
-
    // If in debug mode, we measure and later print time take to compute witness
    #[cfg(debug_assertions)]
    let now = Instant::now();

-    let full_assignment = witness_calculator
-        .lock()
-        .expect("witness_calculator mutex should not get poisoned")
-        .calculate_witness_element::<Curve, _>(inputs, false)
-        .map_err(ProofError::WitnessError)?;
+    let full_assignment =
+        calculate_witness_element::<Curve>(witness).map_err(ProofError::WitnessError)?;

    #[cfg(debug_assertions)]
    println!("witness generation took: {:.2?}", now.elapsed());
@@ -438,7 +586,101 @@ pub fn generate_proof(
    #[cfg(debug_assertions)]
    let now = Instant::now();

-    let proof = create_proof_with_reduction_and_matrices::<_, CircomReduction>(
+    let proof = Groth16::<_, CircomReduction>::create_proof_with_reduction_and_matrices(
+        &proving_key.0,
+        r,
+        s,
+        &proving_key.1,
+        proving_key.1.num_instance_variables,
+        proving_key.1.num_constraints,
+        full_assignment.as_slice(),
+    )?;
+
+    #[cfg(debug_assertions)]
+    println!("proof generation took: {:.2?}", now.elapsed());
+
+    Ok(proof)
+}
+
+pub fn inputs_for_witness_calculation(
+    rln_witness: &RLNWitnessInput,
+) -> Result<[(&str, Vec<BigInt>); 6]> {
+    // We confert the path indexes to field elements
+    // TODO: check if necessary
+    let mut path_elements = Vec::new();
+
+    for v in rln_witness.path_elements.iter() {
+        path_elements.push(to_bigint(v)?);
+    }
+
+    let mut identity_path_index = Vec::new();
+    rln_witness
+        .identity_path_index
+        .iter()
+        .for_each(|v| identity_path_index.push(BigInt::from(*v)));
+
+    Ok([
+        (
+            "identity_secret",
+            vec![to_bigint(&rln_witness.identity_secret)?],
+        ),
+        ("path_elements", path_elements),
+        ("identity_path_index", identity_path_index),
+        ("x", vec![to_bigint(&rln_witness.x)?]),
+        ("epoch", vec![to_bigint(&rln_witness.epoch)?]),
+        (
+            "rln_identifier",
+            vec![to_bigint(&rln_witness.rln_identifier)?],
+        ),
+    ])
+}
+
+/// Generates a RLN proof
+///
+/// # Errors
+///
+/// Returns a [`ProofError`] if proving fails.
+pub fn generate_proof(
+    #[cfg(not(target_arch = "wasm32"))] witness_calculator: &Mutex<WitnessCalculator>,
+    #[cfg(target_arch = "wasm32")] witness_calculator: &mut WitnessCalculator,
+    proving_key: &(ProvingKey<Curve>, ConstraintMatrices<Fr>),
+    rln_witness: &RLNWitnessInput,
+) -> Result<ArkProof<Curve>, ProofError> {
+    let inputs = inputs_for_witness_calculation(rln_witness)?
+        .into_iter()
+        .map(|(name, values)| (name.to_string(), values));
+
+    // If in debug mode, we measure and later print time take to compute witness
+    #[cfg(debug_assertions)]
+    let now = Instant::now();
+
+    cfg_if! {
+        if #[cfg(target_arch = "wasm32")] {
+            let full_assignment = witness_calculator
+            .calculate_witness_element::<Curve, _>(inputs, false)
+            .map_err(ProofError::WitnessError)?;
+        } else {
+            let full_assignment = witness_calculator
+            .lock()
+            .expect("witness_calculator mutex should not get poisoned")
+            .calculate_witness_element::<Curve, _>(inputs, false)
+            .map_err(ProofError::WitnessError)?;
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    println!("witness generation took: {:.2?}", now.elapsed());
+
+    // Random Values
+    let mut rng = thread_rng();
+    let r = Fr::rand(&mut rng);
+    let s = Fr::rand(&mut rng);
+
+    // If in debug mode, we measure and later print time take to compute proof
+    #[cfg(debug_assertions)]
+    let now = Instant::now();
+
+    let proof = Groth16::<_, CircomReduction>::create_proof_with_reduction_and_matrices(
        &proving_key.0,
        r,
        s,
@@ -483,10 +725,39 @@ pub fn verify_proof(
    #[cfg(debug_assertions)]
    let now = Instant::now();

-    let verified = ark_verify_proof(&pvk, proof, &inputs)?;
+    let verified = Groth16::<_, CircomReduction>::verify_proof(&pvk, proof, &inputs)?;

    #[cfg(debug_assertions)]
    println!("verify took: {:.2?}", now.elapsed());

    Ok(verified)
 }
+
+/// Get CIRCOM JSON inputs
+///
+/// Returns a JSON object containing the inputs necessary to calculate
+/// the witness with CIRCOM on javascript
+pub fn get_json_inputs(rln_witness: &RLNWitnessInput) -> Result<serde_json::Value> {
+    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!({
+        "identity_secret": to_bigint(&rln_witness.identity_secret)?.to_str_radix(10),
+        "path_elements": path_elements,
+        "identity_path_index": identity_path_index,
+        "x": to_bigint(&rln_witness.x)?.to_str_radix(10),
+        "epoch":  format!("0x{:064x}", to_bigint(&rln_witness.epoch)?),
+        "rln_identifier": to_bigint(&rln_witness.rln_identifier)?.to_str_radix(10),
+    });
+
+    Ok(inputs)
+}
--- a/rln/src/public.rs
+++ b/rln/src/public.rs
--- a/rln/src/utils.rs
+++ b/rln/src/utils.rs
@@ -1,30 +1,26 @@
 // This crate provides cross-module useful utilities (mainly type conversions) not necessarily specific to RLN

 use crate::circuit::Fr;
-use ark_ff::{BigInteger, FpParameters, PrimeField};
+use ark_ff::PrimeField;
+use color_eyre::{Report, Result};
 use num_bigint::{BigInt, BigUint};
 use num_traits::Num;
 use std::iter::Extend;

-pub fn modulus_bit_size() -> usize {
-    <Fr as PrimeField>::Params::MODULUS
-        .num_bits()
-        .try_into()
-        .unwrap()
-}
-
-pub fn to_bigint(el: &Fr) -> BigInt {
-    let res: BigUint = (*el).try_into().unwrap();
-    res.try_into().unwrap()
+pub fn to_bigint(el: &Fr) -> Result<BigInt> {
+    let res: BigUint = (*el).try_into()?;
+    Ok(res.into())
 }

 pub fn fr_byte_size() -> usize {
-    let mbs = modulus_bit_size();
-    (mbs + 64 - (mbs % 64)) / 8
+    let mbs = <Fr as PrimeField>::MODULUS_BIT_SIZE;
+    ((mbs + 64 - (mbs % 64)) / 8) as usize
 }

-pub fn str_to_fr(input: &str, radix: u32) -> Fr {
-    assert!((radix == 10) || (radix == 16));
+pub fn str_to_fr(input: &str, radix: u32) -> Result<Fr> {
+    if !(radix == 10 || radix == 16) {
+        return Err(Report::msg("wrong radix"));
+    }

    // We remove any quote present and we trim
    let single_quote: char = '\"';
@@ -32,16 +28,10 @@ pub fn str_to_fr(input: &str, radix: u32) -> Fr {
    input_clean = input_clean.trim().to_string();

    if radix == 10 {
-        BigUint::from_str_radix(&input_clean, radix)
-            .unwrap()
-            .try_into()
-            .unwrap()
+        Ok(BigUint::from_str_radix(&input_clean, radix)?.try_into()?)
    } else {
        input_clean = input_clean.replace("0x", "");
-        BigUint::from_str_radix(&input_clean, radix)
-            .unwrap()
-            .try_into()
-            .unwrap()
+        Ok(BigUint::from_str_radix(&input_clean, radix)?.try_into()?)
    }
 }

@@ -82,99 +72,111 @@ pub fn fr_to_bytes_be(input: &Fr) -> Vec<u8> {
    res
 }

-pub fn vec_fr_to_bytes_le(input: &[Fr]) -> Vec<u8> {
+pub fn vec_fr_to_bytes_le(input: &[Fr]) -> Result<Vec<u8>> {
    let mut bytes: Vec<u8> = Vec::new();
    //We store the vector length
    bytes.extend(input.len().to_le_bytes().to_vec());
+
    // We store each element
    input.iter().for_each(|el| bytes.extend(fr_to_bytes_le(el)));

-    bytes
+    Ok(bytes)
 }

-pub fn vec_fr_to_bytes_be(input: &[Fr]) -> Vec<u8> {
+pub fn vec_fr_to_bytes_be(input: &[Fr]) -> Result<Vec<u8>> {
    let mut bytes: Vec<u8> = Vec::new();
    //We store the vector length
    bytes.extend(input.len().to_be_bytes().to_vec());
+
    // We store each element
    input.iter().for_each(|el| bytes.extend(fr_to_bytes_be(el)));

-    bytes
+    Ok(bytes)
 }

-pub fn vec_u8_to_bytes_le(input: &[u8]) -> Vec<u8> {
+pub fn vec_u8_to_bytes_le(input: &[u8]) -> Result<Vec<u8>> {
    let mut bytes: Vec<u8> = Vec::new();
    //We store the vector length
-    bytes.extend(u64::try_from(input.len()).unwrap().to_le_bytes().to_vec());
+    bytes.extend(input.len().to_le_bytes().to_vec());
+
    bytes.extend(input);
-    bytes
+
+    Ok(bytes)
 }

-pub fn vec_u8_to_bytes_be(input: Vec<u8>) -> Vec<u8> {
+pub fn vec_u8_to_bytes_be(input: Vec<u8>) -> Result<Vec<u8>> {
    let mut bytes: Vec<u8> = Vec::new();
    //We store the vector length
-    bytes.extend(u64::try_from(input.len()).unwrap().to_be_bytes().to_vec());
+    bytes.extend(input.len().to_be_bytes().to_vec());
+
    bytes.extend(input);
-    bytes
+
+    Ok(bytes)
 }

-pub fn bytes_le_to_vec_u8(input: &[u8]) -> (Vec<u8>, usize) {
+pub fn bytes_le_to_vec_u8(input: &[u8]) -> Result<(Vec<u8>, usize)> {
    let mut read: usize = 0;

-    let len = usize::try_from(u64::from_le_bytes(input[0..8].try_into().unwrap())).unwrap();
+    let len = usize::from_le_bytes(input[0..8].try_into()?);
    read += 8;

    let res = input[8..8 + len].to_vec();
    read += res.len();

-    (res, read)
+    Ok((res, read))
 }

-pub fn bytes_be_to_vec_u8(input: &[u8]) -> (Vec<u8>, usize) {
+pub fn bytes_be_to_vec_u8(input: &[u8]) -> Result<(Vec<u8>, usize)> {
    let mut read: usize = 0;

-    let len = usize::try_from(u64::from_be_bytes(input[0..8].try_into().unwrap())).unwrap();
+    let len = usize::from_be_bytes(input[0..8].try_into()?);
    read += 8;

    let res = input[8..8 + len].to_vec();

    read += res.len();

-    (res, read)
+    Ok((res, read))
 }

-pub fn bytes_le_to_vec_fr(input: &[u8]) -> (Vec<Fr>, usize) {
+pub fn bytes_le_to_vec_fr(input: &[u8]) -> Result<(Vec<Fr>, usize)> {
    let mut read: usize = 0;
    let mut res: Vec<Fr> = Vec::new();

-    let len = usize::try_from(u64::from_le_bytes(input[0..8].try_into().unwrap())).unwrap();
+    let len = usize::from_le_bytes(input[0..8].try_into()?);
    read += 8;

    let el_size = fr_byte_size();
    for i in 0..len {
-        let (curr_el, _) = bytes_le_to_fr(&input[8 + el_size * i..8 + el_size * (i + 1)].to_vec());
+        let (curr_el, _) = bytes_le_to_fr(&input[8 + el_size * i..8 + el_size * (i + 1)]);
        res.push(curr_el);
        read += el_size;
    }

-    (res, read)
+    Ok((res, read))
 }

-pub fn bytes_be_to_vec_fr(input: &[u8]) -> (Vec<Fr>, usize) {
+pub fn bytes_be_to_vec_fr(input: &[u8]) -> Result<(Vec<Fr>, usize)> {
    let mut read: usize = 0;
    let mut res: Vec<Fr> = Vec::new();

-    let len = usize::try_from(u64::from_be_bytes(input[0..8].try_into().unwrap())).unwrap();
+    let len = usize::from_be_bytes(input[0..8].try_into()?);
    read += 8;

    let el_size = fr_byte_size();
    for i in 0..len {
-        let (curr_el, _) = bytes_be_to_fr(&input[8 + el_size * i..8 + el_size * (i + 1)].to_vec());
+        let (curr_el, _) = bytes_be_to_fr(&input[8 + el_size * i..8 + el_size * (i + 1)]);
        res.push(curr_el);
        read += el_size;
    }

-    (res, read)
+    Ok((res, read))
+}
+
+pub fn normalize_usize(input: usize) -> Vec<u8> {
+    let mut normalized_usize = input.to_le_bytes().to_vec();
+    normalized_usize.resize(8, 0);
+    normalized_usize
 }

 /* Old conversion utilities between different libraries data types
--- a/rln/tests/ffi.rs
+++ b/rln/tests/ffi.rs
--- a/rln/tests/poseidon_tree.rs
+++ b/rln/tests/poseidon_tree.rs
@@ -0,0 +1,617 @@
+////////////////////////////////////////////////////////////
+/// Tests
+////////////////////////////////////////////////////////////
+
+#[cfg(test)]
+mod test {
+    use rln::circuit::*;
+    use rln::poseidon_tree::*;
+    use utils::{FullMerkleTree, OptimalMerkleTree};
+
+    #[test]
+    /// A basic performance comparison between the two supported Merkle Tree implementations
+    fn test_zerokit_merkle_implementations_performances() {
+        use std::time::{Duration, Instant};
+
+        let tree_height = 20;
+        let sample_size = 100;
+
+        let leaves: Vec<Fr> = (0..sample_size).map(|s| Fr::from(s)).collect();
+
+        let mut gen_time_full: u128 = 0;
+        let mut upd_time_full: u128 = 0;
+        let mut gen_time_opt: u128 = 0;
+        let mut upd_time_opt: u128 = 0;
+
+        for _ in 0..sample_size.try_into().unwrap() {
+            let now = Instant::now();
+            FullMerkleTree::<PoseidonHash>::default(tree_height);
+            gen_time_full += now.elapsed().as_nanos();
+
+            let now = Instant::now();
+            OptimalMerkleTree::<PoseidonHash>::default(tree_height);
+            gen_time_opt += now.elapsed().as_nanos();
+        }
+
+        let mut tree_full = FullMerkleTree::<PoseidonHash>::default(tree_height);
+        let mut tree_opt = OptimalMerkleTree::<PoseidonHash>::default(tree_height);
+
+        for i in 0..sample_size.try_into().unwrap() {
+            let now = Instant::now();
+            tree_full.set(i, leaves[i]).unwrap();
+            upd_time_full += now.elapsed().as_nanos();
+            let proof = tree_full.proof(i).expect("index should be set");
+            assert_eq!(proof.leaf_index(), i);
+
+            let now = Instant::now();
+            tree_opt.set(i, leaves[i]).unwrap();
+            upd_time_opt += now.elapsed().as_nanos();
+            let proof = tree_opt.proof(i).expect("index should be set");
+            assert_eq!(proof.leaf_index(), i);
+        }
+
+        // We check all roots are the same
+        let tree_full_root = tree_full.root();
+        let tree_opt_root = tree_opt.root();
+
+        assert_eq!(tree_full_root, tree_opt_root);
+
+        println!(" Average tree generation time:");
+        println!(
+            "   - Full Merkle Tree:  {:?}",
+            Duration::from_nanos((gen_time_full / sample_size).try_into().unwrap())
+        );
+        println!(
+            "   - Optimal Merkle Tree: {:?}",
+            Duration::from_nanos((gen_time_opt / sample_size).try_into().unwrap())
+        );
+
+        println!(" Average update_next execution time:");
+        println!(
+            "   - Full Merkle Tree: {:?}",
+            Duration::from_nanos((upd_time_full / sample_size).try_into().unwrap())
+        );
+
+        println!(
+            "   - Optimal Merkle Tree: {:?}",
+            Duration::from_nanos((upd_time_opt / sample_size).try_into().unwrap())
+        );
+    }
+}
+
+// Test module for testing pmtree integration and features in zerokit
+// enabled only if the pmtree feature is enabled
+
+#[cfg(feature = "pmtree-ft")]
+#[cfg(test)]
+mod pmtree_test {
+
+    use pmtree::*;
+    use rln::circuit::Fr;
+    use rln::poseidon_hash::poseidon_hash;
+    use rln::poseidon_tree::PoseidonHash;
+    use rln::protocol::hash_to_field;
+    use rln::utils::str_to_fr;
+    use sled::Db as Sled;
+    use std::fs;
+    use std::{collections::HashMap, path::PathBuf};
+    use utils::{FullMerkleTree, OptimalMerkleTree};
+
+    // pmtree supports in-memory and on-disk databases (Database trait) for storing the Merkle tree state
+
+    // We implement Database for hashmaps, an in-memory database
+    struct MemoryDB(HashMap<DBKey, Value>);
+
+    #[derive(Default)]
+    struct MemoryDBConfig {}
+
+    impl Database for MemoryDB {
+        type Config = MemoryDBConfig;
+
+        fn new(_config: Self::Config) -> Result<Self> {
+            Ok(MemoryDB(HashMap::new()))
+        }
+
+        fn load(_config: Self::Config) -> Result<Self> {
+            Err(Box::new(Error("Cannot load in-memory DB".to_string())))
+        }
+
+        fn get(&self, key: DBKey) -> Result<Option<Value>> {
+            Ok(self.0.get(&key).cloned())
+        }
+
+        fn put(&mut self, key: DBKey, value: Value) -> Result<()> {
+            self.0.insert(key, value);
+
+            Ok(())
+        }
+
+        fn put_batch(&mut self, subtree: HashMap<DBKey, Value>) -> Result<()> {
+            self.0.extend(subtree);
+            Ok(())
+        }
+    }
+
+    // We implement Database for sled DB, an on-disk database
+    struct SledDB(Sled);
+
+    impl Database for SledDB {
+        type Config = sled::Config;
+
+        fn new(config: Self::Config) -> Result<Self> {
+            let dbpath = config.path;
+            if config.dbpath.exists() {
+                match fs::remove_dir_all(&config.dbpath) {
+                    Ok(x) => x,
+                    Err(e) => return Err(Box::new(Error(e.to_string()))),
+                }
+            }
+
+            let db: Sled = match config.open() {
+                Ok(db) => db,
+                Err(e) => return Err(Box::new(Error(e.to_string()))),
+            };
+
+            Ok(SledDB(db))
+        }
+
+        fn load(config: Self::Config) -> Result<Self> {
+            let db: Sled = match sled::open(config.dbpath) {
+                Ok(db) => db,
+                Err(e) => return Err(Box::new(Error(e.to_string()))),
+            };
+
+            if !db.was_recovered() {
+                return Err(Box::new(Error(
+                    "Trying to load non-existing database!".to_string(),
+                )));
+            }
+
+            Ok(SledDB(db))
+        }
+
+        fn get(&self, key: DBKey) -> Result<Option<Value>> {
+            match self.0.get(key) {
+                Ok(value) => Ok(value.map(|val| val.to_vec())),
+                Err(e) => Err(Box::new(Error(e.to_string()))),
+            }
+        }
+
+        fn put(&mut self, key: DBKey, value: Value) -> Result<()> {
+            match self.0.insert(key, value) {
+                Ok(_) => Ok(()),
+                Err(e) => Err(Box::new(Error(e.to_string()))),
+            }
+        }
+
+        fn put_batch(&mut self, subtree: HashMap<DBKey, Value>) -> Result<()> {
+            let mut batch = sled::Batch::default();
+
+            for (key, value) in subtree {
+                batch.insert(&key, value);
+            }
+
+            self.0.apply_batch(batch)?;
+            Ok(())
+        }
+    }
+
+    #[test]
+    /// A basic performance comparison between the two supported Merkle Tree implementations and in-memory/on-disk pmtree implementations
+    fn test_zerokit_and_pmtree_merkle_implementations_performances() {
+        use std::time::{Duration, Instant};
+
+        let tree_height = 20;
+        let sample_size = 100;
+
+        let leaves: Vec<Fr> = (0..sample_size).map(|s| Fr::from(s)).collect();
+
+        let mut gen_time_full: u128 = 0;
+        let mut upd_time_full: u128 = 0;
+        let mut gen_time_opt: u128 = 0;
+        let mut upd_time_opt: u128 = 0;
+        let mut gen_time_pm_memory: u128 = 0;
+        let mut upd_time_pm_memory: u128 = 0;
+        let mut gen_time_pm_sled: u128 = 0;
+        let mut upd_time_pm_sled: u128 = 0;
+
+        for _ in 0..sample_size.try_into().unwrap() {
+            let now = Instant::now();
+            FullMerkleTree::<PoseidonHash>::default(tree_height);
+            gen_time_full += now.elapsed().as_nanos();
+
+            let now = Instant::now();
+            OptimalMerkleTree::<PoseidonHash>::default(tree_height);
+            gen_time_opt += now.elapsed().as_nanos();
+
+            let now = Instant::now();
+            pmtree::MerkleTree::<MemoryDB, PoseidonHash>::default(tree_height).unwrap();
+            gen_time_pm_memory += now.elapsed().as_nanos();
+
+            let now = Instant::now();
+            pmtree::MerkleTree::<SledDB, PoseidonHash>::default(tree_height).unwrap();
+            gen_time_pm_sled += now.elapsed().as_nanos();
+        }
+
+        let mut tree_full = FullMerkleTree::<PoseidonHash>::default(tree_height);
+        let mut tree_opt = OptimalMerkleTree::<PoseidonHash>::default(tree_height);
+        let mut tree_pm_memory =
+            pmtree::MerkleTree::<MemoryDB, PoseidonHash>::default(tree_height).unwrap();
+        let mut tree_pm_sled =
+            pmtree::MerkleTree::<SledDB, PoseidonHash>::default(tree_height).unwrap();
+
+        for i in 0..sample_size.try_into().unwrap() {
+            let now = Instant::now();
+            tree_full.set(i, leaves[i]).unwrap();
+            upd_time_full += now.elapsed().as_nanos();
+            let proof = tree_full.proof(i).expect("index should be set");
+            assert_eq!(proof.leaf_index(), i);
+
+            let now = Instant::now();
+            tree_opt.set(i, leaves[i]).unwrap();
+            upd_time_opt += now.elapsed().as_nanos();
+            let proof = tree_opt.proof(i).expect("index should be set");
+            assert_eq!(proof.leaf_index(), i);
+
+            let now = Instant::now();
+            tree_pm_memory.set(i, leaves[i]).unwrap();
+            upd_time_pm_memory += now.elapsed().as_nanos();
+            let proof = tree_pm_memory.proof(i).expect("index should be set");
+            assert_eq!(proof.leaf_index(), i);
+
+            let now = Instant::now();
+            tree_pm_sled.set(i, leaves[i]).unwrap();
+            upd_time_pm_sled += now.elapsed().as_nanos();
+            let proof = tree_pm_sled.proof(i).expect("index should be set");
+            assert_eq!(proof.leaf_index(), i);
+        }
+
+        // We check all roots are the same
+        let tree_full_root = tree_full.root();
+        let tree_opt_root = tree_opt.root();
+        let tree_pm_memory_root = tree_pm_memory.root();
+        let tree_pm_sled_root = tree_pm_sled.root();
+
+        assert_eq!(tree_full_root, tree_opt_root);
+        assert_eq!(tree_opt_root, tree_pm_memory_root);
+        assert_eq!(tree_pm_memory_root, tree_pm_sled_root);
+
+        println!(" Average tree generation time:");
+        println!(
+            "   - Full Merkle Tree:  {:?}",
+            Duration::from_nanos((gen_time_full / sample_size).try_into().unwrap())
+        );
+        println!(
+            "   - Optimal Merkle Tree: {:?}",
+            Duration::from_nanos((gen_time_opt / sample_size).try_into().unwrap())
+        );
+
+        println!(
+            "   - Pmtree-HashMap Merkle Tree: {:?}",
+            Duration::from_nanos((gen_time_pm_memory / sample_size).try_into().unwrap())
+        );
+
+        println!(
+            "   - Pmtree-Sled Merkle Tree: {:?}",
+            Duration::from_nanos((gen_time_pm_sled / sample_size).try_into().unwrap())
+        );
+
+        println!(" Average update_next execution time:");
+        println!(
+            "   - Full Merkle Tree: {:?}",
+            Duration::from_nanos((upd_time_full / sample_size).try_into().unwrap())
+        );
+
+        println!(
+            "   - Optimal Merkle Tree: {:?}",
+            Duration::from_nanos((upd_time_opt / sample_size).try_into().unwrap())
+        );
+
+        println!(
+            "   - Pmtree-HashMap Merkle Tree: {:?}",
+            Duration::from_nanos((upd_time_pm_memory / sample_size).try_into().unwrap())
+        );
+
+        println!(
+            "   - Pmtree-Sled Merkle Tree: {:?}",
+            Duration::from_nanos((upd_time_pm_sled / sample_size).try_into().unwrap())
+        );
+    }
+
+    // The following two tests contain values that come from public::test_merkle_proof test
+    // We check that pmtree and zerokit Merkle tree implementations match.
+
+    #[test]
+    fn test_pmtree_hashmap() -> Result<()> {
+        let tree_height = 20;
+
+        let mut tree = pmtree::MerkleTree::<MemoryDB, PoseidonHash>::default(tree_height).unwrap();
+
+        let leaf_index = 3;
+
+        let identity_secret = hash_to_field(b"test-merkle-proof");
+        let id_commitment = poseidon_hash(&[identity_secret]);
+
+        // let default_leaf = Fr::from(0);
+        tree.set(leaf_index, id_commitment).unwrap();
+
+        // We check correct computation of the root
+        let root = tree.root();
+
+        assert_eq!(
+            root,
+            str_to_fr(
+                "0x21947ffd0bce0c385f876e7c97d6a42eec5b1fe935aab2f01c1f8a8cbcc356d2",
+                16
+            )
+            .unwrap()
+        );
+
+        let merkle_proof = tree.proof(leaf_index).expect("proof should exist");
+        let path_elements = merkle_proof.get_path_elements();
+        let identity_path_index = merkle_proof.get_path_index();
+
+        // We check correct computation of the path and indexes
+        // These values refers to tree height = 20
+        let expected_path_elements = vec![
+            str_to_fr(
+                "0x0000000000000000000000000000000000000000000000000000000000000000",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
+                16,
+            )
+            .unwrap(),
+        ];
+
+        let expected_identity_path_index: Vec<u8> =
+            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        assert_eq!(path_elements, expected_path_elements);
+        assert_eq!(identity_path_index, expected_identity_path_index);
+
+        // We check correct verification of the proof
+        assert!(tree.verify(&id_commitment, &merkle_proof));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_pmtree_sled() -> Result<()> {
+        let tree_height = 20;
+
+        let mut tree = pmtree::MerkleTree::<SledDB, PoseidonHash>::default(tree_height).unwrap();
+
+        let leaf_index = 3;
+
+        let identity_secret = hash_to_field(b"test-merkle-proof");
+        let id_commitment = poseidon_hash(&[identity_secret]);
+
+        // let default_leaf = Fr::from(0);
+        tree.set(leaf_index, id_commitment).unwrap();
+
+        // We check correct computation of the root
+        let root = tree.root();
+
+        assert_eq!(
+            root,
+            str_to_fr(
+                "0x21947ffd0bce0c385f876e7c97d6a42eec5b1fe935aab2f01c1f8a8cbcc356d2",
+                16
+            )
+            .unwrap()
+        );
+
+        let merkle_proof = tree.proof(leaf_index).expect("proof should exist");
+        let path_elements = merkle_proof.get_path_elements();
+        let identity_path_index = merkle_proof.get_path_index();
+
+        // We check correct computation of the path and indexes
+        // These values refers to tree height = 20
+        let expected_path_elements = vec![
+            str_to_fr(
+                "0x0000000000000000000000000000000000000000000000000000000000000000",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
+                16,
+            )
+            .unwrap(),
+        ];
+
+        let expected_identity_path_index: Vec<u8> =
+            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        assert_eq!(path_elements, expected_path_elements);
+        assert_eq!(identity_path_index, expected_identity_path_index);
+
+        // We check correct verification of the proof
+        assert!(tree.verify(&id_commitment, &merkle_proof));
+
+        Ok(())
+    }
+}
--- a/rln/tests/protocol.rs
+++ b/rln/tests/protocol.rs
@@ -0,0 +1,502 @@
+#[cfg(test)]
+mod test {
+    use rln::circuit::{
+        circom_from_folder, vk_from_folder, zkey_from_folder, Fr, TEST_RESOURCES_FOLDER,
+        TEST_TREE_HEIGHT,
+    };
+    use rln::poseidon_hash::poseidon_hash;
+    use rln::poseidon_tree::PoseidonTree;
+    use rln::protocol::*;
+    use rln::utils::str_to_fr;
+
+    // Input generated with https://github.com/oskarth/zk-kit/commit/b6a872f7160c7c14e10a0ea40acab99cbb23c9a8
+    const WITNESS_JSON_15: &str = r#"
+            {
+              "identity_secret": "12825549237505733615964533204745049909430608936689388901883576945030025938736",
+              "path_elements": [
+                "18622655742232062119094611065896226799484910997537830749762961454045300666333",
+                "20590447254980891299813706518821659736846425329007960381537122689749540452732",
+                "7423237065226347324353380772367382631490014989348495481811164164159255474657",
+                "11286972368698509976183087595462810875513684078608517520839298933882497716792",
+                "3607627140608796879659380071776844901612302623152076817094415224584923813162",
+                "19712377064642672829441595136074946683621277828620209496774504837737984048981",
+                "20775607673010627194014556968476266066927294572720319469184847051418138353016",
+                "3396914609616007258851405644437304192397291162432396347162513310381425243293",
+                "21551820661461729022865262380882070649935529853313286572328683688269863701601",
+                "6573136701248752079028194407151022595060682063033565181951145966236778420039",
+                "12413880268183407374852357075976609371175688755676981206018884971008854919922",
+                "14271763308400718165336499097156975241954733520325982997864342600795471836726",
+                "20066985985293572387227381049700832219069292839614107140851619262827735677018",
+                "9394776414966240069580838672673694685292165040808226440647796406499139370960",
+                "11331146992410411304059858900317123658895005918277453009197229807340014528524"
+              ],
+              "identity_path_index": [
+                1,
+                1,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0
+              ],
+              "x": "8143228284048792769012135629627737459844825626241842423967352803501040982",
+              "epoch": "0x0000005b612540fc986b42322f8cb91c2273afad58ed006fdba0c97b4b16b12f",
+              "rln_identifier": "11412926387081627876309792396682864042420635853496105400039841573530884328439"
+            }
+        "#;
+
+    // Input generated with protocol::random_rln_witness
+    const WITNESS_JSON_19: &str = r#"
+            {
+              "identity_secret": "922538810348594125658702672067738675294669207539999802857585668079702330450",
+              "path_elements": [
+                  "16059714054680148404543504061485737353203416489071538960876865983954285286166",
+                  "3041470753871943901334053763207316028823782848445723460227667780327106380356",
+                  "2557297527793326315072058421057853700096944625924483912548759909801348042183",
+                  "6677578602456189582427063963562590713054668181987223110955234085327917303436",
+                  "2250827150965576973906150764756422151438812678308727218463995574869267980301",
+                  "1895457427602709606993445561553433669787657053834360973759981803464906070980",
+                  "11033689991077061346803816826729204895841441316315304395980565540264104346466",
+                  "18588752216879570844240300406954267039026327526134910835334500497981810174976",
+                  "19346480964028499661277403659363466542857230928032088490855656809181891953123",
+                  "21460193770370072688835316363068413651465631481105148051902686770759127189327",
+                  "20906347653364838502964722817589315918082261023317339146393355650507243340078",
+                  "13466599592974387800162739317046838825289754472645703919149409009404541432954",
+                  "9617165663598957201253074168824246164494443748556931540348223968573884172285",
+                  "6936463137584425684797785981770877165377386163416057257854261010817156666898",
+                  "369902028235468424790098825415813437044876310542601948037281422841675126849",
+                  "13510969869821080499683463562609720931680005714401083864659516045615497273644",
+                  "2567921390740781421487331055530491683313154421589525170472201828596388395736",
+                  "14360870889466292805403568662660511177232987619663547772298178013674025998478",
+                  "4735344599616284973799984501493858013178071155960162022656706545116168334293"
+              ],
+              "identity_path_index": [
+                  1,
+                  0,
+                  1,
+                  0,
+                  1,
+                  1,
+                  0,
+                  0,
+                  1,
+                  1,
+                  1,
+                  0,
+                  0,
+                  0,
+                  1,
+                  0,
+                  1,
+                  1,
+                  0
+              ],
+              "x": "6427050788896290028100534859169645070970780055911091444144195464808120686416",
+              "epoch": "0x2bd155d9f85c741044da6909d144f9cc5ce8e0d545a9ed4921b156e8b8569bab",
+              "rln_identifier": "2193983000213424579594329476781986065965849144986973472766961413131458022566"
+            }
+        "#;
+
+    const WITNESS_JSON_20: &str = r#"
+            {
+              "identity_secret": "13732353453861280511150022598793312186188599006979552959297495195757997428306",
+              "path_elements": [
+                  "20463525608687844300981085488128968694844212760055234622292326942405619575964",
+                  "8040856403709217901175408904825741112286158901303127670929462145501210871313",
+                  "3776499751255585163563840252112871568402966629435152937692711318702338789837",
+                  "19415813252626942110541463414404411443562242499365750694284604341271149125679",
+                  "19414720788761208006634240390286942738242262010168559813148115573784354129237",
+                  "17680594732844291740094158892269696200077963275550625226493856898849422516043",
+                  "16009199741350632715210088346611798597033333293348807000623441780059543674510",
+                  "18743496911007535170857676824393811326863602477260615792503039058813338644738",
+                  "1029572792321380246989475723806770724699749375691788486434716005338938722216",
+                  "21713138150151063186050010182615713685603650963220209951496401043119768920892",
+                  "6713732504049401389983008178456811894856018247924860823028704114266363984580",
+                  "2746686888799473963221285145390361693256731812094259845879519459924507786594",
+                  "18620748467731297359505500266677881218553438497271819903304075323783392031715",
+                  "2446201221122671119406471414204229600430018713181038717206670749886932158104",
+                  "12037171942017611311954851302868199608036334625783560875426350283156617524597",
+                  "21798743392351780927808323348278035105395367759688979232116905142049921734349",
+                  "17450230289417496971557215666910229260621413088991137405744457922069827319039",
+                  "20936854099128086256353520300046664152516566958630447858438908748907198510485",
+                  "13513344965831154386658059617477268600255664386844920822248038939666265737046",
+                  "15546319496880899251450021422131511560001766832580480193115646510655765306630"
+
+              ],
+              "identity_path_index": [
+                  0,
+                  1,
+                  0,
+                  0,
+                  1,
+                  1,
+                  0,
+                  0,
+                  1,
+                  1,
+                  0,
+                  0,
+                  0,
+                  1,
+                  0,
+                  1,
+                  1,
+                  0,
+                  0,
+                  0
+              ],
+              "x": "18073935665561339809445069958310044423750771681863480888589546877024349720547",
+              "epoch": "0x147e4c23a43a1ddca78d94bcd28147f62ca74b3dc7e56bb0a314a954b9f0e567",
+              "rln_identifier": "2193983000213424579594329476781986065965849144986973472766961413131458022566"
+            }
+        "#;
+
+    #[test]
+    // We test Merkle tree generation, proofs and verification
+    fn test_merkle_proof() {
+        let tree_height = TEST_TREE_HEIGHT;
+        let leaf_index = 3;
+
+        // generate identity
+        let identity_secret_hash = hash_to_field(b"test-merkle-proof");
+        let id_commitment = poseidon_hash(&vec![identity_secret_hash]);
+
+        // generate merkle tree
+        let default_leaf = Fr::from(0);
+        let mut tree = PoseidonTree::new(tree_height, default_leaf);
+        tree.set(leaf_index, id_commitment.into()).unwrap();
+
+        // We check correct computation of the root
+        let root = tree.root();
+
+        if TEST_TREE_HEIGHT == 15 {
+            assert_eq!(
+                root,
+                str_to_fr(
+                    "0x1984f2e01184aef5cb974640898a5f5c25556554e2b06d99d4841badb8b198cd",
+                    16
+                )
+                .unwrap()
+            );
+        } else if TEST_TREE_HEIGHT == 19 {
+            assert_eq!(
+                root,
+                str_to_fr(
+                    "0x219ceb53f2b1b7a6cf74e80d50d44d68ecb4a53c6cc65b25593c8d56343fb1fe",
+                    16
+                )
+                .unwrap()
+            );
+        } else if TEST_TREE_HEIGHT == 20 {
+            assert_eq!(
+                root,
+                str_to_fr(
+                    "0x21947ffd0bce0c385f876e7c97d6a42eec5b1fe935aab2f01c1f8a8cbcc356d2",
+                    16
+                )
+                .unwrap()
+            );
+        }
+
+        let merkle_proof = tree.proof(leaf_index).expect("proof should exist");
+        let path_elements = merkle_proof.get_path_elements();
+        let identity_path_index = merkle_proof.get_path_index();
+
+        // We check correct computation of the path and indexes
+        // These values refers to TEST_TREE_HEIGHT == 16
+        let mut expected_path_elements = vec![
+            str_to_fr(
+                "0x0000000000000000000000000000000000000000000000000000000000000000",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
+                16,
+            )
+            .unwrap(),
+        ];
+
+        let mut expected_identity_path_index: Vec<u8> =
+            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        // We add the remaining elements for the case TEST_TREE_HEIGHT = 20
+        if TEST_TREE_HEIGHT == 19 || TEST_TREE_HEIGHT == 20 {
+            expected_path_elements.append(&mut vec![
+                str_to_fr(
+                    "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
+                    16,
+                )
+                .unwrap(),
+            ]);
+            expected_identity_path_index.append(&mut vec![0, 0, 0, 0]);
+        }
+
+        if TEST_TREE_HEIGHT == 20 {
+            expected_path_elements.append(&mut vec![str_to_fr(
+                "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
+                16,
+            )
+            .unwrap()]);
+            expected_identity_path_index.append(&mut vec![0]);
+        }
+
+        assert_eq!(path_elements, expected_path_elements);
+        assert_eq!(identity_path_index, expected_identity_path_index);
+
+        // We check correct verification of the proof
+        assert!(tree.verify(&id_commitment, &merkle_proof).unwrap());
+    }
+
+    #[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(TEST_RESOURCES_FOLDER).unwrap();
+        let verification_key = vk_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+        let builder = circom_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+
+        // We compute witness from the json input example
+        let mut witness_json: &str = "";
+
+        if TEST_TREE_HEIGHT == 15 {
+            witness_json = WITNESS_JSON_15;
+        } else if TEST_TREE_HEIGHT == 19 {
+            witness_json = WITNESS_JSON_19;
+        } else if TEST_TREE_HEIGHT == 20 {
+            witness_json = WITNESS_JSON_20;
+        }
+
+        let rln_witness = rln_witness_from_json(witness_json);
+
+        let rln_witness_unwrapped = rln_witness.unwrap();
+
+        // Let's generate a zkSNARK proof
+        let proof = generate_proof(builder, &proving_key, &rln_witness_unwrapped).unwrap();
+
+        let proof_values = proof_values_from_witness(&rln_witness_unwrapped);
+
+        // Let's verify the proof
+        let verified = verify_proof(&verification_key, &proof, &proof_values);
+
+        assert!(verified.unwrap());
+    }
+
+    #[test]
+    // We test a RLN proof generation and verification
+    fn test_end_to_end() {
+        let tree_height = TEST_TREE_HEIGHT;
+        let leaf_index = 3;
+
+        // Generate identity pair
+        let (identity_secret_hash, id_commitment) = keygen();
+
+        //// generate merkle tree
+        let default_leaf = Fr::from(0);
+        let mut tree = PoseidonTree::new(tree_height, default_leaf);
+        tree.set(leaf_index, id_commitment.into()).unwrap();
+
+        let merkle_proof = tree.proof(leaf_index).expect("proof should exist");
+
+        let signal = b"hey hey";
+        let x = hash_to_field(signal);
+
+        // We set the remaining values to random ones
+        let epoch = hash_to_field(b"test-epoch");
+        //let rln_identifier = hash_to_field(b"test-rln-identifier");
+
+        let rln_witness: RLNWitnessInput = rln_witness_from_values(
+            identity_secret_hash,
+            &merkle_proof,
+            x,
+            epoch, /*, rln_identifier*/
+        );
+
+        // We generate all relevant keys
+        let proving_key = zkey_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+        let verification_key = vk_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+        let builder = circom_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+
+        // Let's generate a zkSNARK proof
+        let proof = generate_proof(builder, &proving_key, &rln_witness).unwrap();
+
+        let proof_values = proof_values_from_witness(&rln_witness);
+
+        // Let's verify the proof
+        let success = verify_proof(&verification_key, &proof, &proof_values).unwrap();
+
+        assert!(success);
+    }
+
+    #[test]
+    fn test_witness_serialization() {
+        // We test witness serialization
+        let mut witness_json: &str = "";
+
+        if TEST_TREE_HEIGHT == 15 {
+            witness_json = WITNESS_JSON_15;
+        } else if TEST_TREE_HEIGHT == 19 {
+            witness_json = WITNESS_JSON_19;
+        } else if TEST_TREE_HEIGHT == 20 {
+            witness_json = WITNESS_JSON_20;
+        }
+
+        let rln_witness = rln_witness_from_json(witness_json).unwrap();
+
+        let ser = serialize_witness(&rln_witness).unwrap();
+        let (deser, _) = deserialize_witness(&ser).unwrap();
+        assert_eq!(rln_witness, deser);
+
+        // We test Proof values serialization
+        let proof_values = proof_values_from_witness(&rln_witness);
+        let ser = serialize_proof_values(&proof_values);
+        let (deser, _) = deserialize_proof_values(&ser);
+        assert_eq!(proof_values, deser);
+    }
+
+    #[test]
+    // Tests seeded keygen
+    // Note that hardcoded values are only valid for Bn254
+    fn test_seeded_keygen() {
+        // Generate identity pair using a seed phrase
+        let seed_phrase: &str = "A seed phrase example";
+        let (identity_secret_hash, id_commitment) = seeded_keygen(seed_phrase.as_bytes());
+
+        // We check against expected values
+        let expected_identity_secret_hash_seed_phrase = str_to_fr(
+            "0x20df38f3f00496f19fe7c6535492543b21798ed7cb91aebe4af8012db884eda3",
+            16,
+        )
+        .unwrap();
+        let expected_id_commitment_seed_phrase = str_to_fr(
+            "0x1223a78a5d66043a7f9863e14507dc80720a5602b2a894923e5b5147d5a9c325",
+            16,
+        )
+        .unwrap();
+
+        assert_eq!(
+            identity_secret_hash,
+            expected_identity_secret_hash_seed_phrase
+        );
+        assert_eq!(id_commitment, expected_id_commitment_seed_phrase);
+
+        // Generate identity pair using an byte array
+        let seed_bytes: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let (identity_secret_hash, id_commitment) = seeded_keygen(seed_bytes);
+
+        // We check against expected values
+        let expected_identity_secret_hash_seed_bytes = str_to_fr(
+            "0x766ce6c7e7a01bdf5b3f257616f603918c30946fa23480f2859c597817e6716",
+            16,
+        )
+        .unwrap();
+        let expected_id_commitment_seed_bytes = str_to_fr(
+            "0xbf16d2b5c0d6f9d9d561e05bfca16a81b4b873bb063508fae360d8c74cef51f",
+            16,
+        )
+        .unwrap();
+
+        assert_eq!(
+            identity_secret_hash,
+            expected_identity_secret_hash_seed_bytes
+        );
+        assert_eq!(id_commitment, expected_id_commitment_seed_bytes);
+
+        // We check again if the identity pair generated with the same seed phrase corresponds to the previously generated one
+        let (identity_secret_hash, id_commitment) = seeded_keygen(seed_phrase.as_bytes());
+
+        assert_eq!(
+            identity_secret_hash,
+            expected_identity_secret_hash_seed_phrase
+        );
+        assert_eq!(id_commitment, expected_id_commitment_seed_phrase);
+    }
+}
--- a/rln/tests/public.rs
+++ b/rln/tests/public.rs
@@ -0,0 +1,317 @@
+#[cfg(test)]
+mod test {
+    use ark_std::{rand::thread_rng, UniformRand};
+    use rand::Rng;
+    use rln::circuit::{Fr, TEST_RESOURCES_FOLDER, TEST_TREE_HEIGHT};
+    use rln::poseidon_hash::{poseidon_hash as utils_poseidon_hash, ROUND_PARAMS};
+    use rln::protocol::{compute_tree_root, deserialize_identity_tuple, hash_to_field};
+    use rln::public::{hash as public_hash, poseidon_hash as public_poseidon_hash, RLN};
+    use rln::utils::*;
+    use std::io::Cursor;
+
+    #[test]
+    // This test is similar to the one in lib, but uses only public API
+    fn test_merkle_proof() {
+        let tree_height = TEST_TREE_HEIGHT;
+        let leaf_index = 3;
+
+        let input_buffer = Cursor::new(TEST_RESOURCES_FOLDER);
+        let mut rln = RLN::new(tree_height, input_buffer).unwrap();
+
+        // generate identity
+        let identity_secret_hash = hash_to_field(b"test-merkle-proof");
+        let id_commitment = utils_poseidon_hash(&vec![identity_secret_hash]);
+
+        // We pass id_commitment as Read buffer to RLN's set_leaf
+        let mut buffer = Cursor::new(fr_to_bytes_le(&id_commitment));
+        rln.set_leaf(leaf_index, &mut buffer).unwrap();
+
+        // We check correct computation of the root
+        let mut buffer = Cursor::new(Vec::<u8>::new());
+        rln.get_root(&mut buffer).unwrap();
+        let (root, _) = bytes_le_to_fr(&buffer.into_inner());
+
+        if TEST_TREE_HEIGHT == 15 {
+            assert_eq!(
+                root,
+                str_to_fr(
+                    "0x1984f2e01184aef5cb974640898a5f5c25556554e2b06d99d4841badb8b198cd",
+                    16
+                )
+                .unwrap()
+            );
+        } else if TEST_TREE_HEIGHT == 19 {
+            assert_eq!(
+                root,
+                str_to_fr(
+                    "0x219ceb53f2b1b7a6cf74e80d50d44d68ecb4a53c6cc65b25593c8d56343fb1fe",
+                    16
+                )
+                .unwrap()
+            );
+        } else if TEST_TREE_HEIGHT == 20 {
+            assert_eq!(
+                root,
+                str_to_fr(
+                    "0x21947ffd0bce0c385f876e7c97d6a42eec5b1fe935aab2f01c1f8a8cbcc356d2",
+                    16
+                )
+                .unwrap()
+            );
+        }
+
+        // We check correct computation of merkle proof
+        let mut buffer = Cursor::new(Vec::<u8>::new());
+        rln.get_proof(leaf_index, &mut buffer).unwrap();
+
+        let buffer_inner = buffer.into_inner();
+        let (path_elements, read) = bytes_le_to_vec_fr(&buffer_inner).unwrap();
+        let (identity_path_index, _) = bytes_le_to_vec_u8(&buffer_inner[read..].to_vec()).unwrap();
+
+        // We check correct computation of the path and indexes
+        let mut expected_path_elements = vec![
+            str_to_fr(
+                "0x0000000000000000000000000000000000000000000000000000000000000000",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
+                16,
+            )
+            .unwrap(),
+        ];
+
+        let mut expected_identity_path_index: Vec<u8> =
+            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        // We add the remaining elements for the case TEST_TREE_HEIGHT = 20
+        if TEST_TREE_HEIGHT == 19 || TEST_TREE_HEIGHT == 20 {
+            expected_path_elements.append(&mut vec![
+                str_to_fr(
+                    "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
+                    16,
+                )
+                .unwrap(),
+            ]);
+            expected_identity_path_index.append(&mut vec![0, 0, 0, 0]);
+        }
+
+        if TEST_TREE_HEIGHT == 20 {
+            expected_path_elements.append(&mut vec![str_to_fr(
+                "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
+                16,
+            )
+            .unwrap()]);
+            expected_identity_path_index.append(&mut vec![0]);
+        }
+
+        assert_eq!(path_elements, expected_path_elements);
+        assert_eq!(identity_path_index, expected_identity_path_index);
+
+        // We double check that the proof computed from public API is correct
+        let root_from_proof =
+            compute_tree_root(&id_commitment, &path_elements, &identity_path_index, false);
+
+        assert_eq!(root, root_from_proof);
+    }
+
+    #[test]
+    fn test_seeded_keygen() {
+        let rln = RLN::default();
+
+        let seed_bytes: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+        let mut input_buffer = Cursor::new(&seed_bytes);
+        let mut output_buffer = Cursor::new(Vec::<u8>::new());
+
+        rln.seeded_key_gen(&mut input_buffer, &mut output_buffer)
+            .unwrap();
+        let serialized_output = output_buffer.into_inner();
+
+        let (identity_secret_hash, read) = bytes_le_to_fr(&serialized_output);
+        let (id_commitment, _) = bytes_le_to_fr(&serialized_output[read..].to_vec());
+
+        // We check against expected values
+        let expected_identity_secret_hash_seed_bytes = str_to_fr(
+            "0x766ce6c7e7a01bdf5b3f257616f603918c30946fa23480f2859c597817e6716",
+            16,
+        )
+        .unwrap();
+        let expected_id_commitment_seed_bytes = str_to_fr(
+            "0xbf16d2b5c0d6f9d9d561e05bfca16a81b4b873bb063508fae360d8c74cef51f",
+            16,
+        )
+        .unwrap();
+
+        assert_eq!(
+            identity_secret_hash,
+            expected_identity_secret_hash_seed_bytes
+        );
+        assert_eq!(id_commitment, expected_id_commitment_seed_bytes);
+    }
+
+    #[test]
+    fn test_seeded_extended_keygen() {
+        let rln = RLN::default();
+
+        let seed_bytes: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+        let mut input_buffer = Cursor::new(&seed_bytes);
+        let mut output_buffer = Cursor::new(Vec::<u8>::new());
+
+        rln.seeded_extended_key_gen(&mut input_buffer, &mut output_buffer)
+            .unwrap();
+        let serialized_output = output_buffer.into_inner();
+
+        let (identity_trapdoor, identity_nullifier, identity_secret_hash, id_commitment) =
+            deserialize_identity_tuple(serialized_output);
+
+        // We check against expected values
+        let expected_identity_trapdoor_seed_bytes = str_to_fr(
+            "0x766ce6c7e7a01bdf5b3f257616f603918c30946fa23480f2859c597817e6716",
+            16,
+        )
+        .unwrap();
+        let expected_identity_nullifier_seed_bytes = str_to_fr(
+            "0x1f18714c7bc83b5bca9e89d404cf6f2f585bc4c0f7ed8b53742b7e2b298f50b4",
+            16,
+        )
+        .unwrap();
+        let expected_identity_secret_hash_seed_bytes = str_to_fr(
+            "0x2aca62aaa7abaf3686fff2caf00f55ab9462dc12db5b5d4bcf3994e671f8e521",
+            16,
+        )
+        .unwrap();
+        let expected_id_commitment_seed_bytes = str_to_fr(
+            "0x68b66aa0a8320d2e56842581553285393188714c48f9b17acd198b4f1734c5c",
+            16,
+        )
+        .unwrap();
+
+        assert_eq!(identity_trapdoor, expected_identity_trapdoor_seed_bytes);
+        assert_eq!(identity_nullifier, expected_identity_nullifier_seed_bytes);
+        assert_eq!(
+            identity_secret_hash,
+            expected_identity_secret_hash_seed_bytes
+        );
+        assert_eq!(id_commitment, expected_id_commitment_seed_bytes);
+    }
+
+    #[test]
+    fn test_hash_to_field() {
+        let mut rng = thread_rng();
+        let signal: [u8; 32] = rng.gen();
+
+        let mut input_buffer = Cursor::new(&signal);
+        let mut output_buffer = Cursor::new(Vec::<u8>::new());
+
+        public_hash(&mut input_buffer, &mut output_buffer).unwrap();
+        let serialized_hash = output_buffer.into_inner();
+        let (hash1, _) = bytes_le_to_fr(&serialized_hash);
+
+        let hash2 = hash_to_field(&signal);
+
+        assert_eq!(hash1, hash2);
+    }
+
+    #[test]
+    fn test_poseidon_hash() {
+        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 expected_hash = utils_poseidon_hash(&inputs);
+
+        let mut input_buffer = Cursor::new(vec_fr_to_bytes_le(&inputs).unwrap());
+        let mut output_buffer = Cursor::new(Vec::<u8>::new());
+
+        public_poseidon_hash(&mut input_buffer, &mut output_buffer).unwrap();
+        let serialized_hash = output_buffer.into_inner();
+        let (hash, _) = bytes_le_to_fr(&serialized_hash);
+
+        assert_eq!(hash, expected_hash);
+    }
+}
--- a/rln/vendor/rln
+++ b/rln/vendor/rln
--- a/semaphore/Cargo.toml
+++ b/semaphore/Cargo.toml
@@ -2,6 +2,7 @@
 name = "semaphore-wrapper"
 version = "0.1.0"
 edition = "2021"
+license = "MIT OR Apache-2.0"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -16,12 +17,12 @@ ark-ec = { version = "0.3.0", default-features = false, features = ["parallel"]
 ark-groth16 = { git = "https://github.com/arkworks-rs/groth16", rev = "765817f", features = ["parallel"] }
 ark-relations = { version = "0.3.0", default-features = false }
 ark-std = { version = "0.3.0", default-features = false, features = ["parallel"] }
-color-eyre = "0.5"
-num-bigint = { version = "0.4", default-features = false, features = ["rand"] }
+color-eyre = "0.6.1"
 once_cell = "1.8"
-primitive-types = "0.11.1"
 rand = "0.8.4"
-semaphore = { git = "https://github.com/worldcoin/semaphore-rs", rev = "d462a43"}
+semaphore = { git = "https://github.com/worldcoin/semaphore-rs", rev = "ee658c2"}
+ethers-core = { git = "https://github.com/gakonst/ethers-rs", default-features = false }
+ruint = { version = "1.2.0", features = [ "serde", "num-bigint", "ark-ff" ] }
 serde = "1.0"
 thiserror = "1.0.0"
 wasmer = { version = "2.0" }
@@ -31,10 +32,10 @@ rand_chacha = "0.3.1"
 serde_json = "1.0.79"

 [build-dependencies]
-color-eyre = "0.5"
+color-eyre = "0.6.1"
 wasmer = { version = "2.0" }
 wasmer-engine-dylib = { version = "2.2.1", optional = true }
-wasmer-compiler-cranelift = { version = "2.2.1", optional = true }
+wasmer-compiler-cranelift = { version = "3.1.1", optional = true }

 [profile.release]
 codegen-units = 1
@@ -46,4 +47,4 @@ opt-level = 3
 # Dependencies are optimized, even in a dev build. This improves dev performance
 # while having neglible impact on incremental build times.
 [profile.dev.package."*"]
-opt-level = 3
+opt-level = 3
--- a/semaphore/Makefile.toml
+++ b/semaphore/Makefile.toml
@@ -0,0 +1,7 @@
+[tasks.build]
+command = "cargo"
+args = ["build", "--release"]
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--release"]
--- a/semaphore/README.md
+++ b/semaphore/README.md
@@ -8,3 +8,11 @@ Goal is also to provide a basic FFI around protocol.rs, which is currently not
 in scope for that project.

 See that project for more information.
+
+## Build and Test
+
+To build and test, run the following commands within the module folder
+```bash
+cargo make build
+cargo make test
+```
--- a/semaphore/build.rs
+++ b/semaphore/build.rs
@@ -37,7 +37,7 @@ fn build_circuit() -> Result<()> {
            .current_dir("./vendor/semaphore")
            .status()?
            .success()
-            .then(|| ())
+            .then_some(())
            .ok_or(eyre!("procees returned failure"))?;
        Ok(())
    };
--- a/semaphore/src/circuit.rs
+++ b/semaphore/src/circuit.rs
@@ -50,7 +50,7 @@ fn from_dylib(path: &Path) -> Mutex<WitnessCalculator> {

 #[must_use]
 pub fn zkey() -> &'static (ProvingKey<Bn254>, ConstraintMatrices<Fr>) {
-    &*ZKEY
+    &ZKEY
 }

 #[cfg(feature = "dylib")]
--- a/semaphore/src/lib.rs
+++ b/semaphore/src/lib.rs
@@ -5,43 +5,3 @@ pub mod protocol;

 #[cfg(feature = "dylib")]
 pub use circuit::initialize;
-
-#[cfg(test)]
-mod tests {
-    use crate::protocol::*;
-    use semaphore::{hash_to_field, identity::Identity, poseidon_tree::PoseidonTree, Field};
-
-    #[test]
-    fn test_semaphore() {
-        // generate identity
-        let id = Identity::from_seed(b"secret");
-
-        // generate merkle tree
-        let leaf = Field::from(0);
-        let mut tree = PoseidonTree::new(21, leaf);
-        tree.set(0, id.commitment());
-
-        let merkle_proof = tree.proof(0).expect("proof should exist");
-        let root = tree.root().into();
-
-        // change signal and external_nullifier here
-        let signal_hash = hash_to_field(b"xxx");
-        let external_nullifier_hash = hash_to_field(b"appId");
-
-        let nullifier_hash = generate_nullifier_hash(&id, external_nullifier_hash);
-
-        let proof =
-            generate_proof(&id, &merkle_proof, external_nullifier_hash, signal_hash).unwrap();
-
-        let success = verify_proof(
-            root,
-            nullifier_hash,
-            signal_hash,
-            external_nullifier_hash,
-            &proof,
-        )
-        .unwrap();
-
-        assert!(success);
-    }
-}
--- a/semaphore/src/protocol.rs
+++ b/semaphore/src/protocol.rs
@@ -12,13 +12,13 @@ use ark_groth16::{
 };
 use ark_relations::r1cs::SynthesisError;
 use ark_std::UniformRand;
-use color_eyre::Result;
-use primitive_types::U256;
+use color_eyre::{Report, Result};
+use ethers_core::types::U256;
 use rand::{thread_rng, Rng};
 use semaphore::{
    identity::Identity,
    merkle_tree::{self, Branch},
-    poseidon_hash,
+    poseidon,
    poseidon_tree::PoseidonHash,
    Field,
 };
@@ -81,7 +81,7 @@ fn merkle_proof_to_vec(proof: &merkle_tree::Proof<PoseidonHash>) -> Vec<Field> {
 /// Generates the nullifier hash
 #[must_use]
 pub fn generate_nullifier_hash(identity: &Identity, external_nullifier: Field) -> Field {
-    poseidon_hash(&[external_nullifier, identity.nullifier])
+    poseidon::hash2(external_nullifier, identity.nullifier)
 }

 #[derive(Error, Debug)]
@@ -89,9 +89,11 @@ pub enum ProofError {
    #[error("Error reading circuit key: {0}")]
    CircuitKeyError(#[from] std::io::Error),
    #[error("Error producing witness: {0}")]
-    WitnessError(color_eyre::Report),
+    WitnessError(Report),
    #[error("Error producing proof: {0}")]
    SynthesisError(#[from] SynthesisError),
+    #[error("Error converting public input: {0}")]
+    ToFieldError(#[from] ruint::ToFieldError),
 }

 /// Generates a semaphore proof
@@ -202,90 +204,12 @@ pub fn verify_proof(
    let zkey = zkey();
    let pvk = prepare_verifying_key(&zkey.0.vk);

-    let public_inputs = [
-        root.into(),
-        nullifier_hash.into(),
-        signal_hash.into(),
-        external_nullifier_hash.into(),
-    ];
+    let public_inputs = [root, nullifier_hash, signal_hash, external_nullifier_hash]
+        .iter()
+        .map(ark_bn254::Fr::try_from)
+        .collect::<Result<Vec<_>, _>>()?;
+
    let ark_proof = (*proof).into();
    let result = ark_groth16::verify_proof(&pvk, &ark_proof, &public_inputs[..])?;
    Ok(result)
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use rand::SeedableRng as _;
-    use rand_chacha::ChaChaRng;
-    use semaphore::{hash_to_field, poseidon_tree::PoseidonTree};
-    use serde_json::json;
-
-    fn arb_proof(seed: u64) -> Proof {
-        // Deterministic randomness for testing
-        let mut rng = ChaChaRng::seed_from_u64(seed);
-
-        // generate identity
-        let seed: [u8; 16] = rng.gen();
-        let id = Identity::from_seed(&seed);
-
-        // generate merkle tree
-        let leaf = Field::from(0);
-        let mut tree = PoseidonTree::new(21, leaf);
-        tree.set(0, id.commitment());
-
-        let merkle_proof = tree.proof(0).expect("proof should exist");
-
-        let external_nullifier: [u8; 16] = rng.gen();
-        let external_nullifier_hash = hash_to_field(&external_nullifier);
-
-        let signal: [u8; 16] = rng.gen();
-        let signal_hash = hash_to_field(&signal);
-
-        generate_proof_rng(
-            &id,
-            &merkle_proof,
-            external_nullifier_hash,
-            signal_hash,
-            &mut rng,
-        )
-        .unwrap()
-    }
-
-    #[test]
-    fn test_proof_cast_roundtrip() {
-        let proof = arb_proof(123);
-        let ark_proof: ArkProof<Bn<Parameters>> = proof.into();
-        let result: Proof = ark_proof.into();
-        assert_eq!(proof, result);
-    }
-
-    #[test]
-    fn test_proof_serialize() {
-        let proof = arb_proof(456);
-        let json = serde_json::to_value(&proof).unwrap();
-        assert_eq!(
-            json,
-            json!([
-                [
-                    "0x249ae469686987ee9368da60dd177a8c42891c02f5760e955e590c79d55cfab2",
-                    "0xf22e25870f49388459d388afb24dcf6ec11bb2d4def1e2ec26d6e42f373aad8"
-                ],
-                [
-                    [
-                        "0x17bd25dbd7436c30ea5b8a3a47aadf11ed646c4b25cc14a84ff8cbe0252ff1f8",
-                        "0x1c140668c56688367416534d57b4a14e5a825efdd5e121a6a2099f6dc4cd277b"
-                    ],
-                    [
-                        "0x26a8524759d969ea0682a092cf7a551697d81962d6c998f543f81e52d83e05e1",
-                        "0x273eb3f796fd1807b9df9c6d769d983e3dabdc61677b75d48bb7691303b2c8dd"
-                    ]
-                ],
-                [
-                    "0x62715c53a0eb4c46dbb5f73f1fd7449b9c63d37c1ece65debc39b472065a90f",
-                    "0x114f7becc66f1cd7a8b01c89db8233622372fc0b6fc037c4313bca41e2377fd9"
-                ]
-            ])
-        );
-    }
-}
--- a/semaphore/tests/protocol.rs
+++ b/semaphore/tests/protocol.rs
@@ -0,0 +1,115 @@
+#[cfg(test)]
+mod tests {
+    use ark_bn254::Parameters;
+    use ark_ec::bn::Bn;
+    use ark_groth16::Proof as ArkProof;
+    use rand::{Rng, SeedableRng as _};
+    use rand_chacha::ChaChaRng;
+    use semaphore::{hash_to_field, identity::Identity, poseidon_tree::PoseidonTree, Field};
+    use semaphore_wrapper::protocol::{
+        generate_nullifier_hash, generate_proof, generate_proof_rng, verify_proof, Proof,
+    };
+    use serde_json::json;
+
+    #[test]
+    fn test_semaphore() {
+        // generate identity
+        let id = Identity::from_seed(b"secret");
+
+        // generate merkle tree
+        let leaf = Field::from(0);
+        let mut tree = PoseidonTree::new(21, leaf);
+        tree.set(0, id.commitment());
+
+        let merkle_proof = tree.proof(0).expect("proof should exist");
+        let root = tree.root().into();
+
+        // change signal and external_nullifier here
+        let signal_hash = hash_to_field(b"xxx");
+        let external_nullifier_hash = hash_to_field(b"appId");
+
+        let nullifier_hash = generate_nullifier_hash(&id, external_nullifier_hash);
+
+        let proof =
+            generate_proof(&id, &merkle_proof, external_nullifier_hash, signal_hash).unwrap();
+
+        let success = verify_proof(
+            root,
+            nullifier_hash,
+            signal_hash,
+            external_nullifier_hash,
+            &proof,
+        )
+        .unwrap();
+
+        assert!(success);
+    }
+
+    fn arb_proof(seed: u64) -> Proof {
+        // Deterministic randomness for testing
+        let mut rng = ChaChaRng::seed_from_u64(seed);
+
+        // generate identity
+        let seed: [u8; 16] = rng.gen();
+        let id = Identity::from_seed(&seed);
+
+        // generate merkle tree
+        let leaf = Field::from(0);
+        let mut tree = PoseidonTree::new(21, leaf);
+        tree.set(0, id.commitment());
+
+        let merkle_proof = tree.proof(0).expect("proof should exist");
+
+        let external_nullifier: [u8; 16] = rng.gen();
+        let external_nullifier_hash = hash_to_field(&external_nullifier);
+
+        let signal: [u8; 16] = rng.gen();
+        let signal_hash = hash_to_field(&signal);
+
+        generate_proof_rng(
+            &id,
+            &merkle_proof,
+            external_nullifier_hash,
+            signal_hash,
+            &mut rng,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn test_proof_cast_roundtrip() {
+        let proof = arb_proof(123);
+        let ark_proof: ArkProof<Bn<Parameters>> = proof.into();
+        let result: Proof = ark_proof.into();
+        assert_eq!(proof, result);
+    }
+
+    #[test]
+    fn test_proof_serialize() {
+        let proof = arb_proof(456);
+        let json = serde_json::to_value(&proof).unwrap();
+        assert_eq!(
+            json,
+            json!([
+                [
+                    "0x249ae469686987ee9368da60dd177a8c42891c02f5760e955e590c79d55cfab2",
+                    "0xf22e25870f49388459d388afb24dcf6ec11bb2d4def1e2ec26d6e42f373aad8"
+                ],
+                [
+                    [
+                        "0x17bd25dbd7436c30ea5b8a3a47aadf11ed646c4b25cc14a84ff8cbe0252ff1f8",
+                        "0x1c140668c56688367416534d57b4a14e5a825efdd5e121a6a2099f6dc4cd277b"
+                    ],
+                    [
+                        "0x26a8524759d969ea0682a092cf7a551697d81962d6c998f543f81e52d83e05e1",
+                        "0x273eb3f796fd1807b9df9c6d769d983e3dabdc61677b75d48bb7691303b2c8dd"
+                    ]
+                ],
+                [
+                    "0x62715c53a0eb4c46dbb5f73f1fd7449b9c63d37c1ece65debc39b472065a90f",
+                    "0x114f7becc66f1cd7a8b01c89db8233622372fc0b6fc037c4313bca41e2377fd9"
+                ]
+            ])
+        );
+    }
+}
--- a/utils/Cargo.toml
+++ b/utils/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "utils"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+ark-ff = { version = "=0.4.1", default-features = false, features = ["asm"] }
+num-bigint = { version = "=0.4.3", default-features = false, features = ["rand"] }
+color-eyre = "=0.6.2"
+
+[dev-dependencies]
+ark-bn254 = "=0.4.0"
+num-traits = "0.2.11"
+hex-literal = "0.3.4"
+tiny-keccak = { version = "2.0.2", features = ["keccak"] }
+
+[features]
+default = ["parallel"]
+parallel = ["ark-ff/parallel"]
--- a/utils/Makefile.toml
+++ b/utils/Makefile.toml
@@ -0,0 +1,7 @@
+[tasks.build]
+command = "cargo"
+args = ["build", "--release"]
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--release"]
--- a/utils/src/lib.rs
+++ b/utils/src/lib.rs
@@ -0,0 +1,5 @@
+pub mod poseidon;
+pub use self::poseidon::*;
+
+pub mod merkle_tree;
+pub use self::merkle_tree::*;
--- a/utils/src/merkle_tree/merkle_tree.rs
+++ b/utils/src/merkle_tree/merkle_tree.rs
@@ -13,14 +13,17 @@
 //! * Disk based storage backend (using mmaped files should be easy)
 //! * Implement serialization for tree and Merkle proof

+#![allow(dead_code)]
+
 use std::collections::HashMap;
-use std::io;
 use std::{
    cmp::max,
    fmt::Debug,
    iter::{once, repeat, successors},
 };

+use color_eyre::{Report, Result};
+
 /// In the Hasher trait we define the node type, the default leaf
 /// and the hash function used to initialize a Merkle Tree implementation
 pub trait Hasher {
@@ -84,7 +87,7 @@ impl<H: Hasher> OptimalMerkleTree<H> {
        cached_nodes.reverse();
        OptimalMerkleTree {
            cached_nodes: cached_nodes.clone(),
-            depth: depth,
+            depth,
            nodes: HashMap::new(),
            next_index: 0,
        }
@@ -112,27 +115,43 @@ impl<H: Hasher> OptimalMerkleTree<H> {
    }

    // Sets a leaf at the specified tree index
-    pub fn set(&mut self, index: usize, leaf: H::Fr) -> io::Result<()> {
+    pub fn set(&mut self, index: usize, leaf: H::Fr) -> Result<()> {
        if index >= self.capacity() {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "index exceeds set size",
-            ));
+            return Err(Report::msg("index exceeds set size"));
        }
        self.nodes.insert((self.depth, index), leaf);
-        self.recalculate_from(index);
+        self.recalculate_from(index)?;
        self.next_index = max(self.next_index, index + 1);
        Ok(())
    }

+    // Sets multiple leaves from the specified tree index
+    pub fn set_range<I: IntoIterator<Item = H::Fr>>(
+        &mut self,
+        start: usize,
+        leaves: I,
+    ) -> Result<()> {
+        let leaves = leaves.into_iter().collect::<Vec<_>>();
+        // check if the range is valid
+        if start + leaves.len() > self.capacity() {
+            return Err(Report::msg("provided range exceeds set size"));
+        }
+        for (i, leaf) in leaves.iter().enumerate() {
+            self.nodes.insert((self.depth, start + i), *leaf);
+            self.recalculate_from(start + i)?;
+        }
+        self.next_index = max(self.next_index, start + leaves.len());
+        Ok(())
+    }
+
    // Sets a leaf at the next available index
-    pub fn update_next(&mut self, leaf: H::Fr) -> io::Result<()> {
+    pub fn update_next(&mut self, leaf: H::Fr) -> Result<()> {
        self.set(self.next_index, leaf)?;
        Ok(())
    }

    // Deletes a leaf at a certain index by setting it to its default value (next_index is not updated)
-    pub fn delete(&mut self, index: usize) -> io::Result<()> {
+    pub fn delete(&mut self, index: usize) -> Result<()> {
        // We reset the leaf only if we previously set a leaf at that index
        if index < self.next_index {
            self.set(index, H::default_leaf())?;
@@ -141,12 +160,9 @@ impl<H: Hasher> OptimalMerkleTree<H> {
    }

    // Computes a merkle proof the the leaf at the specified index
-    pub fn proof(&self, index: usize) -> io::Result<OptimalMerkleProof<H>> {
+    pub fn proof(&self, index: usize) -> Result<OptimalMerkleProof<H>> {
        if index >= self.capacity() {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "index exceeds set size",
-            ));
+            return Err(Report::msg("index exceeds set size"));
        }
        let mut witness = Vec::<(H::Fr, u8)>::with_capacity(self.depth);
        let mut i = index;
@@ -160,17 +176,17 @@ impl<H: Hasher> OptimalMerkleTree<H> {
                break;
            }
        }
-        assert_eq!(i, 0);
-        Ok(OptimalMerkleProof(witness))
+        if i != 0 {
+            Err(Report::msg("i != 0"))
+        } else {
+            Ok(OptimalMerkleProof(witness))
+        }
    }

    // Verifies a Merkle proof with respect to the input leaf and the tree root
-    pub fn verify(&self, leaf: &H::Fr, witness: &OptimalMerkleProof<H>) -> io::Result<bool> {
+    pub fn verify(&self, leaf: &H::Fr, witness: &OptimalMerkleProof<H>) -> Result<bool> {
        if witness.length() != self.depth {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "witness length doesn't match tree depth",
-            ));
+            return Err(Report::msg("witness length doesn't match tree depth"));
        }
        let expected_root = witness.compute_root_from(leaf);
        Ok(expected_root.eq(&self.root()))
@@ -195,7 +211,7 @@ impl<H: Hasher> OptimalMerkleTree<H> {
        H::hash(&[self.get_node(depth, b), self.get_node(depth, b + 1)])
    }

-    fn recalculate_from(&mut self, index: usize) {
+    fn recalculate_from(&mut self, index: usize) -> Result<()> {
        let mut i = index;
        let mut depth = self.depth;
        loop {
@@ -207,8 +223,13 @@ impl<H: Hasher> OptimalMerkleTree<H> {
                break;
            }
        }
-        assert_eq!(depth, 0);
-        assert_eq!(i, 0);
+        if depth != 0 {
+            return Err(Report::msg("did not reach the depth"));
+        }
+        if i != 0 {
+            return Err(Report::msg("did not go through all indexes"));
+        }
+        Ok(())
    }
 }

@@ -363,7 +384,7 @@ impl<H: Hasher> FullMerkleTree<H> {
    }

    // Sets a leaf at the specified tree index
-    pub fn set(&mut self, leaf: usize, hash: H::Fr) -> io::Result<()> {
+    pub fn set(&mut self, leaf: usize, hash: H::Fr) -> Result<()> {
        self.set_range(leaf, once(hash))?;
        self.next_index = max(self.next_index, leaf + 1);
        Ok(())
@@ -371,33 +392,34 @@ impl<H: Hasher> FullMerkleTree<H> {

    // Sets tree nodes, starting from start index
    // Function proper of FullMerkleTree implementation
-    fn set_range<I: IntoIterator<Item = H::Fr>>(
-        &mut self,
-        start: usize,
-        hashes: I,
-    ) -> io::Result<()> {
+    fn set_range<I: IntoIterator<Item = H::Fr>>(&mut self, start: usize, hashes: I) -> Result<()> {
        let index = self.capacity() + start - 1;
        let mut count = 0;
-        // TODO: Error/panic when hashes is longer than available leafs
-        for (leaf, hash) in self.nodes[index..].iter_mut().zip(hashes) {
-            *leaf = hash;
-            count += 1;
+        // first count number of hashes, and check that they fit in the tree
+        // then insert into the tree
+        let hashes = hashes.into_iter().collect::<Vec<_>>();
+        if hashes.len() + start > self.capacity() {
+            return Err(Report::msg("provided hashes do not fit in the tree"));
        }
+        hashes.into_iter().for_each(|hash| {
+            self.nodes[index + count] = hash;
+            count += 1;
+        });
        if count != 0 {
-            self.update_nodes(index, index + (count - 1));
+            self.update_nodes(index, index + (count - 1))?;
            self.next_index = max(self.next_index, start + count);
        }
        Ok(())
    }

    // Sets a leaf at the next available index
-    pub fn update_next(&mut self, leaf: H::Fr) -> io::Result<()> {
+    pub fn update_next(&mut self, leaf: H::Fr) -> Result<()> {
        self.set(self.next_index, leaf)?;
        Ok(())
    }

    // Deletes a leaf at a certain index by setting it to its default value (next_index is not updated)
-    pub fn delete(&mut self, index: usize) -> io::Result<()> {
+    pub fn delete(&mut self, index: usize) -> Result<()> {
        // We reset the leaf only if we previously set a leaf at that index
        if index < self.next_index {
            self.set(index, H::default_leaf())?;
@@ -406,12 +428,9 @@ impl<H: Hasher> FullMerkleTree<H> {
    }

    // Computes a merkle proof the the leaf at the specified index
-    pub fn proof(&self, leaf: usize) -> io::Result<FullMerkleProof<H>> {
+    pub fn proof(&self, leaf: usize) -> Result<FullMerkleProof<H>> {
        if leaf >= self.capacity() {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "index exceeds set size",
-            ));
+            return Err(Report::msg("index exceeds set size"));
        }
        let mut index = self.capacity() + leaf - 1;
        let mut path = Vec::with_capacity(self.depth + 1);
@@ -428,7 +447,7 @@ impl<H: Hasher> FullMerkleTree<H> {
    }

    // Verifies a Merkle proof with respect to the input leaf and the tree root
-    pub fn verify(&self, hash: &H::Fr, proof: &FullMerkleProof<H>) -> io::Result<bool> {
+    pub fn verify(&self, hash: &H::Fr, proof: &FullMerkleProof<H>) -> Result<bool> {
        Ok(proof.compute_root_from(hash) == self.root())
    }

@@ -455,15 +474,18 @@ impl<H: Hasher> FullMerkleTree<H> {
        (index + 2).next_power_of_two().trailing_zeros() as usize - 1
    }

-    fn update_nodes(&mut self, start: usize, end: usize) {
-        debug_assert_eq!(self.levels(start), self.levels(end));
+    fn update_nodes(&mut self, start: usize, end: usize) -> Result<()> {
+        if self.levels(start) != self.levels(end) {
+            return Err(Report::msg("self.levels(start) != self.levels(end)"));
+        }
        if let (Some(start), Some(end)) = (self.parent(start), self.parent(end)) {
            for parent in start..=end {
                let child = self.first_child(parent);
                self.nodes[parent] = H::hash(&[self.nodes[child], self.nodes[child + 1]]);
            }
-            self.update_nodes(start, end);
+            self.update_nodes(start, end)?;
        }
+        Ok(())
    }
 }

@@ -540,127 +562,3 @@ where
        f.debug_tuple("Proof").field(&self.0).finish()
    }
 }
-
-////////////////////////////////////////////////////////////
-/// Tests
-////////////////////////////////////////////////////////////
-
-// Tests adapted from https://github.com/worldcoin/semaphore-rs/blob/d462a4372f1fd9c27610f2acfe4841fab1d396aa/src/merkle_tree.rs
-#[cfg(test)]
-mod test {
-    use super::*;
-    use hex_literal::hex;
-    use tiny_keccak::{Hasher as _, Keccak};
-
-    struct Keccak256;
-
-    impl Hasher for Keccak256 {
-        type Fr = [u8; 32];
-
-        fn default_leaf() -> Self::Fr {
-            [0; 32]
-        }
-
-        fn hash(inputs: &[Self::Fr]) -> Self::Fr {
-            let mut output = [0; 32];
-            let mut hasher = Keccak::v256();
-            for element in inputs {
-                hasher.update(element);
-            }
-            hasher.finalize(&mut output);
-            output
-        }
-    }
-
-    #[test]
-    fn test_root() {
-        let leaves = [
-            hex!("0000000000000000000000000000000000000000000000000000000000000001"),
-            hex!("0000000000000000000000000000000000000000000000000000000000000002"),
-            hex!("0000000000000000000000000000000000000000000000000000000000000003"),
-            hex!("0000000000000000000000000000000000000000000000000000000000000004"),
-        ];
-
-        let default_tree_root =
-            hex!("b4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30");
-
-        let roots = [
-            hex!("c1ba1812ff680ce84c1d5b4f1087eeb08147a4d510f3496b2849df3a73f5af95"),
-            hex!("893760ec5b5bee236f29e85aef64f17139c3c1b7ff24ce64eb6315fca0f2485b"),
-            hex!("222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c"),
-            hex!("a9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36"),
-        ];
-
-        let mut tree = FullMerkleTree::<Keccak256>::new(2, [0; 32]);
-        assert_eq!(tree.root(), default_tree_root);
-        for i in 0..leaves.len() {
-            tree.set(i, leaves[i]).unwrap();
-            assert_eq!(tree.root(), roots[i]);
-        }
-
-        let mut tree = OptimalMerkleTree::<Keccak256>::new(2, [0; 32]);
-        assert_eq!(tree.root(), default_tree_root);
-        for i in 0..leaves.len() {
-            tree.set(i, leaves[i]).unwrap();
-            assert_eq!(tree.root(), roots[i]);
-        }
-    }
-
-    #[test]
-    fn test_proof() {
-        let leaves = [
-            hex!("0000000000000000000000000000000000000000000000000000000000000001"),
-            hex!("0000000000000000000000000000000000000000000000000000000000000002"),
-            hex!("0000000000000000000000000000000000000000000000000000000000000003"),
-            hex!("0000000000000000000000000000000000000000000000000000000000000004"),
-        ];
-
-        // We thest the FullMerkleTree implementation
-        let mut tree = FullMerkleTree::<Keccak256>::new(2, [0; 32]);
-        for i in 0..leaves.len() {
-            // We set the leaves
-            tree.set(i, leaves[i]).unwrap();
-
-            // We compute a merkle proof
-            let proof = tree.proof(i).expect("index should be set");
-
-            // We verify if the merkle proof corresponds to the right leaf index
-            assert_eq!(proof.leaf_index(), i);
-
-            // We verify the proof
-            assert!(tree.verify(&leaves[i], &proof).unwrap());
-
-            // We ensure that the Merkle proof and the leaf generate the same root as the tree
-            assert_eq!(proof.compute_root_from(&leaves[i]), tree.root());
-
-            // We check that the proof is not valid for another leaf
-            assert!(!tree
-                .verify(&leaves[(i + 1) % leaves.len()], &proof)
-                .unwrap());
-        }
-
-        // We test the OptimalMerkleTree implementation
-        let mut tree = OptimalMerkleTree::<Keccak256>::new(2, [0; 32]);
-        for i in 0..leaves.len() {
-            // We set the leaves
-            tree.set(i, leaves[i]).unwrap();
-
-            // We compute a merkle proof
-            let proof = tree.proof(i).expect("index should be set");
-
-            // We verify if the merkle proof corresponds to the right leaf index
-            assert_eq!(proof.leaf_index(), i);
-
-            // We verify the proof
-            assert!(tree.verify(&leaves[i], &proof).unwrap());
-
-            // We ensure that the Merkle proof and the leaf generate the same root as the tree
-            assert_eq!(proof.compute_root_from(&leaves[i]), tree.root());
-
-            // We check that the proof is not valid for another leaf
-            assert!(!tree
-                .verify(&leaves[(i + 1) % leaves.len()], &proof)
-                .unwrap());
-        }
-    }
-}
--- a/utils/src/merkle_tree/mod.rs
+++ b/utils/src/merkle_tree/mod.rs
@@ -0,0 +1,3 @@
+#[allow(clippy::module_inception)]
+pub mod merkle_tree;
+pub use self::merkle_tree::*;
--- a/utils/src/poseidon/mod.rs
+++ b/utils/src/poseidon/mod.rs
@@ -0,0 +1,5 @@
+pub mod poseidon_hash;
+pub use self::poseidon_hash::*;
+
+pub mod poseidon_constants;
+pub use self::poseidon_constants::*;
--- a/utils/src/poseidon/poseidon_constants.rs
+++ b/utils/src/poseidon/poseidon_constants.rs
@@ -0,0 +1,272 @@
+// This crate provides an implementation to compute the Poseidon hash round constants and MDS matrices.
+
+// SECURITY NOTE: The MDS matrices are generated interatively using the Grain LFSR until certain criteria are met.
+// According to the paper, such matrices have to respect some conditions which are checked by 3 different algorithms in the reference implementation.
+// At the moment such algorithms are not implemented, however *for the hardcoded parameters* the first random matrix generated satisfy such conditions.
+// If different parameters are implemented, it should be checked against the reference implementation how many matrices are generated before outputting
+// the right one, and pass this number to the skip_matrices parameter of find_poseidon_ark_and_mds function in order to output the correct one.
+// Poseidon reference implementation: https://extgit.iaik.tugraz.at/krypto/hadeshash/-/blob/master/code/generate_parameters_grain.sage (algorithm_1, algorithm_2, algorithm_3)
+
+// The following implementation was adapted from https://github.com/arkworks-rs/sponge/blob/7d9b3a474c9ddb62890014aeaefcb142ac2b3776/src/poseidon/grain_lfsr.rs
+
+#![allow(dead_code)]
+
+use ark_ff::PrimeField;
+use num_bigint::BigUint;
+
+pub struct PoseidonGrainLFSR {
+    pub prime_num_bits: u64,
+    pub state: [bool; 80],
+    pub head: usize,
+}
+
+#[allow(unused_variables)]
+impl PoseidonGrainLFSR {
+    pub fn new(
+        is_field: u64,
+        is_sbox_an_inverse: u64,
+        prime_num_bits: u64,
+        state_len: u64,
+        num_full_rounds: u64,
+        num_partial_rounds: u64,
+    ) -> Self {
+        let mut state = [false; 80];
+
+        // Only fields are supported for now
+        assert!(is_field == 1);
+
+        // b0, b1 describes the field
+        if is_field == 1 {
+            state[1] = true;
+        } else {
+            state[1] = false;
+        }
+
+        assert!(is_sbox_an_inverse == 0 || is_sbox_an_inverse == 1);
+
+        // b2, ..., b5 describes the S-BOX
+        if is_sbox_an_inverse == 1 {
+            state[5] = true;
+        } else {
+            state[5] = false;
+        }
+
+        // b6, ..., b17 are the binary representation of n (prime_num_bits)
+        {
+            let mut cur = prime_num_bits;
+            for i in (6..=17).rev() {
+                state[i] = cur & 1 == 1;
+                cur >>= 1;
+            }
+        }
+
+        // b18, ..., b29 are the binary representation of t (state_len, rate + capacity)
+        {
+            let mut cur = state_len;
+            for i in (18..=29).rev() {
+                state[i] = cur & 1 == 1;
+                cur >>= 1;
+            }
+        }
+
+        // b30, ..., b39 are the binary representation of R_F (the number of full rounds)
+        {
+            let mut cur = num_full_rounds;
+            for i in (30..=39).rev() {
+                state[i] = cur & 1 == 1;
+                cur >>= 1;
+            }
+        }
+
+        // b40, ..., b49 are the binary representation of R_P (the number of partial rounds)
+        {
+            let mut cur = num_partial_rounds;
+            for i in (40..=49).rev() {
+                state[i] = cur & 1 == 1;
+                cur >>= 1;
+            }
+        }
+
+        // b50, ..., b79 are set to 1
+        for item in state.iter_mut().skip(50) {
+            *item = true;
+        }
+
+        let head = 0;
+
+        let mut res = Self {
+            prime_num_bits,
+            state,
+            head,
+        };
+        res.init();
+        res
+    }
+
+    pub fn get_bits(&mut self, num_bits: usize) -> Vec<bool> {
+        let mut res = Vec::new();
+
+        for _ in 0..num_bits {
+            // Obtain the first bit
+            let mut new_bit = self.update();
+
+            // Loop until the first bit is true
+            while !new_bit {
+                // Discard the second bit
+                let _ = self.update();
+                // Obtain another first bit
+                new_bit = self.update();
+            }
+
+            // Obtain the second bit
+            res.push(self.update());
+        }
+
+        res
+    }
+
+    pub fn get_field_elements_rejection_sampling<F: PrimeField>(
+        &mut self,
+        num_elems: usize,
+    ) -> Vec<F> {
+        assert_eq!(F::MODULUS_BIT_SIZE as u64, self.prime_num_bits);
+        let modulus: BigUint = F::MODULUS.into();
+
+        let mut res = Vec::new();
+        for _ in 0..num_elems {
+            // Perform rejection sampling
+            loop {
+                // Obtain n bits and make it most-significant-bit first
+                let mut bits = self.get_bits(self.prime_num_bits as usize);
+                bits.reverse();
+
+                let bytes = bits
+                    .chunks(8)
+                    .map(|chunk| {
+                        let mut result = 0u8;
+                        for (i, bit) in chunk.iter().enumerate() {
+                            result |= u8::from(*bit) << i
+                        }
+                        result
+                    })
+                    .collect::<Vec<u8>>();
+
+                let value = BigUint::from_bytes_le(&bytes);
+
+                if value < modulus {
+                    res.push(F::from(value.clone()));
+                    break;
+                }
+            }
+        }
+        res
+    }
+
+    pub fn get_field_elements_mod_p<F: PrimeField>(&mut self, num_elems: usize) -> Vec<F> {
+        assert_eq!(F::MODULUS_BIT_SIZE as u64, self.prime_num_bits);
+
+        let mut res = Vec::new();
+        for _ in 0..num_elems {
+            // Obtain n bits and make it most-significant-bit first
+            let mut bits = self.get_bits(self.prime_num_bits as usize);
+            bits.reverse();
+
+            let bytes = bits
+                .chunks(8)
+                .map(|chunk| {
+                    let mut result = 0u8;
+                    for (i, bit) in chunk.iter().enumerate() {
+                        result |= u8::from(*bit) << i
+                    }
+                    result
+                })
+                .collect::<Vec<u8>>();
+
+            res.push(F::from_le_bytes_mod_order(&bytes));
+        }
+
+        res
+    }
+
+    #[inline]
+    fn update(&mut self) -> bool {
+        let new_bit = self.state[(self.head + 62) % 80]
+            ^ self.state[(self.head + 51) % 80]
+            ^ self.state[(self.head + 38) % 80]
+            ^ self.state[(self.head + 23) % 80]
+            ^ self.state[(self.head + 13) % 80]
+            ^ self.state[self.head];
+        self.state[self.head] = new_bit;
+        self.head += 1;
+        self.head %= 80;
+
+        new_bit
+    }
+
+    fn init(&mut self) {
+        for _ in 0..160 {
+            let new_bit = self.state[(self.head + 62) % 80]
+                ^ self.state[(self.head + 51) % 80]
+                ^ self.state[(self.head + 38) % 80]
+                ^ self.state[(self.head + 23) % 80]
+                ^ self.state[(self.head + 13) % 80]
+                ^ self.state[self.head];
+            self.state[self.head] = new_bit;
+            self.head += 1;
+            self.head %= 80;
+        }
+    }
+}
+
+pub fn find_poseidon_ark_and_mds<F: PrimeField>(
+    is_field: u64,
+    is_sbox_an_inverse: u64,
+    prime_bits: u64,
+    rate: usize,
+    full_rounds: u64,
+    partial_rounds: u64,
+    skip_matrices: usize,
+) -> (Vec<F>, Vec<Vec<F>>) {
+    let mut lfsr = PoseidonGrainLFSR::new(
+        is_field,
+        is_sbox_an_inverse,
+        prime_bits,
+        rate as u64,
+        full_rounds,
+        partial_rounds,
+    );
+
+    let mut ark = Vec::<F>::with_capacity((full_rounds + partial_rounds) as usize);
+    for _ in 0..(full_rounds + partial_rounds) {
+        let values = lfsr.get_field_elements_rejection_sampling::<F>(rate);
+        for el in values {
+            ark.push(el);
+        }
+    }
+
+    let mut mds = Vec::<Vec<F>>::with_capacity(rate);
+    mds.resize(rate, vec![F::zero(); rate]);
+
+    // Note that we build the MDS matrix generating 2*rate elements. If the matrix built is not secure (see checks with algorithm 1, 2, 3 in reference implementation)
+    // it has to be skipped. Since here we do not implement such algorithm we allow to pass a parameter to skip generations of elements giving unsecure matrixes.
+    // At the moment, the skip_matrices parameter has to be generated from the reference implementation and passed to this function
+    for _ in 0..skip_matrices {
+        let _ = lfsr.get_field_elements_mod_p::<F>(2 * (rate));
+    }
+
+    // a qualifying matrix must satisfy the following requirements
+    // - there is no duplication among the elements in x or y
+    // - there is no i and j such that x[i] + y[j] = p
+    // - the resultant MDS passes all the three tests
+
+    let xs = lfsr.get_field_elements_mod_p::<F>(rate);
+    let ys = lfsr.get_field_elements_mod_p::<F>(rate);
+
+    for i in 0..(rate) {
+        for (j, ys_item) in ys.iter().enumerate().take(rate) {
+            mds[i][j] = (xs[i] + ys_item).inverse().unwrap();
+        }
+    }
+
+    (ark, mds)
+}
--- a/utils/src/poseidon/poseidon_hash.rs
+++ b/utils/src/poseidon/poseidon_hash.rs
@@ -0,0 +1,141 @@
+// This crate implements the Poseidon hash algorithm https://eprint.iacr.org/2019/458.pdf
+
+// Implementation partially taken from https://github.com/arnaucube/poseidon-rs/blob/233027d6075a637c29ad84a8a44f5653b81f0410/src/lib.rs
+// and adapted to work over arkworks field traits and custom data structures
+
+use crate::poseidon_constants::find_poseidon_ark_and_mds;
+use ark_ff::PrimeField;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RoundParamenters<F: PrimeField> {
+    pub t: usize,
+    pub n_rounds_f: usize,
+    pub n_rounds_p: usize,
+    pub skip_matrices: usize,
+    pub c: Vec<F>,
+    pub m: Vec<Vec<F>>,
+}
+
+pub struct Poseidon<F: PrimeField> {
+    round_params: Vec<RoundParamenters<F>>,
+}
+impl<F: PrimeField> Poseidon<F> {
+    // Loads round parameters and generates round constants
+    // poseidon_params is a vector containing tuples (t, RF, RP, skip_matrices)
+    // where: t is the rate (input lenght + 1), RF is the number of full rounds, RP is the number of partial rounds
+    // and skip_matrices is a (temporary) parameter used to generate secure MDS matrices (see comments in the description of find_poseidon_ark_and_mds)
+    // TODO: implement automatic generation of round parameters
+    pub fn from(poseidon_params: &[(usize, usize, usize, usize)]) -> Self {
+        let mut read_params = Vec::<RoundParamenters<F>>::new();
+
+        for &(t, n_rounds_f, n_rounds_p, skip_matrices) in poseidon_params {
+            let (ark, mds) = find_poseidon_ark_and_mds::<F>(
+                1, // is_field = 1
+                0, // is_sbox_inverse = 0
+                F::MODULUS_BIT_SIZE as u64,
+                t,
+                n_rounds_f as u64,
+                n_rounds_p as u64,
+                skip_matrices,
+            );
+            let rp = RoundParamenters {
+                t,
+                n_rounds_p,
+                n_rounds_f,
+                skip_matrices,
+                c: ark,
+                m: mds,
+            };
+            read_params.push(rp);
+        }
+
+        Poseidon {
+            round_params: read_params,
+        }
+    }
+
+    pub fn get_parameters(&self) -> Vec<RoundParamenters<F>> {
+        self.round_params.clone()
+    }
+
+    pub fn ark(&self, state: &mut [F], c: &[F], it: usize) {
+        for i in 0..state.len() {
+            state[i] += c[it + i];
+        }
+    }
+
+    pub fn sbox(&self, n_rounds_f: usize, n_rounds_p: usize, state: &mut [F], i: usize) {
+        if (i < n_rounds_f / 2) || (i >= n_rounds_f / 2 + n_rounds_p) {
+            for current_state in &mut state.iter_mut() {
+                let aux = *current_state;
+                *current_state *= *current_state;
+                *current_state *= *current_state;
+                *current_state *= aux;
+            }
+        } else {
+            let aux = state[0];
+            state[0] *= state[0];
+            state[0] *= state[0];
+            state[0] *= aux;
+        }
+    }
+
+    pub fn mix(&self, state: &[F], m: &[Vec<F>]) -> Vec<F> {
+        let mut new_state: Vec<F> = Vec::new();
+        for i in 0..state.len() {
+            new_state.push(F::zero());
+            for (j, state_item) in state.iter().enumerate() {
+                let mut mij = m[i][j];
+                mij *= state_item;
+                new_state[i] += mij;
+            }
+        }
+        new_state.clone()
+    }
+
+    pub fn hash(&self, inp: Vec<F>) -> Result<F, String> {
+        // Note that the rate t becomes input lenght + 1, hence for lenght N we pick parameters with T = N + 1
+        let t = inp.len() + 1;
+
+        // We seek the index (Poseidon's round_params is an ordered vector) for the parameters corresponding to t
+        let param_index = self.round_params.iter().position(|el| el.t == t);
+
+        if inp.is_empty() || param_index.is_none() {
+            return Err("No parameters found for inputs length".to_string());
+        }
+
+        let param_index = param_index.unwrap();
+
+        let mut state = vec![F::zero(); t];
+        state[1..].clone_from_slice(&inp);
+
+        for i in 0..(self.round_params[param_index].n_rounds_f
+            + self.round_params[param_index].n_rounds_p)
+        {
+            self.ark(
+                &mut state,
+                &self.round_params[param_index].c,
+                i * self.round_params[param_index].t,
+            );
+            self.sbox(
+                self.round_params[param_index].n_rounds_f,
+                self.round_params[param_index].n_rounds_p,
+                &mut state,
+                i,
+            );
+            state = self.mix(&state, &self.round_params[param_index].m);
+        }
+
+        Ok(state[0])
+    }
+}
+
+impl<F> Default for Poseidon<F>
+where
+    F: PrimeField,
+{
+    // Default instantiation has no round constants set. Will return an error when hashing is attempted.
+    fn default() -> Self {
+        Self::from(&[])
+    }
+}
--- a/utils/tests/merkle_tree.rs
+++ b/utils/tests/merkle_tree.rs
@@ -0,0 +1,119 @@
+// Tests adapted from https://github.com/worldcoin/semaphore-rs/blob/d462a4372f1fd9c27610f2acfe4841fab1d396aa/src/merkle_tree.rs
+#[cfg(test)]
+mod test {
+    use hex_literal::hex;
+    use tiny_keccak::{Hasher as _, Keccak};
+    use utils::{FullMerkleTree, Hasher, OptimalMerkleTree};
+
+    struct Keccak256;
+
+    impl Hasher for Keccak256 {
+        type Fr = [u8; 32];
+
+        fn default_leaf() -> Self::Fr {
+            [0; 32]
+        }
+
+        fn hash(inputs: &[Self::Fr]) -> Self::Fr {
+            let mut output = [0; 32];
+            let mut hasher = Keccak::v256();
+            for element in inputs {
+                hasher.update(element);
+            }
+            hasher.finalize(&mut output);
+            output
+        }
+    }
+
+    #[test]
+    fn test_root() {
+        let leaves = [
+            hex!("0000000000000000000000000000000000000000000000000000000000000001"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000002"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000003"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000004"),
+        ];
+
+        let default_tree_root =
+            hex!("b4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30");
+
+        let roots = [
+            hex!("c1ba1812ff680ce84c1d5b4f1087eeb08147a4d510f3496b2849df3a73f5af95"),
+            hex!("893760ec5b5bee236f29e85aef64f17139c3c1b7ff24ce64eb6315fca0f2485b"),
+            hex!("222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c"),
+            hex!("a9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36"),
+        ];
+
+        let mut tree = FullMerkleTree::<Keccak256>::new(2, [0; 32]);
+        assert_eq!(tree.root(), default_tree_root);
+        for i in 0..leaves.len() {
+            tree.set(i, leaves[i]).unwrap();
+            assert_eq!(tree.root(), roots[i]);
+        }
+
+        let mut tree = OptimalMerkleTree::<Keccak256>::new(2, [0; 32]);
+        assert_eq!(tree.root(), default_tree_root);
+        for i in 0..leaves.len() {
+            tree.set(i, leaves[i]).unwrap();
+            assert_eq!(tree.root(), roots[i]);
+        }
+    }
+
+    #[test]
+    fn test_proof() {
+        let leaves = [
+            hex!("0000000000000000000000000000000000000000000000000000000000000001"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000002"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000003"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000004"),
+        ];
+
+        // We thest the FullMerkleTree implementation
+        let mut tree = FullMerkleTree::<Keccak256>::new(2, [0; 32]);
+        for i in 0..leaves.len() {
+            // We set the leaves
+            tree.set(i, leaves[i]).unwrap();
+
+            // We compute a merkle proof
+            let proof = tree.proof(i).expect("index should be set");
+
+            // We verify if the merkle proof corresponds to the right leaf index
+            assert_eq!(proof.leaf_index(), i);
+
+            // We verify the proof
+            assert!(tree.verify(&leaves[i], &proof).unwrap());
+
+            // We ensure that the Merkle proof and the leaf generate the same root as the tree
+            assert_eq!(proof.compute_root_from(&leaves[i]), tree.root());
+
+            // We check that the proof is not valid for another leaf
+            assert!(!tree
+                .verify(&leaves[(i + 1) % leaves.len()], &proof)
+                .unwrap());
+        }
+
+        // We test the OptimalMerkleTree implementation
+        let mut tree = OptimalMerkleTree::<Keccak256>::new(2, [0; 32]);
+        for i in 0..leaves.len() {
+            // We set the leaves
+            tree.set(i, leaves[i]).unwrap();
+
+            // We compute a merkle proof
+            let proof = tree.proof(i).expect("index should be set");
+
+            // We verify if the merkle proof corresponds to the right leaf index
+            assert_eq!(proof.leaf_index(), i);
+
+            // We verify the proof
+            assert!(tree.verify(&leaves[i], &proof).unwrap());
+
+            // We ensure that the Merkle proof and the leaf generate the same root as the tree
+            assert_eq!(proof.compute_root_from(&leaves[i]), tree.root());
+
+            // We check that the proof is not valid for another leaf
+            assert!(!tree
+                .verify(&leaves[(i + 1) % leaves.len()], &proof)
+                .unwrap());
+        }
+    }
+}
--- a/utils/tests/poseidon_constants.rs
+++ b/utils/tests/poseidon_constants.rs
Author	SHA1	Message	Date
tyshkor	658d07ae8c	rm commented line	2023-03-20 23:14:29 +01:00
tyshkor	6ef3bb0e76	as gakonst updated the version, doing the same	2023-03-20 21:51:56 +01:00
tyshkor	d2039138a8	update wasm	2023-03-20 18:27:01 +01:00
tyshkor	2fb1b27434	redundunt dep + rev rln-wasm cogro toml	2023-03-20 12:55:42 +01:00
tyshkor	81eb230a62	fmt	2023-03-20 12:47:56 +01:00
tyshkor	9bfef98813	code updates as ark tooling names has changed	2023-03-20 12:42:00 +01:00
tyshkor	dd4f44bee5	leave our fork of `ark-circom`	2023-03-20 09:45:52 +01:00
Aaryamann Challani	bb7dfb80ee	feat(ci): cross-compile release assets, cache deps (#128 ) * feat(ci): cross-compile release assets, cache deps chore(ci): add caching to regular tests * fix(ci): include cross only in ci env, add note about release assets	2023-03-14 17:44:06 +05:30
Aaryamann Challani	c319f32a1e	feat(rln): package rln w/ resources into a static lib (#118 ) * feat(rln): package resources into lib * fix(rln): use Path * fix(rln): fmt * fix(rln): trailing slash	2023-03-07 18:15:06 +05:30
tyshko-rostyslav	bf2aa16a71	chore(rln): ensure all dependencies have fixed revision (#127 )	2023-03-07 09:11:08 +05:30
tyshko-rostyslav	c423bdea61	chore(rln): update pmtree implementation (#125 ) * most changes * fmt * hide tests back under feature * grooming * changed `SledConfig` * requested change: rm `dbpath` --------- Co-authored-by: tyshkor <tyshko1@gmail.com>	2023-03-03 10:33:39 +05:30
Carlos Pérez	5eb98d4b33	change: Replace `u64` for `usize` for length vars (#94 ) * change: Replace `u64` for `usize` for length vars Resolves: #39 * fix(rln): usize instead of u64 in tests * fix(rln): linter * fix: outlier u64 usage * fix(rln\|rln-wasm): serde of usize types --------- Co-authored-by: Aaryamann Challani <43716372+rymnc@users.noreply.github.com>	2023-03-02 19:15:58 +05:30
Aaryamann Challani	b698153e28	fix(ci): nightly release (#124 )	2023-03-02 07:41:49 +05:30
Aaryamann Challani	a6c8090c93	feat(v0.2): changelog (#122 )	2023-02-28 16:25:18 +05:30
tyshko-rostyslav	7ee7675d52	Redundunt dependencies (#111 ) * most changes * delete unused deps + update ark-circom * fix build * revert * default deatures * return * кумуке 2 * try * rm --------- Co-authored-by: tyshkor <tyshko1@gmail.com>	2023-02-28 00:19:47 +05:30
Aaryamann Challani	062055dc5e	fix(license): add licensing info to cargo.toml (#121 )	2023-02-27 11:47:55 +05:30
tyshko-rostyslav	55b00fd653	Code quality (#114 ) * to color_eyre::Result 1st part * tests and seconds batch * third batch * rln fixes + multiplier * rln-wasm, assert rln, multiplier * io to color_eyre * fmt + clippy * fix lint * temporary fix of `ark-circom` * fix ci after merge * fmt * fix rln tests * minor * fix tests * imports * requested change * report + commented line + requested change * requested changes * fix build * lint fixes * better comments --------- Co-authored-by: tyshkor <tyshko1@gmail.com>	2023-02-27 11:46:16 +05:30
Rahul Ghangas	62018b4eba	Update documentation for building and testing (#120 ) * chore: fix Makefile pre-build * chore: add Makefile command to install depenedncy cargo-make * chore: update all READMEs with instructions to install dependencies, build and test * chore: add target to fetch all submodules	2023-02-24 11:50:51 +05:30
oskarth	48fa1b9b3d	chore: Add MIT/Apache dual license (#119 )	2023-02-24 11:20:01 +08:00
Aaryamann Challani	a6145ab201	feat(rln): expose poseidon to ffi (#112 )	2023-02-16 13:26:13 +05:30
Aaryamann Challani	e21e9954ac	fix(semaphore): revert ark-circom dependency (#116 )	2023-02-16 12:32:43 +05:30
Carlos Pérez	de5eb2066a	change: Replace profile overwrites to Workspace Cargo.toml (#95 ) Since profile info specified inside workspace members `Cargo.toml`'s is ignored by Cargo, this replaces the place to specify these details for the workspace-level `Cargo.toml`. NOTE that `panic` and `rpath` aren't supported with the Overwritting feature. Therefore, the only required thing (if considered necessary) is to create a new profile which also enables these things. Resolves: #93	2023-02-08 12:38:42 +01:00
tyshko-rostyslav	7aba62ff51	Add rust-clippy to CI (#108 ) Convert clippy warnings to errors, fix them --------- Co-authored-by: tyshkor <tyshko1@gmail.com>	2023-02-06 05:54:59 +01:00
Rahul Ghangas	cbf8c541c2	test: separate out tests (#103 ) * test: move tests for rln, multiplier and private-settlements to tests folder * test: fix rln test for poseiden tree * test: move tests for rln-wasn to standalone tests folder * test: move tests for semaphore and utils to standalone tests folder * chore: cargo fmt * test: rename test files * test: move tests out from rln/src/public to test folder * test: fix rln tests, move tests accessign private fields back to relevant source file * chor: run cargo fmt * test: move all semaphore tests to tests folder * chore: cargo fmt	2023-01-31 21:27:28 +05:30
Rahul Ghangas	5bcbc6c22f	Use cargo make for tests in CI (#107 ) * chore: use cargo make for builds/tests * chore: add step to install cargo-make	2023-01-31 20:46:33 +05:30
tyshko-rostyslav	01fdba6d88	feat(rln): Abstract ffi APIs structure with a helper function (#102 ) Added macros to do the following: read the input passed to the FFI API; cast it to a byte sequence; pass the byte sequence to the corresponding public function; cast the output of the public function to Buffer(if any) and write it into the FFI caller ´output_buffer` variable; erase memory from any temporarily allocated data structure; return true if everything went fine, false otherwise.	2023-01-31 09:43:41 +01:00
Rahul Ghangas	1502315605	chore: Makefile and consistent usage of cargo-make (#101 ) * feat: add Makefile with pre build check. add targets for build, test and clean * feat: add workspace level build file * chore: add skeletal build files for each crate * chore: remove environment variable to extend workspace makefile * chore: formatting * chore: add release flags to all builds/tests	2023-01-26 09:19:55 +05:30
Richard Ramos	92c431c98f	feat(rln-wasm): expose `set_leaves_from` and `init_tree_with_leaves`	2023-01-19 08:37:15 -04:00
Richard Ramos	005393d696	feat(wasm): add extended_key_gen, seeded_extended_key_gen and recover_id_secret	2022-12-22 14:30:13 -04:00
G	89ea87a98a	feat(rln): integrate pmtree for MT persistance (#86 ) * feat(rln): integrate pmtree for MT persistance * fix(rln): address reviewers comments * refactor(rln): move pmtree tests under pmtree flag	2022-12-13 20:00:27 +01:00
G	32f3202e9d	feat(rln): add extended keygen APIs for Semaphore-compatible credentials (#85 ) * refactor(rln): update APIs based on updated rln circuit design * chore(rln): update rln vendor submodule * fix(ci): update ci to not ignore rln resources changes * feat(rln): add extended keygen APIs * refactor(rln): rename id_secret/id_key to identity_secret_hash as per RFC * fix(rln): cargo fmt	2022-12-12 00:48:22 +01:00
G	e69f6a67d8	fix(semaphore): restore and update original semaphore git dependency	2022-12-12 00:40:08 +01:00
G	9e1355d36a	refactor(rln): update APIs after circuit update (#84 ) * refactor(rln): update APIs based on updated rln circuit design * chore(rln): update rln vendor submodule * fix(ci): update ci to not ignore rln resources changes	2022-12-09 17:19:55 +01:00
Richard Ramos	3551435d60	feat(wasm): expose seeded_key_gen	2022-12-07 11:35:09 -04:00
G	60e3369621	feat(rln): add recover identity secret API (#80 ) * feat(rln): add API to recover id_secret when a user is slashed * feat(rln): add RLN API for recovering id_secret * feat(rln): add recover_id_secret FFI API; update public API docs * fix(rln): address reviewers' comments * fix(rln): removing ; for clippy	2022-11-28 12:05:33 +01:00
G	284e51483c	feat(rln): add example usage tutorial and expand documentation for RLN (WIP) (#74 ) * feat(rln): expand documentation with minimal public API usage example * refactor(rln): ease RLN interaction with new APIs * feat(rln): expand API docs * fix(rln): disable doctest for rln	2022-11-25 10:54:17 +01:00
G	3427729f7e	fix(semaphore): temporarily use fixed semaphore-rs fork (#79 ) * fix(semaphore): temporarily use fixed semaphore-rs fork * fix(semaphore): update semaphore logic to work with latest master of semaphore-rs	2022-11-23 10:55:12 +01:00
G	e1c16c9c3f	refactor(zerokit): split test workflows per module (#76 ) * refactor(zerokit): split test workflows per module * refactor(ci): separate clippy per module * fix(ci): continue with next module lint check, even if previous fails * refactor: enable tests on linux/macos * fix(rln-wasm): make cargo make build work on macOS and linux (#77) * fix(ci): fix workflow * fix(ci): add name to workflows * refactor(zerokit): split test workflows per module * refactor(ci): separate clippy per module * fix(ci): continue with next module lint check, even if previous fails * refactor: enable tests on linux/macos * fix(ci): fix workflow * fix(ci): add name to workflows * fix(ci): enable lint tests only for ubuntu	2022-11-22 15:25:35 +01:00
G	bc69e25359	feat(rln): add few serialization APIs to ease user interaction (#75 ) * feat(rln): add few serialization APIs to ease user interaction * fix(rln): cargo fmt	2022-11-21 17:55:08 +01:00
G	6a7808d911	fix(rln-wasm): make cargo make build work on macOS and linux (#77 )	2022-11-21 16:41:38 +01:00
Aaryamann Challani	25bcb7991b	fix(ci): exclude rln-wasm since it has its own step now (#73 ) * fix(ci): exclude rln-wasm since it has its own step now * fix(ci): use stable toolchain * fix(ci): paths for release notes * fix(ci): release path * test(ci): check the tree for filepaths * test(ci): check the tree for filepaths * test(ci): tighten name and release assets * test(ci): auto generated release notes * fix(ci): remove commit hash from asset name for determinism * test(ci): start tag should be last release	2022-11-16 20:06:17 +05:30
Aaryamann Challani	3d943bccb6	feat(rln): publish rln artifacts nightly (#72 ) * feat(rln): publish rln artifacts on push to master * test(ci): check if artifacts are built on push to temp branch * fix(ci): run tests only on changes to src * fix(ci): add paths-ignore to prs * fix(ci): make paths more explicit * fix(ci): make publish workflow run * fix(ci): revert back to master ref * fix(ci): add os and sha to artifact name * test(ci): trigger publish * feat(ci): tar the artifacts * test(ci): split ci and publish * test(ci): only on master runs * feat(ci): replace with nightly releaser * chore(ci): extra newlines * fix(ci): Spelling Co-authored-by: G. <28568419+s1fr0@users.noreply.github.com> * feat(ci): build and publish rln wasm Co-authored-by: G. <28568419+s1fr0@users.noreply.github.com>	2022-11-15 16:35:29 +05:30
Aaryamann Challani	fba905f45d	fix(rln): throw if attempting to insert out of bounds (#67 ) * fix(rln): throw if attempting to insert out of bounds * chore(rln): better error msg * fix(merkle-tree): make it mimic OptimalMerkleTree impl * chore(rln): return result as is	2022-11-10 22:41:44 +05:30
Aaryamann Challani	490206aa44	feat(rln): ability to set leaves from a given index (#63 ) * feat(rln): ability to set leaves from a given index * style(rln): fmt * fix(rln): bubble the error * revert: "fix(rln): bubble the error" This reverts commit `40265082ba`. * fix(rln): replace ark::std::Zero with default * fix(rln): ordering of ffi api * fix(rln): use PoseidonHash::default_leaf * chore(rln): add ffi test for batching * docs(rln): add entry to changelog * fix(rln): address reviews * fix(changelog): fmt * fix(rln): safe conversion * fix(rln): reset tree with init func, add comments * chore(rln): add comment about init_tree_with_leaves * fix(rln): comment	2022-11-03 17:49:30 +05:30
G	afa4a09bba	Update public.rs fix(rln): remove unnecessary print	2022-10-10 08:52:36 +02:00
Richard Ramos	b95b151a1c	feat(rln-wasm): expose get_root and verify_with_roots	2022-10-07 14:34:03 -04:00
G	b77facc5e9	feat(RLN): Proof verification using provided roots (#61 ) * chore(rln): better comments * feat(rln): add verification with roots	2022-10-07 18:04:48 +02:00
Sanaz Taheri Boshrooyeh	5d429ca031	Initializes the private settlement package (#60 ) * initializes the private settlement crate * adds private settlement to the main cargo.toml	2022-10-06 13:44:16 -07:00
G	1df6c53ca0	fix(rln): fix order of inputs in comments (#59 )	2022-10-03 14:58:49 +02:00
Richard Ramos	878c3c5c5f	fix(rln-wasm): expose verify_rln_proof instead of verify (#58 )	2022-10-03 08:50:27 -04:00
G	a5aa4e8d4f	feat(rln): add seeded keygen (#56 ) * refactor(rln/zerokit): move poseidon to separate utils crate * refactor(rln/zerokit): move merkle tree to utils crate * feat(rln): add seeded keygen	2022-09-30 17:27:55 +02:00
G	bbacc9dcce	Add `utils` module (#53 ) * refactor(rln/zerokit): move poseidon to separate utils crate * refactor(rln/zerokit): move merkle tree to utils crate * refactor(rln/zerokit): move poseidon to separate utils crate * fix(utils/rln): fmt & conflict resolve * feat(utils): add parallel feature	2022-09-28 11:33:14 +02:00
G	c42fcfe644	Add GrainLFRS and PrimeField trait to Poseidon (#51 ) * refactor(rln): generate poseidon constants * refactor(rln): use traits in poseidon hash; refactor constants * fix(rln): fix poseidon hardcoded constants test * fix(rln): cargo fmt	2022-09-27 17:17:23 +02:00
fryorcraken.eth	99a7eb003f	ci: include wasm (#54 )	2022-09-28 01:09:48 +10:00
Richard Ramos	14f41d5340	chore: use cargo-make for building and publishing rln-wasm (#48 )	2022-09-24 10:27:46 -04:00
Richard Ramos	c401c0b21d	feat: wasm (#38 )	2022-09-20 08:22:46 -04:00
oskarth	4f08818d7a	docs: Add CHANGELOG for v0.1 release (#46 ) Co-authored-by: oskarth <noreply@dev.null>	2022-09-19 13:16:43 +08:00