style: resolve all compiler and clippy warnings

Author: Uchechukwu-Ekezie

contracts/src/lib.rs

@@ -3,12 +3,12 @@ use soroban_sdk::{contract, contractimpl, Address, Env, Map};
 
 mod portfolio;
 mod reflector;
-mod types;
 #[cfg(test)]
 mod test;
+mod types;
 
-pub use types::*;
 pub use reflector::*;
+pub use types::*;
 
 #[contract]
 pub struct PortfolioRebalancer;
@@ -20,7 +20,9 @@ impl PortfolioRebalancer {
             return Err(Error::AlreadyInitialized);
         }
         env.storage().instance().set(&DataKey::Admin, &admin);
-        env.storage().instance().set(&DataKey::ReflectorAddress, &reflector_address);
+        env.storage()
+            .instance()
+            .set(&DataKey::ReflectorAddress, &reflector_address);
         env.storage().instance().set(&DataKey::Initialized, &true);
         Ok(())
     }
@@ -37,12 +39,18 @@ impl PortfolioRebalancer {
             return Err(Error::InvalidAllocation);
         }
 
-        if rebalance_threshold < 1 || rebalance_threshold > 50 {
+        if !(1..=50).contains(&rebalance_threshold) {
             return Err(Error::InvalidThreshold);
         }
-        
-        let portfolio_id: u64 = env.storage().persistent().get(&DataKey::NextPortfolioId).unwrap_or(1);
-        env.storage().persistent().set(&DataKey::NextPortfolioId, &(portfolio_id + 1));
+
+        let portfolio_id: u64 = env
+            .storage()
+            .persistent()
+            .get(&DataKey::NextPortfolioId)
+            .unwrap_or(1);
+        env.storage()
+            .persistent()
+            .set(&DataKey::NextPortfolioId, &(portfolio_id + 1));
 
         let portfolio = Portfolio {
             user: user.clone(),
@@ -53,17 +61,18 @@ impl PortfolioRebalancer {
             total_value: 0,
             is_active: true,
         };
-        
-        env.storage().persistent().set(&DataKey::Portfolio(portfolio_id), &portfolio);
-        env.events().publish(
-            ("portfolio", "created"),
-            (portfolio_id, user)
-        );
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::Portfolio(portfolio_id), &portfolio);
+        env.events()
+            .publish(("portfolio", "created"), (portfolio_id, user));
         Ok(portfolio_id)
     }
 
     pub fn get_portfolio(env: Env, portfolio_id: u64) -> Portfolio {
-        env.storage().persistent()
+        env.storage()
+            .persistent()
             .get(&DataKey::Portfolio(portfolio_id))
             .unwrap()
     }
