Fix unit tests compilation (#9)

* Fix unit test: test_set_tier_limits
* Fix unit test: test_user_register
* Fix unit test: test_update_on_epoch_changes

prover/src/main.rs

@@ -49,9 +49,8 @@ const PROVER_MINIMAL_AMOUNT_FOR_REGISTRATION: U256 =
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    
     // debug!("Args: {:?}", std::env::args());
-    
+
     let filter = EnvFilter::builder()
         .with_default_directive(LevelFilter::INFO.into())
         .from_env_lossy();

prover/src/tier.rs

@@ -1,8 +1,11 @@
-use alloy::primitives::U256;
 use std::collections::{BTreeMap, HashSet};
-use std::ops::{Deref, DerefMut};
+use std::ops::{
+    ControlFlow,
+    Deref, DerefMut
+};
 // third-party
 use derive_more::{From, Into};
+use alloy::primitives::U256;
 // internal
 use crate::user_db_service::SetTierLimitsError;
 use smart_contract::{Tier, TierIndex};
@@ -95,22 +98,28 @@ impl TierLimits {
 
     /// Given some karma amount, find the matching Tier
     pub(crate) fn get_tier_by_karma(&self, karma_amount: &U256) -> Option<(TierIndex, Tier)> {
-        #[derive(Default)]
+        
         struct Context<'a> {
             prev: Option<(&'a TierIndex, &'a Tier)>,
         }
 
+        let ctx_initial = Context { prev: None };
         let ctx = self
             .0
             .iter()
-            .try_fold(Context::default(), |mut state, (tier_index, tier)| {
+            .try_fold(ctx_initial, |mut state, (tier_index, tier)| {
                 if karma_amount < &tier.min_karma {
-                    return None;
+                    ControlFlow::Break(state)
+                } else {
+                    state.prev = Some((tier_index, tier));
+                    ControlFlow::Continue(state)
                 }
-                state.prev = Some((tier_index, tier));
-                Some(state)
-            })?;
+            });
 
-        ctx.prev.map(|p| (*p.0, p.1.clone()))
+        if let Some(ctx) = ctx.break_value() {
+            ctx.prev.map(|p| (*p.0, p.1.clone()))
+        } else {
+            None
+        }
     }
 }

prover/src/user_db_service.rs

@@ -85,8 +85,8 @@ impl UserRegistry {
     fn register(&self, address: Address) -> Result<Fr, RegisterError> {
         let (identity_secret_hash, id_commitment) = keygen();
         let index = self.inner.len();
-        let _ = self
-            .inner
+
+        self.inner
             .insert(
                 address,
                 (
@@ -98,7 +98,7 @@ impl UserRegistry {
                     MerkleTreeIndex(index),
                 ),
             )
-            .map_err(|_e| RegisterError::AlreadyRegistered(address));
+            .map_err(|_e| RegisterError::AlreadyRegistered(address))?;
 
         let rate_commit = poseidon_hash(&[id_commitment, Fr::from(u64::from(self.rate_limit))]);
         self.merkle_tree
@@ -416,6 +416,9 @@ impl UserDbService {
 #[cfg(test)]
 mod tests {
     use super::*;
+    // std
+    use std::collections::BTreeMap;
+    // third-party
     use alloy::primitives::address;
     use async_trait::async_trait;
     use claims::{assert_err, assert_matches};
@@ -662,7 +665,7 @@ mod tests {
 
         let tier_limits = BTreeMap::from([
             (
-                TierIndex::from(0),
+                TierIndex::from(1),
                 Tier {
                     name: "Basic".into(),
                     min_karma: U256::from(10),
@@ -672,7 +675,7 @@ mod tests {
                 },
             ),
             (
-                TierIndex::from(1),
+                TierIndex::from(2),
                 Tier {
                     name: "Power User".into(),
                     min_karma: U256::from(50),