farm position first audit fixes

common/modules/farm/config/src/config.rs

@@ -19,11 +19,20 @@ pub const DEFAULT_NFT_DEPOSIT_MAX_LEN: usize = 10;
     PartialEq,
     Debug,
 )]
-pub struct UserTotalFarmPositionStruct<M: ManagedTypeApi> {
+pub struct UserTotalFarmPosition<M: ManagedTypeApi> {
     pub total_farm_position: BigUint<M>,
     pub allow_external_claim_boosted_rewards: bool,
 }
 
+impl<M: ManagedTypeApi> Default for UserTotalFarmPosition<M> {
+    fn default() -> Self {
+        Self {
+            total_farm_position: BigUint::zero(),
+            allow_external_claim_boosted_rewards: false,
+        }
+    }
+}
+
 #[multiversx_sc::module]
 pub trait ConfigModule: pausable::PausableModule + permissions_module::PermissionsModule {
     #[inline]
@@ -32,17 +41,34 @@ pub trait ConfigModule: pausable::PausableModule + permissions_module::Permissio
         state == State::Active
     }
 
-    fn get_user_total_farm_position_struct(
+    fn get_user_total_farm_position(
         &self,
         user: &ManagedAddress,
-    ) -> UserTotalFarmPositionStruct<Self::Api> {
-        self.user_total_farm_position(user)
-            .set_if_empty(UserTotalFarmPositionStruct {
-                total_farm_position: BigUint::zero(),
-                allow_external_claim_boosted_rewards: false,
-            });
-
-        self.user_total_farm_position(user).get()
+    ) -> UserTotalFarmPosition<Self::Api> {
+        let user_total_farm_position_mapper = self.user_total_farm_position(user);
+        if user_total_farm_position_mapper.is_empty() {
+            UserTotalFarmPosition::default()
+        } else {
+            user_total_farm_position_mapper.get()
+        }
+    }
+
+    fn is_old_farm_position(&self, token_nonce: Nonce) -> bool {
+        let farm_position_migration_block_nonce = self.farm_position_migration_block_nonce().get();
+        token_nonce < farm_position_migration_block_nonce
+    }
+
+    #[endpoint(allowExternalClaimBoostedRewards)]
+    fn allow_external_claim_boosted_rewards(&self, allow_external_claim: bool) {
+        let caller = self.blockchain().get_caller();
+        let user_total_farm_position_mapper = self.user_total_farm_position(&caller);
+        require!(
+            !user_total_farm_position_mapper.is_empty(),
+            "User must have a farm position"
+        );
+        user_total_farm_position_mapper.update(|user_total_farm_position| {
+            user_total_farm_position.allow_external_claim_boosted_rewards = allow_external_claim;
+        });
     }
 
     #[view(getFarmingTokenId)]
@@ -73,5 +99,9 @@ pub trait ConfigModule: pausable::PausableModule + permissions_module::Permissio
     fn user_total_farm_position(
         &self,
         user: &ManagedAddress,
-    ) -> SingleValueMapper<UserTotalFarmPositionStruct<Self::Api>>;
+    ) -> SingleValueMapper<UserTotalFarmPosition<Self::Api>>;
+
+    #[view(getFarmPositionMigrationBlockNonce)]
+    #[storage_mapper("farm_position_migration_block_nonce")]
+    fn farm_position_migration_block_nonce(&self) -> SingleValueMapper<Nonce>;
 }

common/modules/farm/farm_base_impl/src/base_traits_impl.rs