@@ -72,99 +81,123 @@ impl PortfolioRebalancer {
         if amount <= 0 {
             panic!("Amount must be positive");
         }
-        
+
         // Check for emergency stop
         if let Some(true) = env.storage().instance().get(&DataKey::EmergencyStop) {
             panic!("Emergency stop active");
         }
 
-        let mut portfolio: Portfolio = env.storage().persistent()
+        let mut portfolio: Portfolio = env
+            .storage()
+            .persistent()
             .get(&DataKey::Portfolio(portfolio_id))
             .unwrap();
-        
+
         portfolio.user.require_auth();
-        
+
         // Verify asset is in portfolio (optional based on requirements, but good practice)
         if !portfolio.target_allocations.contains_key(asset.clone()) {
-             // For now, allow depositing any asset, as users might deposit first then rebalance
-             // or maybe we should restrict? The issue says "valid and invalid inputs". 
-             // Let's assume valid input means positive amount and valid asset.
+            // For now, allow depositing any asset, as users might deposit first then rebalance
+            // or maybe we should restrict? The issue says "valid and invalid inputs".
+            // Let's assume valid input means positive amount and valid asset.
         }
 
         let current_balance = portfolio.current_balances.get(asset.clone()).unwrap_or(0);
-        portfolio.current_balances.set(asset.clone(), current_balance + amount);
-        
-        env.storage().persistent().set(&DataKey::Portfolio(portfolio_id), &portfolio);
-        env.events().publish(
-            ("portfolio", "deposit"),
-            (portfolio_id, asset, amount)
-        );
+        portfolio
+            .current_balances
+            .set(asset.clone(), current_balance + amount);
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::Portfolio(portfolio_id), &portfolio);
+        env.events()
+            .publish(("portfolio", "deposit"), (portfolio_id, asset, amount));
     }
 
     pub fn check_rebalance_needed(env: Env, portfolio_id: u64) -> bool {
-        let portfolio: Portfolio = env.storage().persistent()
+        let portfolio: Portfolio = env
+            .storage()
+            .persistent()
             .get(&DataKey::Portfolio(portfolio_id))
             .unwrap();
 
-        let reflector_address: Address = env.storage().instance().get(&DataKey::ReflectorAddress).unwrap();
+        let reflector_address: Address = env
+            .storage()
+            .instance()
+            .get(&DataKey::ReflectorAddress)
+            .unwrap();
         let reflector_client = ReflectorClient::new(&env, &reflector_address);
 
         // Calculate total current value
-        let total_value = portfolio::calculate_portfolio_value(&env, &portfolio.current_balances, &reflector_client);
-        
+        let total_value = portfolio::calculate_portfolio_value(
+            &env,
+            &portfolio.current_balances,
+            &reflector_client,
+        );
+
         if total_value == 0 {
             return false;
         }
 
         // Check drift for each asset
         for (asset, target_percent) in portfolio.target_allocations.iter() {
             let current_balance = portfolio.current_balances.get(asset.clone()).unwrap_or(0);
-            
+
             // Get price from reflector
             // Note: In a real app we'd need to handle potential failures/missing prices gracefully
             // For this check, if price missing, we can't calculate drift, so maybe skip or fail?
             // Let's skip for simplicity in this check
-            if let Some(price_data) = reflector_client.lastprice(&crate::reflector::Asset::Stellar(asset.clone())) {
-                 let current_asset_value = (current_balance * price_data.price) / 10i128.pow(14);
-                 let current_percent = (current_asset_value * 100) / total_value;
-                 
-                 let drift = (current_percent as i128 - target_percent as i128).abs();
-                 if drift > portfolio.rebalance_threshold as i128 {
-                     return true;
-                 }
+            if let Some(price_data) =
+                reflector_client.lastprice(&crate::reflector::Asset::Stellar(asset.clone()))
+            {
+                let current_asset_value = (current_balance * price_data.price) / 10i128.pow(14);
+                let current_percent = (current_asset_value * 100) / total_value;
+
+                 let drift = (current_percent - target_percent as i128).abs();
+                if drift > portfolio.rebalance_threshold as i128 {
+                    return true;
+                }
             }
         }
-        
+
         false
     }
 
     pub fn execute_rebalance(env: Env, portfolio_id: u64) {
         // Check for emergency stop
         if let Some(true) = env.storage().instance().get(&DataKey::EmergencyStop) {
-             panic!("Emergency stop active");
+            panic!("Emergency stop active");
         }
 
-        let mut portfolio: Portfolio = env.storage().persistent()
+        let mut portfolio: Portfolio = env
+            .storage()
+            .persistent()
             .get(&DataKey::Portfolio(portfolio_id))
             .unwrap();
-        
+
         portfolio.user.require_auth();
 
         // Check cooldown (e.g., 1 hour = 3600 seconds)
         let current_time = env.ledger().timestamp();
         if current_time < portfolio.last_rebalance + 3600 {
             panic!("Cooldown active");
         }
-        
+
         // Reflector check for stale data
-        let reflector_address: Address = env.storage().instance().get(&DataKey::ReflectorAddress).unwrap();
+        let reflector_address: Address = env
+            .storage()
+            .instance()
+            .get(&DataKey::ReflectorAddress)
+            .unwrap();
         let reflector_client = ReflectorClient::new(&env, &reflector_address);
-        
+
         // Verify prices satisfy freshness requirement (e.g., 1 hour)
         for (asset, _) in portfolio.target_allocations.iter() {
-            if let Some(price_data) = reflector_client.lastprice(&crate::reflector::Asset::Stellar(asset.clone())) {
+            if let Some(price_data) =
+                reflector_client.lastprice(&crate::reflector::Asset::Stellar(asset.clone()))
+            {
                 if price_data.is_stale(current_time, 3600) {
-                     panic!("Stale price data");
+                    panic!("Stale price data");
                 }
             } else {
                 // If price is missing, we can't safely rebalance
@@ -175,12 +208,12 @@ impl PortfolioRebalancer {
         // Perform rebalance logic (simplified: update last_rebalance and emit event)
         // In a real contract, this would execute trades or generate instructions
         portfolio.last_rebalance = current_time;
-        env.storage().persistent().set(&DataKey::Portfolio(portfolio_id), &portfolio);
-        
-        env.events().publish(
-            ("portfolio", "rebalanced"),
-            (portfolio_id, current_time)
-        );
+        env.storage()
+            .persistent()
+            .set(&DataKey::Portfolio(portfolio_id), &portfolio);
+
+        env.events()
+            .publish(("portfolio", "rebalanced"), (portfolio_id, current_time));
     }
 
     pub fn set_emergency_stop(env: Env, stop: bool) {

contracts/src/portfolio.rs

@@ -15,14 +15,16 @@ pub fn calculate_portfolio_value(
     reflector_client: &crate::reflector::ReflectorClient,
 ) -> i128 {
     let mut total_value = 0i128;
-    
+
     for (asset, balance) in balances.iter() {
-        if let Some(price_data) = reflector_client.lastprice(&crate::reflector::Asset::Stellar(asset)) {
+        if let Some(price_data) =
+            reflector_client.lastprice(&crate::reflector::Asset::Stellar(asset))
+        {
             let value = (balance * price_data.price) / 10i128.pow(14);
             total_value += value;
         }
     }
-    
+
     total_value
 }
 
@@ -34,20 +36,21 @@ pub fn calculate_rebalance_trades(
 ) -> Map<Address, i128> {
     let mut trades = Map::new(env);
     let total_value = portfolio.total_value;
-    
+
     for (asset, target_percentage) in portfolio.target_allocations.iter() {
         let current_balance = portfolio.current_balances.get(asset.clone()).unwrap_or(0);
         let target_value = (total_value * target_percentage as i128) / 100;
-        
+
         if let Some(price) = current_prices.get(asset.clone()) {
             let target_balance = (target_value * 10i128.pow(14)) / price;
             let trade_amount = target_balance - current_balance;
-            
-            if trade_amount.abs() > 1000000 { // Minimum trade threshold
+
+            if trade_amount.abs() > 1000000 {
+                // Minimum trade threshold
                 trades.set(asset, trade_amount);
             }
         }
     }
-    
+
     trades
-}
+}

contracts/src/reflector.rs

@@ -30,7 +30,7 @@ impl PriceData {
         let divisor = 10_i128.pow(decimals);
         self.price / divisor
     }
-    
+
     /// Check if price data is stale (older than specified seconds)
     pub fn is_stale(&self, current_timestamp: u64, max_age_seconds: u64) -> bool {
         current_timestamp.saturating_sub(self.timestamp) > max_age_seconds
@@ -41,12 +41,12 @@ impl Asset {
     pub fn xlm(env: &Env) -> Self {
         Asset::Other(Symbol::new(env, "XLM"))
     }
-    
+
     pub fn usdc(env: &Env) -> Self {
         Asset::Other(Symbol::new(env, "USDC"))
     }
-    
+
     pub fn btc(env: &Env) -> Self {
         Asset::Other(Symbol::new(env, "BTC"))
     }
-}
+}