Update to semaphore-rs 0.3.0

Cargo.toml

@@ -50,9 +50,10 @@ oz-api = { path = "crates/oz-api" }
 prometheus = "0.13.3"
 reqwest = { version = "0.12.8", features = ["json"] }
 ruint = { version = "1.12.3", features = ["primitive-types", "sqlx"] }
-semaphore = { git = "https://github.com/worldcoin/semaphore-rs", rev = "251e908d89d598c976901306bc29f06ab59e799d", features = [
-    "depth_30",
-] }
+semaphore-rs = { version = "0.3.0", features = ["depth_30"] }
+semaphore-rs-poseidon = { version = "0.3.0" }
+semaphore-rs-trees = { version = "0.3.0" }
+semaphore-rs-hasher = { version = "0.3.0" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 sqlx = { version = "0.8.2", features = [
@@ -89,9 +90,7 @@ maplit = "1.0.2"
 micro-oz = { path = "crates/micro-oz" }
 postgres-docker-utils = { path = "crates/postgres-docker-utils" }
 regex = { version = "1.7.1", features = ["std"] }
-semaphore = { git = "https://github.com/worldcoin/semaphore-rs", rev = "251e908d89d598c976901306bc29f06ab59e799d", features = [
-    "depth_20",
-] }
+semaphore-rs = { version = "0.3.0", features = ["depth_20"] }
 similar-asserts = "1.5.0"
 test-case = "3.0"
 testcontainers = "0.15.0"

src/app.rs

@@ -3,7 +3,7 @@ use std::sync::{Arc, OnceLock};
 
 use chrono::{Duration, Utc};
 use ruint::Uint;
-use semaphore::protocol::verify_proof;
+use semaphore_rs::protocol::verify_proof;
 use tracing::{info, instrument, warn};
 
 use crate::config::Config;

src/bin/tool.rs

@@ -3,9 +3,9 @@ use std::path::{Path, PathBuf};
 use anyhow::Context;
 use clap::Parser;
 use ethers::core::rand::{thread_rng, RngCore};
-use semaphore::identity::Identity;
-use semaphore::poseidon_tree::Proof;
-use semaphore::Field;
+use semaphore_rs::identity::Identity;
+use semaphore_rs::poseidon_tree::Proof;
+use semaphore_rs::Field;
 use serde::{Deserialize, Serialize};
 use signup_sequencer::server::data::{
     InclusionProofRequest, InclusionProofResponse, InsertCommitmentRequest,
@@ -231,10 +231,12 @@ async fn main() -> anyhow::Result<()> {
 
             let root = response.root.context("Missing root")?;
 
-            let nullifier_hash =
-                semaphore::protocol::generate_nullifier_hash(&identity, x.external_nullifier_hash);
+            let nullifier_hash = semaphore_rs::protocol::generate_nullifier_hash(
+                &identity,
+                x.external_nullifier_hash,
+            );
 
-            let proof = semaphore::protocol::generate_proof(
+            let proof = semaphore_rs::protocol::generate_proof(
                 &identity,
                 &response.proof.context("Missing proof")?,
                 x.external_nullifier_hash,

src/config.rs

@@ -4,7 +4,7 @@ use std::path::Path;
 use std::time::Duration;
 
 use ethers::types::{Address, H160};
-use semaphore::Field;
+use semaphore_rs::Field;
 use serde::{Deserialize, Serialize};
 
 use crate::prover::ProverConfig;
@@ -341,8 +341,8 @@ pub mod default {
         false
     }
 
-    pub fn initial_leaf_value() -> semaphore::Field {
-        semaphore::Field::from_be_bytes(hex_literal::hex!(
+    pub fn initial_leaf_value() -> semaphore_rs::Field {
+        semaphore_rs::Field::from_be_bytes(hex_literal::hex!(
             "0000000000000000000000000000000000000000000000000000000000000000"
         ))
     }

src/database/mod.rs

@@ -186,8 +186,8 @@ mod test {
     use ethers::types::U256;
     use postgres_docker_utils::DockerContainer;
     use ruint::Uint;
-    use semaphore::poseidon_tree::LazyPoseidonTree;
-    use semaphore::Field;
+    use semaphore_rs::poseidon_tree::LazyPoseidonTree;
+    use semaphore_rs::Field;
     use testcontainers::clients::Cli;
 
     use super::Database;

src/identity/validator.rs

@@ -1,5 +1,5 @@
 use ruint::uint;
-use semaphore::Field;
+use semaphore_rs::Field;
 
 use crate::config::Config;
 use crate::identity_tree::Hash;

src/identity_tree/builder.rs

@@ -1,9 +1,9 @@
 use std::cmp::min;
 use std::sync::{Arc, Mutex};
 
-use semaphore::lazy_merkle_tree::LazyMerkleTree;
-use semaphore::poseidon_tree::PoseidonHash;
-use semaphore::{lazy_merkle_tree, Field};
+use semaphore_rs::Field;
+use semaphore_rs_poseidon::Poseidon as PoseidonHash;
+use semaphore_rs_trees::lazy::{self, LazyMerkleTree};
 use tracing::{info, warn};
 
 use crate::identity_tree::{
@@ -13,7 +13,7 @@ use crate::identity_tree::{
 
 /// A helper for building the first tree version. Exposes a type-safe API over
 /// building a sequence of tree versions efficiently.
-pub struct CanonicalTreeBuilder(TreeVersionData<lazy_merkle_tree::Canonical>);
+pub struct CanonicalTreeBuilder(TreeVersionData<lazy::Canonical>);
 
 impl CanonicalTreeBuilder {
     /// Creates a new builder with the given parameters.
@@ -46,17 +46,22 @@ impl CanonicalTreeBuilder {
             initial_leaves.split_at(initial_leaves_in_dense_count);
 
         info!("Creating mmap dense tree");
-        let tree =
-            PoseidonTree::<lazy_merkle_tree::Canonical>::new_mmapped_with_dense_prefix_with_init_values(
-                tree_depth,
-                dense_prefix_depth,
-                &default_leaf,
-                &initial_leaves_in_dense
-                    .iter()
-                    .map(|tree_update| tree_update.as_ref().map(|v| v.element).unwrap_or(default_leaf))
-                    .collect::<Vec<Field>>(),
-                mmap_file_path
-            ).unwrap();
+        let tree = PoseidonTree::<lazy::Canonical>::new_mmapped_with_dense_prefix_with_init_values(
+            tree_depth,
+            dense_prefix_depth,
+            &default_leaf,
+            &initial_leaves_in_dense
+                .iter()
+                .map(|tree_update| {
+                    tree_update
+                        .as_ref()
+                        .map(|v| v.element)
+                        .unwrap_or(default_leaf)
+                })
+                .collect::<Vec<Field>>(),
+            mmap_file_path,
+        )
+        .unwrap();
 
         info!("Applying leaves not in dense tree");
         let metadata = CanonicalTreeMetadata {
@@ -100,8 +105,8 @@ impl CanonicalTreeBuilder {
         mmap_file_path: &str,
     ) -> Option<Self> {
         info!("Restoring tree from file");
-        let tree: LazyMerkleTree<PoseidonHash, lazy_merkle_tree::Canonical> =
-            match PoseidonTree::<lazy_merkle_tree::Canonical>::attempt_dense_mmap_restore(
+        let tree: LazyMerkleTree<PoseidonHash, lazy::Canonical> =
+            match PoseidonTree::<lazy::Canonical>::attempt_dense_mmap_restore(
                 tree_depth,
                 dense_prefix_depth,
                 default_leaf,
@@ -164,13 +169,13 @@ impl CanonicalTreeBuilder {
 /// building a sequence of tree versions efficiently.
 pub struct DerivedTreeBuilder<P: Version> {
     prev: TreeVersion<P>,
-    current: TreeVersionData<lazy_merkle_tree::Derived>,
+    current: TreeVersionData<lazy::Derived>,
 }
 
 impl<P: Version> DerivedTreeBuilder<P> {
     #[must_use]
     fn new<Prev: Version>(
-        state: TreeVersionState<lazy_merkle_tree::Derived>,
+        state: TreeVersionState<lazy::Derived>,
         prev: TreeVersion<Prev>,
     ) -> DerivedTreeBuilder<Prev> {
         let metadata = DerivedTreeMetadata {

src/identity_tree/initializer.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 use std::time::Instant;
 
-use semaphore::poseidon_tree::LazyPoseidonTree;
+use semaphore_rs::poseidon_tree::LazyPoseidonTree;
 use tracing::{info, instrument, warn};
 
 use crate::config::TreeConfig;

src/identity_tree/mod.rs

@@ -1,10 +1,12 @@
 use std::sync::{Arc, Mutex, MutexGuard};
 
 use chrono::Utc;
-use semaphore::lazy_merkle_tree::LazyMerkleTree;
-use semaphore::merkle_tree::Hasher;
-use semaphore::poseidon_tree::{PoseidonHash, Proof};
-use semaphore::{lazy_merkle_tree, Field};
+use semaphore_rs::poseidon_tree::Proof;
+use semaphore_rs::Field;
+use semaphore_rs_hasher::Hasher;
+use semaphore_rs_poseidon::Poseidon as PoseidonHash;
+use semaphore_rs_trees::lazy;
+use semaphore_rs_trees::lazy::LazyMerkleTree;
 use serde::{Deserialize, Serialize};
 use sqlx::prelude::FromRow;
 use tracing::{info, warn};
@@ -84,28 +86,28 @@ pub struct CanonicalTreeMetadata {
 /// updates performed since previous version.
 pub struct DerivedTreeMetadata {
     diff: Vec<AppliedTreeUpdate>,
-    ref_state: TreeVersionState<lazy_merkle_tree::Derived>,
+    ref_state: TreeVersionState<lazy::Derived>,
 }
 
 #[derive(Clone)]
 pub struct AppliedTreeUpdate {
     pub update: TreeUpdate,
-    pub post_state: TreeVersionState<lazy_merkle_tree::Derived>,
+    pub post_state: TreeVersionState<lazy::Derived>,
 }
 
 /// Trait used to associate a version marker with its metadata type.
 pub trait AllowedTreeVersionMarker
 where
-    Self: lazy_merkle_tree::VersionMarker,
+    Self: lazy::VersionMarker,
 {
     type Metadata;
 }
 
-impl AllowedTreeVersionMarker for lazy_merkle_tree::Canonical {
+impl AllowedTreeVersionMarker for lazy::Canonical {
     type Metadata = CanonicalTreeMetadata;
 }
 
-impl AllowedTreeVersionMarker for lazy_merkle_tree::Derived {
+impl AllowedTreeVersionMarker for lazy::Derived {
     type Metadata = DerivedTreeMetadata;
 }
 
@@ -115,8 +117,8 @@ pub struct TreeVersionState<V: AllowedTreeVersionMarker> {
     pub last_sequence_id: usize,
 }
 
-impl TreeVersionState<lazy_merkle_tree::Canonical> {
-    fn derived(&self) -> TreeVersionState<lazy_merkle_tree::Derived> {
+impl TreeVersionState<lazy::Canonical> {
+    fn derived(&self) -> TreeVersionState<lazy::Derived> {
         TreeVersionState {
             tree: self.tree.derived(),
             next_leaf: self.next_leaf,
@@ -125,7 +127,7 @@ impl TreeVersionState<lazy_merkle_tree::Canonical> {
     }
 }
 
-impl Clone for TreeVersionState<lazy_merkle_tree::Derived> {
+impl Clone for TreeVersionState<lazy::Derived> {
     fn clone(&self) -> Self {
         TreeVersionState {
             tree: self.tree.clone(),
@@ -164,7 +166,7 @@ pub trait BasicTreeOps {
 
 impl<V> TreeVersionData<V>
 where
-    V: lazy_merkle_tree::VersionMarker + AllowedTreeVersionMarker,
+    V: lazy::VersionMarker + AllowedTreeVersionMarker,
     Self: BasicTreeOps,
 {
     /// Gets the current tree root.
@@ -257,7 +259,7 @@ where
     }
 }
 
-impl TreeVersionData<lazy_merkle_tree::Derived>
+impl TreeVersionData<lazy::Derived>
 where
     Self: BasicTreeOps,
 {
@@ -309,7 +311,7 @@ where
     }
 }
 
-impl BasicTreeOps for TreeVersionData<lazy_merkle_tree::Canonical> {
+impl BasicTreeOps for TreeVersionData<lazy::Canonical> {
     fn update(&mut self, sequence_id: usize, leaf_index: usize, element: Hash) {
         take_mut::take(&mut self.state.tree, |tree| {
             tree.update_with_mutation(leaf_index, &element)
@@ -362,11 +364,11 @@ impl BasicTreeOps for TreeVersionData<lazy_merkle_tree::Canonical> {
     }
 }
 
-impl TreeVersionData<lazy_merkle_tree::Derived> {
+impl TreeVersionData<lazy::Derived> {
     /// This method recalculate tree to use different tree version as a base.
     /// The tree itself is same in terms of root hash but differs how
     /// internally is stored in memory and on disk.
-    fn rebuild_on(&mut self, mut tree: PoseidonTree<lazy_merkle_tree::Derived>) {
+    fn rebuild_on(&mut self, mut tree: PoseidonTree<lazy::Derived>) {
         self.metadata.ref_state.tree = tree.clone();
         for update in &mut self.metadata.diff {
             tree = tree.update(update.update.leaf_index, &update.update.element);
@@ -380,7 +382,7 @@ impl TreeVersionData<lazy_merkle_tree::Derived> {
     }
 }
 
-impl BasicTreeOps for TreeVersionData<lazy_merkle_tree::Derived> {
+impl BasicTreeOps for TreeVersionData<lazy::Derived> {
     fn update(&mut self, sequence_id: usize, leaf_index: usize, element: Hash) {
         let updated_tree = self.state.tree.update(leaf_index, &element);
         let updated_next_leaf = if element != Hash::ZERO {
@@ -462,7 +464,7 @@ where
 #[derive(Clone)]
 pub struct Canonical;
 impl Version for Canonical {
-    type TreeVersion = lazy_merkle_tree::Canonical;
+    type TreeVersion = lazy::Canonical;
 }
 impl HasNextVersion for Canonical {}
 
@@ -471,7 +473,7 @@ impl HasNextVersion for Canonical {}
 #[derive(Clone)]
 pub struct Intermediate;
 impl Version for Intermediate {
-    type TreeVersion = lazy_merkle_tree::Derived;
+    type TreeVersion = lazy::Derived;
 }
 impl HasNextVersion for Intermediate {}
 
@@ -481,7 +483,7 @@ impl HasNextVersion for Intermediate {}
 #[derive(Clone)]
 pub struct Latest;
 impl Version for Latest {
-    type TreeVersion = lazy_merkle_tree::Derived;
+    type TreeVersion = lazy::Derived;
 }
 
 /// Marker for any tree version that has a predecessor. It is useful internally
@@ -490,7 +492,7 @@ impl Version for Latest {
 #[derive(Clone)]
 struct AnyDerived;
 impl Version for AnyDerived {
-    type TreeVersion = lazy_merkle_tree::Derived;
+    type TreeVersion = lazy::Derived;
 }
 
 /// The most important public-facing type of this library. Exposes a type-safe
@@ -504,7 +506,7 @@ impl<V: Version> Clone for TreeVersion<V> {
     }
 }
 
-impl<V: Version<TreeVersion = lazy_merkle_tree::Derived>> TreeVersion<V> {
+impl<V: Version<TreeVersion = lazy::Derived>> TreeVersion<V> {
     /// Only used internally to upcast a compatible tree version to
     /// `AnyDerived`.
     fn as_derived(&self) -> TreeVersion<AnyDerived> {
@@ -678,7 +680,7 @@ pub trait ReversibleVersion {
     fn rewind_updates_up_to(&self, root: Hash) -> usize;
 }
 
-impl<V: Version<TreeVersion = lazy_merkle_tree::Derived>> ReversibleVersion for TreeVersion<V> {
+impl<V: Version<TreeVersion = lazy::Derived>> ReversibleVersion for TreeVersion<V> {
     fn rewind_updates_up_to(&self, root: Hash) -> usize {
         self.get_data().rewind_updates_up_to(root)
     }

src/identity_tree/state.rs

@@ -1,4 +1,4 @@
-use semaphore::Field;
+use semaphore_rs::Field;
 
 use crate::identity_tree::{
     Canonical, InclusionProof, Intermediate, Latest, ProcessedStatus, TreeItem, TreeVersion,

src/server/data.rs

@@ -1,7 +1,7 @@
 use chrono::Utc;
 use hyper::StatusCode;
-use semaphore::protocol::Proof;
-use semaphore::Field;
+use semaphore_rs::protocol::Proof;
+use semaphore_rs::Field;
 use serde::{Deserialize, Serialize};
 
 use crate::identity_tree::{Hash, InclusionProof, ProcessedStatus, RootItem, Status};
@@ -11,7 +11,7 @@ use crate::prover::{ProverConfig, ProverType};
 pub struct InclusionProofResponse {
     pub status: Status,
     pub root: Option<Field>,
-    pub proof: Option<semaphore::poseidon_tree::Proof>,
+    pub proof: Option<semaphore_rs::poseidon_tree::Proof>,
     pub message: Option<String>,
 }