cleanup sc

farm-staking/farm-staking-nft/Cargo.toml

@@ -53,9 +53,6 @@ path = "../../common/modules/pausable"
 [dependencies.permissions_module]
 path = "../../common/modules/permissions_module"
 
-[dependencies.sc_whitelist_module]
-path = "../../common/modules/sc_whitelist_module"
-
 [dependencies.banned_addresses]
 path = "../../common/modules/banned_addresses"
 

farm-staking/farm-staking-nft/src/base_impl_wrapper.rs

@@ -9,7 +9,7 @@ use multiversx_sc_modules::transfer_role_proxy::PaymentsVec;
 
 use crate::token_attributes::StakingFarmTokenAttributes;
 
-pub trait FarmStakingTraits =
+pub trait FarmStakingNftTraits =
     crate::custom_rewards::CustomRewardsModule
         + rewards::RewardsModule
         + config::ConfigModule
@@ -19,16 +19,16 @@ pub trait FarmStakingTraits =
         + multiversx_sc_modules::default_issue_callbacks::DefaultIssueCallbacksModule
         + farm_boosted_yields::FarmBoostedYieldsModule;
 
-pub struct FarmStakingWrapper<T>
+pub struct FarmStakingNftWrapper<T>
 where
     T:,
 {
     _phantom: PhantomData<T>,
 }
 
-impl<T> FarmStakingWrapper<T>
+impl<T> FarmStakingNftWrapper<T>
 where
-    T: FarmStakingTraits,
+    T: FarmStakingNftTraits,
 {
     pub fn calculate_base_farm_rewards(
         farm_token_amount: &BigUint<<<Self as FarmContract>::FarmSc as ContractBase>::Api>,
@@ -50,19 +50,17 @@ where
     ) -> BigUint<<<Self as FarmContract>::FarmSc as ContractBase>::Api> {
         let user_total_farm_position = sc.get_user_total_farm_position(caller);
         let user_farm_position = user_total_farm_position.total_farm_position;
-        let mut boosted_rewards = BigUint::zero();
-
-        if user_farm_position > 0 {
-            boosted_rewards = sc.claim_boosted_yields_rewards(caller, user_farm_position);
+        if user_farm_position == 0 {
+            return BigUint::zero();
         }
 
-        boosted_rewards
+        sc.claim_boosted_yields_rewards(caller, user_farm_position)
     }
 }
 
-impl<T> FarmContract for FarmStakingWrapper<T>
+impl<T> FarmContract for FarmStakingNftWrapper<T>
 where
-    T: FarmStakingTraits,
+    T: FarmStakingNftTraits,
 {
     type FarmSc = T;
     type AttributesType = StakingFarmTokenAttributes<<Self::FarmSc as ContractBase>::Api>;
@@ -192,10 +190,6 @@ where
     ) {
         let farm_token_mapper = sc.farm_token();
         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);
 
             let token_attributes: StakingFarmTokenAttributes<<Self::FarmSc as ContractBase>::Api> =
@@ -208,7 +202,6 @@ where
         }
     }
 
-    #[inline]
     fn increase_user_farm_position(
         sc: &Self::FarmSc,
         user: &ManagedAddress<<Self::FarmSc as ContractBase>::Api>,
@@ -224,10 +217,6 @@ where
         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: StakingFarmTokenAttributes<<Self::FarmSc as ContractBase>::Api> =
             farm_token_mapper.get_token_attributes(farm_position.token_nonce);

farm-staking/farm-staking-nft/src/custom_rewards.rs

@@ -5,7 +5,7 @@ use common_structs::Epoch;
 use contexts::storage_cache::StorageCache;
 use farm_base_impl::base_traits_impl::FarmContract;
 
-use crate::base_impl_wrapper::FarmStakingWrapper;
+use crate::base_impl_wrapper::FarmStakingNftWrapper;
 
 pub const MAX_PERCENT: u64 = 10_000;
 pub const BLOCKS_IN_YEAR: u64 = 31_536_000 / 6; // seconds_in_year / 6_seconds_per_block
@@ -67,7 +67,7 @@ pub trait CustomRewardsModule:
         self.require_caller_has_admin_permissions();
 
         let mut storage_cache = StorageCache::new(self);
-        FarmStakingWrapper::<Self>::generate_aggregated_rewards(self, &mut storage_cache);
+        FarmStakingNftWrapper::<Self>::generate_aggregated_rewards(self, &mut storage_cache);
         self.produce_rewards_enabled().set(false);
     }
 
@@ -77,7 +77,7 @@ pub trait CustomRewardsModule:
         require!(per_block_amount != 0, "Amount cannot be zero");
 
         let mut storage_cache = StorageCache::new(self);