@@ -195,27 +195,21 @@ pub trait FarmContract {
         farm_positions: &PaymentsVec<<Self::FarmSc as ContractBase>::Api>,
     ) {
         let farm_token_mapper = sc.farm_token();
-        let mut total_farm_position = BigUint::zero();
-        let mut farm_position_increase = BigUint::zero();
         for farm_position in farm_positions {
+            if sc.is_old_farm_position(farm_position.token_nonce) {
+                continue;
+            }
+
             farm_token_mapper.require_same_token(&farm_position.token_identifier);
 
-            total_farm_position += &farm_position.amount;
             let token_attributes: FarmTokenAttributes<<Self::FarmSc as ContractBase>::Api> =
                 farm_token_mapper.get_token_attributes(farm_position.token_nonce);
 
             if &token_attributes.original_owner != user {
                 Self::decrease_user_farm_position(sc, &farm_position);
-                farm_position_increase += &farm_position.amount;
+                Self::increase_user_farm_position(sc, user, &farm_position.amount);
             }
         }
-
-        let user_total_farm_position_struct = sc.get_user_total_farm_position_struct(user);
-        if user_total_farm_position_struct.total_farm_position == BigUint::zero() {
-            Self::increase_user_farm_position(sc, user, &total_farm_position);
-        } else if farm_position_increase > 0 {
-            Self::increase_user_farm_position(sc, user, &farm_position_increase);
-        }
     }
 
     #[inline]
@@ -224,30 +218,31 @@ pub trait FarmContract {
         user: &ManagedAddress<<Self::FarmSc as ContractBase>::Api>,
         increase_farm_position_amount: &BigUint<<Self::FarmSc as ContractBase>::Api>,
     ) {
+        let mut user_total_farm_position = sc.get_user_total_farm_position(user);
+        user_total_farm_position.total_farm_position += increase_farm_position_amount;
         sc.user_total_farm_position(user)
-            .update(|user_farm_position_struct| {
-                user_farm_position_struct.total_farm_position += increase_farm_position_amount
-            });
+            .set(user_total_farm_position);
     }
 
     fn decrease_user_farm_position(
         sc: &Self::FarmSc,
         farm_position: &EsdtTokenPayment<<Self::FarmSc as ContractBase>::Api>,
     ) {
+        if sc.is_old_farm_position(farm_position.token_nonce) {
+            return;
+        }
+
         let farm_token_mapper = sc.farm_token();
         let token_attributes: FarmTokenAttributes<<Self::FarmSc as ContractBase>::Api> =
             farm_token_mapper.get_token_attributes(farm_position.token_nonce);
 
         sc.user_total_farm_position(&token_attributes.original_owner)
-            .update(|user_farm_position_struct| {
-                let mut user_total_farm_position =
-                    user_farm_position_struct.total_farm_position.clone();
-                if user_total_farm_position > farm_position.amount {
-                    user_total_farm_position -= &farm_position.amount;
+            .update(|user_total_farm_position| {
+                if user_total_farm_position.total_farm_position > farm_position.amount {
+                    user_total_farm_position.total_farm_position -= &farm_position.amount;
                 } else {
-                    user_total_farm_position = BigUint::zero();
+                    user_total_farm_position.total_farm_position = BigUint::zero();
                 }
-                user_farm_position_struct.total_farm_position = user_total_farm_position;
             });
     }
 }

common/modules/farm/farm_base_impl/src/claim_rewards.rs

@@ -63,8 +63,6 @@ pub trait BaseClaimRewardsModule:
             self.blockchain(),
         );
 
-        FC::check_and_update_user_farm_position(self, &caller, &payments);
-
         FC::generate_aggregated_rewards(self, &mut storage_cache);
 
         let farm_token_amount = &claim_rewards_context.first_farm_token.payment.amount;
@@ -83,6 +81,8 @@ pub trait BaseClaimRewardsModule:
         );
         storage_cache.reward_reserve -= &reward;
 
+        FC::check_and_update_user_farm_position(self, &caller, &payments);
+
         let farm_token_mapper = self.farm_token();
         let base_attributes = FC::create_claim_rewards_initial_attributes(
             self,

common/modules/farm/farm_base_impl/src/compound_rewards.rs

@@ -51,7 +51,6 @@ pub trait BaseCompoundRewardsModule:
             self.blockchain(),
         );
 
