farm position functionality

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

@@ -8,6 +8,22 @@ use pausable::State;
 
 pub const DEFAULT_NFT_DEPOSIT_MAX_LEN: usize = 10;
 
+#[derive(
+    ManagedVecItem,
+    TopEncode,
+    TopDecode,
+    NestedEncode,
+    NestedDecode,
+    TypeAbi,
+    Clone,
+    PartialEq,
+    Debug,
+)]
+pub struct UserTotalFarmPositionStruct<M: ManagedTypeApi> {
+    pub total_farm_position: BigUint<M>,
+    pub allow_external_claim_boosted_rewards: bool,
+}
+
 #[multiversx_sc::module]
 pub trait ConfigModule: pausable::PausableModule + permissions_module::PermissionsModule {
     #[inline]
@@ -16,6 +32,24 @@ pub trait ConfigModule: pausable::PausableModule + permissions_module::Permissio
         state == State::Active
     }
 
+    fn get_user_total_farm_position(&self, user: &ManagedAddress) -> BigUint {
+        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()
+            .total_farm_position
+    }
+
+    fn get_allow_external_claim_boosted_rewards(&self, user: &ManagedAddress) -> bool {
+        self.user_total_farm_position(user)
+            .get()
+            .allow_external_claim_boosted_rewards
+    }
+
     #[view(getFarmingTokenId)]
     #[storage_mapper("farming_token_id")]
     fn farming_token_id(&self) -> SingleValueMapper<TokenIdentifier>;
@@ -38,4 +72,11 @@ pub trait ConfigModule: pausable::PausableModule + permissions_module::Permissio
     #[view(getDivisionSafetyConstant)]
     #[storage_mapper("division_safety_constant")]
     fn division_safety_constant(&self) -> SingleValueMapper<BigUint>;
+
+    #[view(getUserTotalFarmPosition)]
+    #[storage_mapper("userTotalFarmPosition")]
+    fn user_total_farm_position(
+        &self,
+        user: &ManagedAddress,
+    ) -> SingleValueMapper<UserTotalFarmPositionStruct<Self::Api>>;
 }

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

@@ -6,6 +6,7 @@ use contexts::storage_cache::StorageCache;
 use core::marker::PhantomData;
 use fixed_supply_token::FixedSupplyToken;
 use mergeable::Mergeable;
+use multiversx_sc_modules::transfer_role_proxy::PaymentsVec;
 use rewards::RewardsModule;
 
 pub trait AllBaseFarmImplTraits =
@@ -187,6 +188,67 @@ pub trait FarmContract {
         _storage_cache: &StorageCache<Self::FarmSc>,
     ) {
     }
+
+    fn check_and_update_user_farm_position(
+        sc: &Self::FarmSc,
+        user: &ManagedAddress<<Self::FarmSc as ContractBase>::Api>,
+        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 {
+            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;
+            }
+        }
+
+        let user_total_farm_position = sc.get_user_total_farm_position(user);
+        if user_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]
+    fn increase_user_farm_position(
+        sc: &Self::FarmSc,
+        user: &ManagedAddress<<Self::FarmSc as ContractBase>::Api>,
+        new_farm_position_amount: &BigUint<<Self::FarmSc as ContractBase>::Api>,
+    ) {
+        sc.user_total_farm_position(user)
+            .update(|user_farm_position_struct| {
+                user_farm_position_struct.total_farm_position += new_farm_position_amount
+            });
+    }
+
+    fn decrease_user_farm_position(
+        sc: &Self::FarmSc,
+        farm_position: &EsdtTokenPayment<<Self::FarmSc as ContractBase>::Api>,
+    ) {
+        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;
+                } else {
+                    user_total_farm_position = BigUint::zero();
+                }
+                user_farm_position_struct.total_farm_position = user_total_farm_position;
+            });
+    }
 }
 
 pub struct DefaultFarmWrapper<T>

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

@@ -58,11 +58,13 @@ pub trait BaseClaimRewardsModule:
         self.validate_contract_state(storage_cache.contract_state, &storage_cache.farm_token_id);
 
         let claim_rewards_context = ClaimRewardsContext::<Self::Api, FC::AttributesType>::new(
-            payments,
+            payments.clone(),
             &storage_cache.farm_token_id,
             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;

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

@@ -46,11 +46,13 @@ pub trait BaseCompoundRewardsModule:
         );
 
         let compound_rewards_context = CompoundRewardsContext::<Self::Api, FC::AttributesType>::new(
-            payments,
+            payments.clone(),
             &storage_cache.farm_token_id,
             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;

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

@@ -44,6 +44,18 @@ pub trait BaseEnterFarmModule:
             &storage_cache.farm_token_id,
         );
 
