Merge pull request #206 from ritik4ever/fix/gas-optimization-storage

fix(gas): replace Map blobs with per-key persistent storage in escrow and rewards (#161)

Author: ISTIFANUS-N

contracts/teachlink/src/escrow.rs

@@ -9,7 +9,7 @@ use crate::insurance::InsuranceManager;
 use crate::storage::{ESCROWS, ESCROW_COUNT};
 use crate::types::{DisputeOutcome, Escrow, EscrowApprovalKey, EscrowSigner, EscrowStatus};
 use crate::validation::EscrowValidator;
-use soroban_sdk::{symbol_short, vec, Address, Bytes, Env, IntoVal, Map, Vec};
+use soroban_sdk::{symbol_short, vec, Address, Bytes, Env, IntoVal, Vec};
 
 pub struct EscrowManager;
 
@@ -98,9 +98,9 @@ impl EscrowManager {
             dispute_reason: None,
         };
 
-        let mut escrows = Self::load_escrows(env);
-        escrows.set(escrow_count, escrow.clone());
-        env.storage().instance().set(&ESCROWS, &escrows);
+        env.storage()
+            .persistent()
+            .set(&(ESCROWS, escrow_count), &escrow);
 
         EscrowAnalyticsManager::update_creation(env, amount);
 
@@ -449,7 +449,7 @@ impl EscrowManager {
     /// // get_escrow(...);
     /// ```
     pub fn get_escrow(env: &Env, escrow_id: u64) -> Option<Escrow> {
-        Self::load_escrows(env).get(escrow_id)
+        env.storage().persistent().get(&(ESCROWS, escrow_id))
     }
 
     /// Standard API for get_escrow_count
@@ -520,22 +520,17 @@ impl EscrowManager {
         *arbitrator == env.current_contract_address()
     }
 
-    fn load_escrows(env: &Env) -> Map<u64, Escrow> {
-        env.storage()
-            .instance()
-            .get(&ESCROWS)
-            .unwrap_or_else(|| Map::new(env))
-    }
-
     fn load_escrow(env: &Env, escrow_id: u64) -> Result<Escrow, EscrowError> {
-        let escrows = Self::load_escrows(env);
-        escrows.get(escrow_id).ok_or(EscrowError::EscrowNotFound)
+        env.storage()
+            .persistent()
+            .get(&(ESCROWS, escrow_id))
+            .ok_or(EscrowError::EscrowNotFound)
     }
 
     fn save_escrow(env: &Env, escrow_id: u64, escrow: Escrow) {
-        let mut escrows = Self::load_escrows(env);
-        escrows.set(escrow_id, escrow);
-        env.storage().instance().set(&ESCROWS, &escrows);
+        env.storage()
+            .persistent()
+            .set(&(ESCROWS, escrow_id), &escrow);
     }
 
     fn transfer_from_contract(env: &Env, token: &Address, to: &Address, amount: i128) {

contracts/teachlink/src/rewards.rs

@@ -6,7 +6,7 @@ use crate::storage::{
 use crate::types::{RewardRate, UserReward};
 use crate::validation::RewardsValidator;
 
-use soroban_sdk::{symbol_short, vec, Address, Env, IntoVal, Map, String};
+use soroban_sdk::{symbol_short, vec, Address, Env, IntoVal, String};
 
 pub struct Rewards;
 
@@ -36,12 +36,6 @@ impl Rewards {
         env.storage().instance().set(&REWARD_POOL, &0i128);
         env.storage().instance().set(&TOTAL_REWARDS_ISSUED, &0i128);
 
-        let reward_rates: Map<String, RewardRate> = Map::new(env);
-        env.storage().instance().set(&REWARD_RATES, &reward_rates);
-
-        let user_rewards: Map<Address, UserReward> = Map::new(env);
-        env.storage().instance().set(&USER_REWARDS, &user_rewards);
-
         Ok(())
     }
 
@@ -124,25 +118,24 @@ impl Rewards {
             return Err(RewardsError::InsufficientRewardPoolBalance);
         }
 
-        let mut user_rewards: Map<Address, UserReward> = env
+        let mut user_reward: UserReward = env
             .storage()
-            .instance()
-            .get(&USER_REWARDS)
-            .unwrap_or_else(|| Map::new(env));
-
-        let mut user_reward = user_rewards.get(recipient.clone()).unwrap_or(UserReward {
-            user: recipient.clone(),
-            total_earned: 0,
-            claimed: 0,
-            pending: 0,
-            last_claim_timestamp: 0,
-        });
+            .persistent()
+            .get(&(USER_REWARDS, recipient.clone()))
+            .unwrap_or(UserReward {
+                user: recipient.clone(),
+                total_earned: 0,
+                claimed: 0,
+                pending: 0,
+                last_claim_timestamp: 0,
+            });
 
         user_reward.total_earned += amount;
         user_reward.pending += amount;
 
-        user_rewards.set(recipient.clone(), user_reward);
-        env.storage().instance().set(&USER_REWARDS, &user_rewards);
+        env.storage()
+            .persistent()
+            .set(&(USER_REWARDS, recipient.clone()), &user_reward);
 
         let mut total_issued: i128 = env
             .storage()
@@ -188,14 +181,10 @@ impl Rewards {
     pub fn claim_rewards(env: &Env, user: Address) -> Result<(), RewardsError> {
         user.require_auth();
 
-        let mut user_rewards: Map<Address, UserReward> = env
+        let mut user_reward: UserReward = env
             .storage()
-            .instance()
-            .get(&USER_REWARDS)
-            .unwrap_or_else(|| Map::new(env));
-
-        let mut user_reward = user_rewards
-            .get(user.clone())
+            .persistent()
+            .get(&(USER_REWARDS, user.clone()))
             .ok_or(RewardsError::NoRewardsAvailable)?;
 
         if user_reward.pending <= 0 {
@@ -226,8 +215,9 @@ impl Rewards {
         user_reward.pending = 0;
         user_reward.last_claim_timestamp = env.ledger().timestamp();
 
-        user_rewards.set(user.clone(), user_reward);
-        env.storage().instance().set(&USER_REWARDS, &user_rewards);
+        env.storage()
+            .persistent()
+            .set(&(USER_REWARDS, user.clone()), &user_reward);
 
         let new_pool_balance = pool_balance - amount_to_claim;
         env.storage()
@@ -272,23 +262,15 @@ impl Rewards {
             return Err(RewardsError::RateCannotBeNegative);
         }
 
-        let mut reward_rates: Map<String, RewardRate> = env
-            .storage()
-            .instance()
-            .get(&REWARD_RATES)
-            .unwrap_or_else(|| Map::new(env));
-
-        reward_rates.set(
-            reward_type.clone(),
-            RewardRate {
+        env.storage().persistent().set(
+            &(REWARD_RATES, reward_type.clone()),
+            &RewardRate {
                 reward_type,
                 rate,
                 enabled,
             },
         );
 
-        env.storage().instance().set(&REWARD_RATES, &reward_rates);
-
         Ok(())
     }
 
@@ -332,12 +314,7 @@ impl Rewards {
     /// // get_user_rewards(...);
     /// ```
     pub fn get_user_rewards(env: &Env, user: Address) -> Option<UserReward> {
-        let user_rewards: Map<Address, UserReward> = env
-            .storage()
-            .instance()
-            .get(&USER_REWARDS)
-            .unwrap_or_else(|| Map::new(env));
-        user_rewards.get(user)
+        env.storage().persistent().get(&(USER_REWARDS, user))
     }
 
     /// Standard API for get_reward_pool_balance
@@ -400,12 +377,9 @@ impl Rewards {
     /// // get_reward_rate(...);
     /// ```
     pub fn get_reward_rate(env: &Env, reward_type: String) -> Option<RewardRate> {
-        let reward_rates: Map<String, RewardRate> = env
-            .storage()
-            .instance()
-            .get(&REWARD_RATES)
-            .unwrap_or_else(|| Map::new(env));
-        reward_rates.get(reward_type)
+        env.storage()
+            .persistent()
+            .get(&(REWARD_RATES, reward_type))
     }
 
     /// Standard API for get_rewards_admin