-        FC::check_and_update_user_farm_position(self, &caller, &payments);
         FC::generate_aggregated_rewards(self, &mut storage_cache);
 
         let farm_token_amount = &compound_rewards_context.first_farm_token.payment.amount;
@@ -71,6 +70,8 @@ pub trait BaseCompoundRewardsModule:
         storage_cache.reward_reserve -= &reward;
         storage_cache.farm_token_supply += &reward;
 
+        FC::check_and_update_user_farm_position(self, &caller, &payments);
+
         let farm_token_mapper = self.farm_token();
         let base_attributes = FC::create_compound_rewards_initial_attributes(
             self,

dex/farm-with-locked-rewards/src/lib.rs

@@ -35,7 +35,6 @@ pub trait Farm:
     + farm::base_functions::BaseFunctionsModule
     + farm::exit_penalty::ExitPenaltyModule
     + farm::progress_update::ProgressUpdateModule
-    + farm::claim_boost_only::ClaimBoostOnlyModule
     + farm_base_impl::base_farm_init::BaseFarmInitModule
     + farm_base_impl::base_farm_validation::BaseFarmValidationModule
     + farm_base_impl::enter_farm::BaseEnterFarmModule
@@ -89,27 +88,25 @@ pub trait Farm:
         let caller = self.blockchain().get_caller();
         let orig_caller = self.get_orig_caller_from_opt(&caller, opt_orig_caller);
 
-        let payments = self.get_non_empty_payments();
-        let first_additional_payment_index = 1;
-        let boosted_rewards = match payments.try_get(first_additional_payment_index) {
-            Some(p) => {
-                let unlocked_rewards = self.claim_only_boosted_payment(&orig_caller, &p);
-                self.send_to_lock_contract_non_zero(
-                    unlocked_rewards.token_identifier,
-                    unlocked_rewards.amount,
-                    caller.clone(),
-                    orig_caller.clone(),
-                )
-            }
-            None => EsdtTokenPayment::new(self.reward_token_id().get(), 0, BigUint::zero()),
+        self.migrate_old_farm_positions(&orig_caller);
+        let boosted_rewards = self.claim_only_boosted_payment(&orig_caller);
+        let boosted_rewards_payment = if boosted_rewards > 0 {
+            self.send_to_lock_contract_non_zero(
+                self.reward_token_id().get(),
+                boosted_rewards,
+                caller.clone(),
+                orig_caller.clone(),
+            )
+        } else {
+            EsdtTokenPayment::new(self.reward_token_id().get(), 0, BigUint::zero())
         };
 
         let new_farm_token = self.enter_farm::<NoMintWrapper<Self>>(orig_caller.clone());
         self.send_payment_non_zero(&caller, &new_farm_token);
 
         self.update_energy_and_progress(&orig_caller);
 
-        (new_farm_token, boosted_rewards).into()
+        (new_farm_token, boosted_rewards_payment).into()
     }
 
     #[payable("*")]
@@ -121,6 +118,8 @@ pub trait Farm:
         let caller = self.blockchain().get_caller();
         let orig_caller = self.get_orig_caller_from_opt(&caller, opt_orig_caller);
 
+        self.migrate_old_farm_positions(&orig_caller);
+
         let payments = self.call_value().all_esdt_transfers().clone_value();
         let base_claim_rewards_result =
             self.claim_rewards_base::<NoMintWrapper<Self>>(orig_caller.clone(), payments);
@@ -163,7 +162,10 @@ pub trait Farm:
             "Exit amount is bigger than the payment amount"
         );
 
-        let boosted_rewards_full_position = self.claim_only_boosted_payment(&orig_caller, &payment);
+        let boosted_rewards = self.claim_only_boosted_payment(&orig_caller);
+        let boosted_rewards_full_position =
+            EsdtTokenPayment::new(self.reward_token_id().get(), 0, boosted_rewards);
+
         let remaining_farm_payment = EsdtTokenPayment::new(
             payment.token_identifier.clone(),
             payment.token_nonce,
@@ -186,7 +188,7 @@ pub trait Farm:
             orig_caller.clone(),
         );
 
