Add ReentrancyGuard to all StepFi contracts

contracts/parameters-contract/src/errors.rs

@@ -8,4 +8,5 @@ pub enum ParametersError {
     NotAdmin = 2,
     InvalidParameters = 3,
     NotInitialized = 4,
+    ReentrancyDetected = 5,
 }

contracts/parameters-contract/src/lib.rs

@@ -37,7 +37,9 @@ impl ParametersContract {
     pub fn upgrade(env: Env, new_wasm_hash: soroban_sdk::BytesN<32>) {
         let admin = storage::get_admin(&env).unwrap_or_else(|err| panic_with_error!(&env, err));
         admin.require_auth();
+        Self::enter_non_reentrant(&env);
         env.deployer().update_current_contract_wasm(new_wasm_hash);
+        Self::exit_non_reentrant(&env);
     }
     pub fn get_admin(env: Env) -> Result<Address, ParametersError> {
         storage::get_admin(&env)
@@ -48,8 +50,10 @@ impl ParametersContract {
         old_admin.require_auth();
         access::require_admin(&env, &old_admin);
 
+        Self::enter_non_reentrant(&env);
         storage::set_admin(&env, &new_admin);
         events::emit_admin_updated(&env, &old_admin, &new_admin);
+        Self::exit_non_reentrant(&env);
     }
 
     pub fn get_parameters(env: Env) -> Result<ProtocolParameters, ParametersError> {
@@ -61,8 +65,10 @@ impl ParametersContract {
         access::require_admin(&env, &admin);
         Self::validate_parameters(&env, &params);
 
+        Self::enter_non_reentrant(&env);
         storage::set_parameters(&env, &params);
         events::emit_parameters_updated(&env, &admin, &params);
+        Self::exit_non_reentrant(&env);
     }
 
     fn validate_parameters(env: &Env, params: &ProtocolParameters) {
@@ -73,6 +79,19 @@ impl ParametersContract {
             panic_with_error!(env, ParametersError::InvalidParameters);
         }
     }
+
+    fn enter_non_reentrant(env: &Env) {
+        if storage::is_reentrancy_locked(env)
+            .unwrap_or_else(|err| panic_with_error!(env, err))
+        {
+            panic_with_error!(env, ParametersError::ReentrancyDetected);
+        }
+        storage::set_reentrancy_locked(env, true);
+    }
+
+    fn exit_non_reentrant(env: &Env) {
+        storage::set_reentrancy_locked(env, false);
+    }
 }
 
 #[cfg(test)]

contracts/parameters-contract/src/storage.rs

@@ -5,6 +5,7 @@ use crate::types::ProtocolParameters;
 
 pub const ADMIN_KEY: Symbol = symbol_short!("ADMIN");
 pub const PARAMS_KEY: Symbol = symbol_short!("PARAMS");
+pub const REENTRANCY_LOCK: Symbol = symbol_short!("LOCKED");
 
 pub fn has_admin(env: &Env) -> bool {
     env.storage().instance().has(&ADMIN_KEY)
@@ -31,3 +32,15 @@ pub fn get_parameters(env: &Env) -> Result<ProtocolParameters, ParametersError>
 pub fn set_parameters(env: &Env, params: &ProtocolParameters) {
     env.storage().instance().set(&PARAMS_KEY, params);
 }
+
+pub fn is_reentrancy_locked(env: &Env) -> Result<bool, ParametersError> {
+    Ok(env
+        .storage()
+        .instance()
+        .get(&REENTRANCY_LOCK)
+        .unwrap_or(false))
+}
+
+pub fn set_reentrancy_locked(env: &Env, locked: bool) {
+    env.storage().instance().set(&REENTRANCY_LOCK, &locked);
+}

contracts/parameters-contract/src/tests.rs

@@ -2,7 +2,11 @@ use crate::{
     default_parameters, ParametersContract, ParametersContractClient, ParametersError,
     ProtocolParameters,
 };
-use soroban_sdk::{testutils::Address as _, Address, Env};
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::Address as _,
+    Address, Env, Symbol,
+};
 
 fn setup() -> (Env, ParametersContractClient<'static>, Address) {
     let env = Env::default();

contracts/reputation-contract/src/errors.rs

@@ -11,4 +11,5 @@ pub enum ReputationError {
     Overflow = 4,
     Underflow = 5,
     NotInitialized = 6,
+    ReentrancyDetected = 7,
 }

contracts/reputation-contract/src/lib.rs

@@ -35,6 +35,8 @@ impl ReputationContract {
         updater.require_auth();
         access::require_updater(&env, &updater);
 
+        Self::enter_non_reentrant(&env);
+
         let old_score = storage::read_score(&env, &user)
             .unwrap_or_else(|err| soroban_sdk::panic_with_error!(&env, err));
         let new_score = old_score
@@ -50,6 +52,8 @@ impl ReputationContract {
 
         let reason = symbol_short!("increase");
         events::emit_score_changed(&env, &user, old_score, new_score, &reason);
+
+        Self::exit_non_reentrant(&env);
     }
 
     /// Decrease a user's reputation score by a given amount
@@ -58,6 +62,8 @@ impl ReputationContract {
         updater.require_auth();
         access::require_updater(&env, &updater);
 
+        Self::enter_non_reentrant(&env);
+
         let old_score = storage::read_score(&env, &user)
             .unwrap_or_else(|err| soroban_sdk::panic_with_error!(&env, err));
         let new_score = match old_score.checked_sub(amount) {
@@ -69,6 +75,8 @@ impl ReputationContract {
 
         let reason = symbol_short!("decrease");
         events::emit_score_changed(&env, &user, old_score, new_score, &reason);
+
+        Self::exit_non_reentrant(&env);
     }
 
     /// Set a user's reputation score to a specific value
@@ -81,12 +89,16 @@ impl ReputationContract {
             soroban_sdk::panic_with_error!(&env, ReputationError::OutOfBounds);
         }
 
+        Self::enter_non_reentrant(&env);
+
         let old_score = storage::read_score(&env, &user)
             .unwrap_or_else(|err| soroban_sdk::panic_with_error!(&env, err));
         storage::write_score(&env, &user, new_score);
 
         let reason = symbol_short!("set");
         events::emit_score_changed(&env, &user, old_score, new_score, &reason);
+
+        Self::exit_non_reentrant(&env);
     }
 
     /// Add a mentor vouching boost to a user's reputation score.
@@ -95,6 +107,8 @@ impl ReputationContract {
         updater.require_auth();
         access::require_updater(&env, &updater);
 
+        Self::enter_non_reentrant(&env);
+
         let old_score = storage::read_score(&env, &user)
             .unwrap_or_else(|err| soroban_sdk::panic_with_error!(&env, err));
         let new_score = old_score
@@ -110,6 +124,8 @@ impl ReputationContract {
 
         let reason = symbol_short!("boost");
         events::emit_score_changed(&env, &user, old_score, new_score, &reason);
+
+        Self::exit_non_reentrant(&env);
     }
 
     /// Remove a mentor vouching boost from a user's reputation score.
@@ -118,6 +134,8 @@ impl ReputationContract {
         updater.require_auth();
         access::require_updater(&env, &updater);
 
+        Self::enter_non_reentrant(&env);
+
         let old_score = storage::read_score(&env, &user)
             .unwrap_or_else(|err| soroban_sdk::panic_with_error!(&env, err));
         let new_score = match old_score.checked_sub(amount) {
@@ -129,6 +147,8 @@ impl ReputationContract {
 
         let reason = symbol_short!("unboost");
         events::emit_score_changed(&env, &user, old_score, new_score, &reason);
+
+        Self::exit_non_reentrant(&env);
     }
 
     /// Set or remove an address as an authorized updater
@@ -137,8 +157,12 @@ impl ReputationContract {
         admin.require_auth();
         access::require_admin(&env, &admin);
 
+        Self::enter_non_reentrant(&env);
+
         storage::set_updater(&env, &updater, allowed);
         events::emit_updater_changed(&env, &updater, allowed);
+
+        Self::exit_non_reentrant(&env);
     }
 
     /// Check if an address is an authorized updater
@@ -156,8 +180,13 @@ impl ReputationContract {
             // Admin exists, require current admin authorization
             old_admin.require_auth();
             access::require_admin(&env, &old_admin);
+
+            Self::enter_non_reentrant(&env);
+
             storage::set_admin(&env, &new_admin);
             events::emit_admin_changed(&env, &old_admin, &new_admin);
+
+            Self::exit_non_reentrant(&env);
         } else {
             // No admin exists, allow setting (initialization)
             storage::set_admin(&env, &new_admin);
@@ -171,11 +200,27 @@ impl ReputationContract {
         let admin = storage::get_admin(&env)
             .unwrap_or_else(|err| soroban_sdk::panic_with_error!(&env, err));
         admin.require_auth();
+
+        Self::enter_non_reentrant(&env);
         env.deployer().update_current_contract_wasm(new_wasm_hash);
+        Self::exit_non_reentrant(&env);
     }
     pub fn get_admin(env: Env) -> Result<Address, ReputationError> {
         storage::get_admin(&env)
     }
+
+    fn enter_non_reentrant(env: &Env) {
+        if storage::is_reentrancy_locked(env)
+            .unwrap_or_else(|err| soroban_sdk::panic_with_error!(env, err))
+        {
+            soroban_sdk::panic_with_error!(env, ReputationError::ReentrancyDetected);
+        }
+        storage::set_reentrancy_locked(env, true);
+    }
+
+    fn exit_non_reentrant(env: &Env) {
+        storage::set_reentrancy_locked(env, false);
+    }
 }
 
 #[cfg(test)]

contracts/reputation-contract/src/storage.rs

@@ -6,6 +6,7 @@ use crate::errors::ReputationError;
 pub const ADMIN_KEY: Symbol = symbol_short!("ADMIN");
 pub const UPDATERS_MAP: Symbol = symbol_short!("UPDATERS");
 pub const SCORES_MAP: Symbol = symbol_short!("SCORES");
+pub const REENTRANCY_LOCK: Symbol = symbol_short!("LOCKED");
 
 /// Get the admin address from storage
 pub fn get_admin(env: &Env) -> Result<Address, ReputationError> {
@@ -70,3 +71,15 @@ pub fn set_updater(env: &Env, updater: &Address, allowed: bool) {
 
     env.storage().instance().set(&UPDATERS_MAP, &updaters);
 }
+
+pub fn is_reentrancy_locked(env: &Env) -> Result<bool, ReputationError> {
+    Ok(env
+        .storage()
+        .instance()
+        .get(&REENTRANCY_LOCK)
+        .unwrap_or(false))
+}
+
+pub fn set_reentrancy_locked(env: &Env, locked: bool) {
+    env.storage().instance().set(&REENTRANCY_LOCK, &locked);
+}