-        FarmStakingWrapper::<Self>::generate_aggregated_rewards(self, &mut storage_cache);
+        FarmStakingNftWrapper::<Self>::generate_aggregated_rewards(self, &mut storage_cache);
         self.per_block_reward_amount().set(&per_block_amount);
     }
 
@@ -87,7 +87,7 @@ pub trait CustomRewardsModule:
         require!(max_apr != 0, "Max APR cannot be zero");
 
         let mut storage_cache = StorageCache::new(self);
-        FarmStakingWrapper::<Self>::generate_aggregated_rewards(self, &mut storage_cache);
+        FarmStakingNftWrapper::<Self>::generate_aggregated_rewards(self, &mut storage_cache);
         self.max_annual_percentage_rewards().set(&max_apr);
     }
 

farm-staking/farm-staking-nft/src/farm_actions/claim_only_boosted_staking_rewards.rs

@@ -1,4 +1,4 @@
-use crate::base_impl_wrapper::FarmStakingWrapper;
+use crate::base_impl_wrapper::FarmStakingNftWrapper;
 
 multiversx_sc::imports!();
 
@@ -49,42 +49,9 @@ pub trait ClaimOnlyBoostedStakingRewardsModule:
         boosted_rewards_payment
     }
 
-    fn migrate_old_farm_positions(&self, caller: &ManagedAddress) -> BigUint {
-        let payments = self.call_value().all_esdt_transfers().clone_value();
-        let farm_token_mapper = self.farm_token();
-        let farm_token_id = farm_token_mapper.get_token_id();
-        let mut migrated_amount = BigUint::zero();
-        for farm_position in &payments {
-            if farm_position.token_identifier == farm_token_id
-                && self.is_old_farm_position(farm_position.token_nonce)
-            {
-                migrated_amount += farm_position.amount;
-            }
-        }
-
-        if migrated_amount > 0 {
-            let mut user_total_farm_position = self.get_user_total_farm_position(caller);
-            user_total_farm_position.total_farm_position += &migrated_amount;
-            self.user_total_farm_position(caller)
-                .set(user_total_farm_position);
-        }
-
-        migrated_amount
-    }
-
-    fn decrease_old_farm_positions(&self, migrated_amount: BigUint, caller: &ManagedAddress) {
-        if migrated_amount == BigUint::zero() {
-            return;
-        }
-        self.user_total_farm_position(caller)
-            .update(|user_total_farm_position| {
-                user_total_farm_position.total_farm_position -= migrated_amount;
-            });
-    }
-
     // Cannot import the one from farm, as the Wrapper struct has different dependencies
     fn claim_only_boosted_payment(&self, caller: &ManagedAddress) -> BigUint {
-        let reward = FarmStakingWrapper::<Self>::calculate_boosted_rewards(self, caller);
+        let reward = FarmStakingNftWrapper::<Self>::calculate_boosted_rewards(self, caller);
         if reward > 0 {
             self.reward_reserve().update(|reserve| *reserve -= &reward);
         }

farm-staking/farm-staking-nft/src/farm_actions/claim_stake_farm_rewards.rs

@@ -2,7 +2,7 @@ multiversx_sc::imports!();
 
 use farm::base_functions::ClaimRewardsResultType;
 
-use crate::{base_impl_wrapper::FarmStakingWrapper, farm_hooks::hook_type::FarmHookType};
+use crate::{base_impl_wrapper::FarmStakingNftWrapper, farm_hooks::hook_type::FarmHookType};
 
 #[multiversx_sc::module]
 pub trait ClaimStakeFarmRewardsModule:
@@ -13,7 +13,6 @@ pub trait ClaimStakeFarmRewardsModule:
     + events::EventsModule
     + token_send::TokenSendModule
     + farm_token::FarmTokenModule
-    + sc_whitelist_module::SCWhitelistModule
     + pausable::PausableModule
     + permissions_module::PermissionsModule
     + multiversx_sc_modules::default_issue_callbacks::DefaultIssueCallbacksModule
@@ -36,63 +35,26 @@ pub trait ClaimStakeFarmRewardsModule:
 {
     #[payable("*")]
     #[endpoint(claimRewards)]
-    fn claim_rewards(
-        &self,
-        opt_original_caller: OptionalValue<ManagedAddress>,
-    ) -> ClaimRewardsResultType<Self::Api> {
+    fn claim_rewards(&self) -> ClaimRewardsResultType<Self::Api> {
         let caller = self.blockchain().get_caller();
-        let original_caller = self.get_orig_caller_from_opt(&caller, opt_original_caller);
-
-        self.claim_rewards_common(original_caller, None)
-    }
-
-    #[payable("*")]
-    #[endpoint(claimRewardsWithNewValue)]
-    fn claim_rewards_with_new_value(
-        &self,
-        new_farming_amount: BigUint,
-        original_caller: ManagedAddress,
-    ) -> ClaimRewardsResultType<Self::Api> {
-        let caller = self.blockchain().get_caller();
-        self.require_sc_address_whitelisted(&caller);
-
-        self.claim_rewards_common(original_caller, Some(new_farming_amount))
-    }
-
-    fn claim_rewards_common(
-        &self,
-        original_caller: ManagedAddress,
-        opt_new_farming_amount: Option<BigUint>,
-    ) -> ClaimRewardsResultType<Self::Api> {
-        self.migrate_old_farm_positions(&original_caller);
-
         let payment = self.call_value().single_esdt();
         let payments_after_hook = self.call_hook(
             FarmHookType::BeforeClaimRewards,
-            original_caller.clone(),
+            caller.clone(),
             ManagedVec::from_single_item(payment),
             ManagedVec::new(),
         );
         let payment = payments_after_hook.get(0);
 
         let mut claim_result = self
-            .claim_rewards_base_no_farm_token_mint::<FarmStakingWrapper<Self>>(
-                original_caller.clone(),
+            .claim_rewards_base_no_farm_token_mint::<FarmStakingNftWrapper<Self>>(
+                caller.clone(),
                 ManagedVec::from_single_item(payment),
             );
 
         let mut virtual_farm_token = claim_result.new_farm_token.clone();
-        if let Some(new_amount) = opt_new_farming_amount {
-            claim_result.storage_cache.farm_token_supply -= &virtual_farm_token.payment.amount;
-            claim_result.storage_cache.farm_token_supply += &new_amount;
 
-            virtual_farm_token.payment.amount = new_amount.clone();
-            virtual_farm_token.attributes.current_farm_amount = new_amount;
-
-            self.set_farm_supply_for_current_week(&claim_result.storage_cache.farm_token_supply);
-        }
-
-        self.update_energy_and_progress(&original_caller);
+        self.update_energy_and_progress(&caller);
 
         let new_farm_token_nonce = self.send().esdt_nft_create_compact(
             &virtual_farm_token.payment.token_identifier,
@@ -107,15 +69,14 @@ pub trait ClaimStakeFarmRewardsModule:
 
         let mut output_payments_after_hook = self.call_hook(
             FarmHookType::AfterClaimRewards,
-            original_caller,
+            caller.clone(),
             output_payments,
             ManagedVec::new(),
         );
         virtual_farm_token.payment = self.pop_first_payment(&mut output_payments_after_hook);
         claim_result.rewards =
             self.pop_or_return_payment(&mut output_payments_after_hook, claim_result.rewards);
 
-        let caller = self.blockchain().get_caller();
         self.send_payment_non_zero(&caller, &virtual_farm_token.payment);
         self.send_payment_non_zero(&caller, &claim_result.rewards);
 

farm-staking/farm-staking-nft/src/farm_actions/compound_stake_farm_rewards.rs

@@ -1,4 +1,4 @@
-use crate::{base_impl_wrapper::FarmStakingWrapper, farm_hooks::hook_type::FarmHookType};
+use crate::{base_impl_wrapper::FarmStakingNftWrapper, farm_hooks::hook_type::FarmHookType};
 
 multiversx_sc::imports!();
 
@@ -11,7 +11,6 @@ pub trait CompoundStakeFarmRewardsModule:
     + events::EventsModule
     + token_send::TokenSendModule
     + farm_token::FarmTokenModule
-    + sc_whitelist_module::SCWhitelistModule
     + pausable::PausableModule
     + permissions_module::PermissionsModule
     + multiversx_sc_modules::default_issue_callbacks::DefaultIssueCallbacksModule
@@ -36,8 +35,6 @@ pub trait CompoundStakeFarmRewardsModule:
     #[endpoint(compoundRewards)]
     fn compound_rewards(&self) -> EsdtTokenPayment {
         let caller = self.blockchain().get_caller();
-        self.migrate_old_farm_positions(&caller);
-
         let payments = self.get_non_empty_payments();
         let payments_after_hook = self.call_hook(
             FarmHookType::BeforeCompoundRewards,
@@ -46,8 +43,10 @@ pub trait CompoundStakeFarmRewardsModule:
             ManagedVec::new(),
         );
 
-        let mut compound_result = self
-            .compound_rewards_base::<FarmStakingWrapper<Self>>(caller.clone(), payments_after_hook);
+        let mut compound_result = self.compound_rewards_base::<FarmStakingNftWrapper<Self>>(
+            caller.clone(),
+            payments_after_hook,
+        );
 
         let new_farm_token = compound_result.new_farm_token.payment.clone();
         let mut args = ManagedVec::new();