-        self.clear_user_energy_if_needed(&orig_caller, &remaining_farm_payment.amount);
+        self.clear_user_energy_if_needed(&orig_caller);
 
         (
             exit_farm_result.farming_tokens,
@@ -196,27 +198,6 @@ pub trait Farm:
             .into()
     }
 
-    #[view(calculateRewardsForGivenPosition)]
-    fn calculate_rewards_for_given_position(
-        &self,
-        user: ManagedAddress,
-        farm_token_amount: BigUint,
-        attributes: FarmTokenAttributes<Self::Api>,
-    ) -> BigUint {
-        self.require_queried();
-
-        let mut storage_cache = StorageCache::new(self);
-        NoMintWrapper::<Self>::generate_aggregated_rewards(self, &mut storage_cache);
-
-        NoMintWrapper::<Self>::calculate_rewards(
-            self,
-            &user,
-            &farm_token_amount,
-            &attributes,
-            &storage_cache,
-        )
-    }
-
     #[payable("*")]
     #[endpoint(mergeFarmTokens)]
     fn merge_farm_tokens_endpoint(
@@ -226,13 +207,41 @@ pub trait Farm:
         let caller = self.blockchain().get_caller();
         let orig_caller = self.get_orig_caller_from_opt(&caller, opt_orig_caller);
         self.check_claim_progress_for_merge(&orig_caller);
+        self.migrate_old_farm_positions(&orig_caller);
 
         let merged_farm_token = self.merge_farm_tokens::<NoMintWrapper<Self>>();
         self.send_payment_non_zero(&caller, &merged_farm_token);
 
         merged_farm_token
     }
 
+    #[endpoint(claimBoostedRewards)]
+    fn claim_boosted_rewards(
+        &self,
+        opt_user: OptionalValue<ManagedAddress>,
+    ) -> EsdtTokenPayment<Self::Api> {
+        let caller = self.blockchain().get_caller();
+        let user = match &opt_user {
+            OptionalValue::Some(user) => user,
+            OptionalValue::None => &caller,
+        };
+        let user_total_farm_position = self.get_user_total_farm_position(user);
+        if user != &caller {
+            require!(
+                user_total_farm_position.allow_external_claim_boosted_rewards,
+                "Cannot claim rewards for this address"
+            );
+        }
+
+        let boosted_rewards = self.claim_only_boosted_payment(user);
+        self.send_to_lock_contract_non_zero(
+            self.reward_token_id().get(),
+            boosted_rewards,
+            caller.clone(),
+            user.clone(),
+        )
+    }
+
     #[endpoint(startProduceRewards)]
     fn start_produce_rewards_endpoint(&self) {
         self.require_caller_has_admin_permissions();
@@ -251,6 +260,27 @@ pub trait Farm:
         self.set_per_block_rewards::<NoMintWrapper<Self>>(per_block_amount);
     }
 
+    #[view(calculateRewardsForGivenPosition)]
+    fn calculate_rewards_for_given_position(
+        &self,
+        user: ManagedAddress,
+        farm_token_amount: BigUint,
+        attributes: FarmTokenAttributes<Self::Api>,
+    ) -> BigUint {
+        self.require_queried();
+
+        let mut storage_cache = StorageCache::new(self);
+        NoMintWrapper::<Self>::generate_aggregated_rewards(self, &mut storage_cache);
+
+        NoMintWrapper::<Self>::calculate_rewards(
+            self,
+            &user,
+            &farm_token_amount,
+            &attributes,
+            &storage_cache,
+        )
+    }
+
     fn send_to_lock_contract_non_zero(
         &self,
         token_id: TokenIdentifier,