+        // The order is important - first check and update, then increase position
+        FC::check_and_update_user_farm_position(
+            self,
+            &caller,
+            &enter_farm_context.additional_farm_tokens,
+        );
+        FC::increase_user_farm_position(
+            self,
+            &caller,
+            &enter_farm_context.farming_token_payment.amount,
+        );
+
         FC::generate_aggregated_rewards(self, &mut storage_cache);
 
         storage_cache.farm_token_supply += &enter_farm_context.farming_token_payment.amount;

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

@@ -39,11 +39,13 @@ pub trait BaseExitFarmModule:
         self.validate_contract_state(storage_cache.contract_state, &storage_cache.farm_token_id);
 
         let exit_farm_context = ExitFarmContext::<Self::Api, FC::AttributesType>::new(
-            payment,
+            payment.clone(),
             &storage_cache.farm_token_id,
             self.blockchain(),
         );
 
+        FC::decrease_user_farm_position(self, &payment);
+
         FC::generate_aggregated_rewards(self, &mut storage_cache);
 
         let farm_token_amount = &exit_farm_context.farm_token.payment.amount;

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

@@ -5,9 +5,9 @@
 ////////////////////////////////////////////////////
 
 // Init:                                 1
-// Endpoints:                           62
+// Endpoints:                           64
 // Async Callback:                       1
-// Total number of exported functions:  64
+// Total number of exported functions:  66
 
 #![no_std]
 #![feature(alloc_error_handler, lang_items)]
@@ -33,6 +33,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         getPerBlockRewardAmount
         getLastRewardBlockNonce
         getDivisionSafetyConstant
+        getUserTotalFarmPosition
         setLockingScAddress
         setLockEpochs
         getLockingScAddress
@@ -59,6 +60,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         getMinimumFarmingEpoch
         getBurnGasLimit
         getPairContractManagedAddress
+        claimBoostedRewards
         setBoostedYieldsRewardsPercentage
         collectUndistributedBoostedRewards
         getBoostedYieldsRewardsPercentage

dex/farm/src/base_functions.rs

@@ -186,6 +186,9 @@ pub trait BaseFunctionsModule:
         let token_mapper = self.farm_token();
         token_mapper.require_all_same_token(&payments);
 
+        let caller = self.blockchain().get_caller();
+        FC::check_and_update_user_farm_position(self, &caller, &payments);
+
         let output_attributes: FC::AttributesType =
             self.merge_from_payments_and_burn(payments, &token_mapper);
         let new_token_amount = output_attributes.get_total_supply();
@@ -236,15 +239,19 @@ where
         sc: &<Self as FarmContract>::FarmSc,
         caller: &ManagedAddress<<<Self as FarmContract>::FarmSc as ContractBase>::Api>,
         token_attributes: &<Self as FarmContract>::AttributesType,
-        farm_token_amount: BigUint<<<Self as FarmContract>::FarmSc as ContractBase>::Api>,
     ) -> BigUint<<<Self as FarmContract>::FarmSc as ContractBase>::Api> {
-        if &token_attributes.original_owner != caller {
+        let original_owner = &token_attributes.original_owner;
+
+        if original_owner != caller {
             sc.update_energy_and_progress(caller);
+        }
 
+        let user_total_farm_position = sc.get_user_total_farm_position(original_owner);
+        if user_total_farm_position == BigUint::zero() {
             return BigUint::zero();
         }
 
-        sc.claim_boosted_yields_rewards(caller, farm_token_amount)
+        sc.claim_boosted_yields_rewards(caller, user_total_farm_position)
     }
 }
 
@@ -288,12 +295,7 @@ where
             token_attributes,
             storage_cache,
         );
-        let boosted_yield_rewards = Self::calculate_boosted_rewards(
-            sc,
-            caller,
-            token_attributes,
-            farm_token_amount.clone(),
-        );
+        let boosted_yield_rewards = Self::calculate_boosted_rewards(sc, caller, token_attributes);
 
         base_farm_reward + boosted_yield_rewards
     }

dex/farm/src/claim_boost_only.rs

@@ -31,6 +31,43 @@ pub trait ClaimBoostOnlyModule:
     + farm_boosted_yields::boosted_yields_factors::BoostedYieldsFactorsModule
     + crate::base_functions::BaseFunctionsModule
 {
+    #[payable("*")]
+    #[endpoint(claimBoostedRewards)]
+    fn claim_boosted_rewards(
+        &self,
+        opt_user: OptionalValue<ManagedAddress>,
+    ) -> EsdtTokenPayment<Self::Api> {
+        let user = match opt_user {
+            OptionalValue::Some(user) => {
+                require!(
+                    self.get_allow_external_claim_boosted_rewards(&user),
+                    "Cannot claim rewards for this address"
+                );
+                user
+            }
+            OptionalValue::None => self.blockchain().get_caller(),
+        };
+
+        let reward_token_id = self.reward_token_id().get();
+
+        let user_total_farm_position = self.get_user_total_farm_position(&user);
+        if user_total_farm_position == BigUint::zero() {
+            return EsdtTokenPayment::new(reward_token_id, 0, BigUint::zero());
+        }
+
+        let reward = self.claim_boosted_yields_rewards(&user, user_total_farm_position);
+        if reward > 0 {
+            self.reward_reserve().update(|reserve| *reserve -= &reward);
+        }
+
+        let boosted_rewards = EsdtTokenPayment::new(reward_token_id, 0, reward);
+        self.send_payment_non_zero(&user, &boosted_rewards);
+
+        self.update_energy_and_progress(&user);
+
+        boosted_rewards
+    }
+
     fn claim_only_boosted_payment(
         &self,
         caller: &ManagedAddress,
@@ -41,12 +78,7 @@ pub trait ClaimBoostOnlyModule:
 
         let token_attributes =
             self.get_attributes_as_part_of_fixed_supply(payment, &farm_token_mapper);
-        let reward = Wrapper::<Self>::calculate_boosted_rewards(
-            self,
-            caller,
-            &token_attributes,
-            payment.amount.clone(),
-        );
+        let reward = Wrapper::<Self>::calculate_boosted_rewards(self, caller, &token_attributes);
         if reward > 0 {
             self.reward_reserve().update(|reserve| *reserve -= &reward);
         }

dex/farm/src/lib.rs

@@ -118,10 +118,13 @@ pub trait Farm:
         let caller = self.blockchain().get_caller();
         let orig_caller = self.get_orig_caller_from_opt(&caller, opt_orig_caller);
 
-        let claim_rewards_result = self.claim_rewards::<Wrapper<Self>>(orig_caller);
+        let claim_rewards_result = self.claim_rewards::<Wrapper<Self>>(orig_caller.clone());
+
         self.send_payment_non_zero(&caller, &claim_rewards_result.new_farm_token);
         self.send_payment_non_zero(&caller, &claim_rewards_result.rewards);
 
+        self.update_energy_and_progress(&orig_caller);
+
         claim_rewards_result.into()
     }
 
@@ -134,9 +137,12 @@ pub trait Farm:
         let caller = self.blockchain().get_caller();
         let orig_caller = self.get_orig_caller_from_opt(&caller, opt_orig_caller);
 
-        let output_farm_token_payment = self.compound_rewards::<Wrapper<Self>>(orig_caller);
+        let output_farm_token_payment = self.compound_rewards::<Wrapper<Self>>(orig_caller.clone());
+
         self.send_payment_non_zero(&caller, &output_farm_token_payment);
 
+        self.update_energy_and_progress(&orig_caller);
+
         output_farm_token_payment
     }
 

dex/farm/wasm/src/lib.rs

@@ -5,9 +5,9 @@
 ////////////////////////////////////////////////////
 
 // Init:                                 1
-// Endpoints:                           59
+// Endpoints:                           61
 // Async Callback:                       1
-// Total number of exported functions:  61
+// Total number of exported functions:  63
 
 #![no_std]
 #![feature(alloc_error_handler, lang_items)]
@@ -34,6 +34,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         getPerBlockRewardAmount
         getLastRewardBlockNonce
         getDivisionSafetyConstant
+        getUserTotalFarmPosition
         registerFarmToken
         getFarmTokenId
         getFarmTokenSupply
@@ -56,6 +57,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         getMinimumFarmingEpoch
         getBurnGasLimit
         getPairContractManagedAddress
+        claimBoostedRewards
         setBoostedYieldsRewardsPercentage
         collectUndistributedBoostedRewards
         getBoostedYieldsRewardsPercentage