Feat/v3.1

Cargo.toml

@@ -42,6 +42,8 @@ members = [
   "locked-asset/distribution/meta",
   "locked-asset/proxy_dex",
   "locked-asset/proxy_dex/meta",
+  "locked-asset/proxy-dex-xmex",
+  "locked-asset/proxy-dex-xmex/meta",
   "locked-asset/lkmex-transfer",
   "locked-asset/lkmex-transfer/meta",
   "locked-asset/locked-token-wrapper",

common/common_errors/Cargo.toml

@@ -8,5 +8,5 @@ edition = "2021"
 path = "src/lib.rs"
 
 [dependencies.multiversx-sc]
-version = "=0.46.1"
+version = "=0.48.1"
 features = ["esdt-token-payment-legacy-decode"]

common/common_structs/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 path = "src/lib.rs"
 
 [dependencies.multiversx-sc]
-version = "=0.46.1"
+version = "=0.48.1"
 features = ["esdt-token-payment-legacy-decode"]
 
 [dependencies.mergeable]

common/common_structs/src/wrapper_types.rs

@@ -5,6 +5,8 @@ use core::ops::Deref;
 
 use unwrappable::Unwrappable;
 
+use crate::{Epoch, Nonce};
+
 static NOT_ENOUGH_RESULTS_ERR_MSG: &[u8] = b"Not enough results";
 const FIRST_VEC_INDEX: usize = 0;
 
@@ -22,13 +24,13 @@ impl<M: ManagedTypeApi> TokenPair<M> {
 
 #[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, TypeAbi)]
 pub struct NonceAmountPair<M: ManagedTypeApi> {
-    pub nonce: u64,
+    pub nonce: Nonce,
     pub amount: BigUint<M>,
 }
 
 impl<M: ManagedTypeApi> NonceAmountPair<M> {
     #[inline]
-    pub fn new(nonce: u64, amount: BigUint<M>) -> Self {
+    pub fn new(nonce: Nonce, amount: BigUint<M>) -> Self {
         NonceAmountPair { nonce, amount }
     }
 }
@@ -37,7 +39,7 @@ impl<M: ManagedTypeApi> NonceAmountPair<M> {
     TypeAbi, TopEncode, TopDecode, NestedEncode, NestedDecode, ManagedVecItem, Clone, Debug,
 )]
 pub struct EpochAmountPair<M: ManagedTypeApi> {
-    pub epoch: u64,
+    pub epoch: Epoch,
     pub amount: BigUint<M>,
 }
 

common/modules/farm/config/Cargo.toml

@@ -23,5 +23,5 @@ path = "../../pausable"
 path = "../../permissions_module"
 
 [dependencies.multiversx-sc]
-version = "=0.46.1"
+version = "=0.48.1"
 features = ["esdt-token-payment-legacy-decode"]

common/modules/farm/contexts/Cargo.toml

@@ -35,8 +35,8 @@ path = "../../pausable"
 path = "../../permissions_module"
 
 [dependencies.multiversx-sc]
-version = "=0.46.1"
+version = "=0.48.1"
 features = ["esdt-token-payment-legacy-decode"]
 
 [dependencies.multiversx-sc-modules]
-version = "=0.46.1"
+version = "=0.48.1"

common/modules/farm/events/Cargo.toml

@@ -14,5 +14,5 @@ path = "../../../common_structs"
 path = "../contexts"
 
 [dependencies.multiversx-sc]
-version = "=0.46.1"
+version = "=0.48.1"
 features = ["esdt-token-payment-legacy-decode"]

common/modules/farm/farm_base_impl/Cargo.toml

@@ -50,11 +50,11 @@ path = "../../../traits/mergeable"
 path = "../../../traits/fixed-supply-token"
 
 [dependencies.multiversx-sc]
-version = "=0.46.1"
+version = "=0.48.1"
 features = ["esdt-token-payment-legacy-decode"]
 
 [dependencies.multiversx-sc-modules]
-version = "=0.46.1"
+version = "=0.48.1"
 
 [dev-dependencies.multiversx-sc-scenario]
-version = "=0.46.1"
+version = "=0.48.1"

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

@@ -32,10 +32,10 @@ pub trait BaseFarmInitModule:
 
         self.state().set(State::Inactive);
         self.division_safety_constant()
-            .set_if_empty(&division_safety_constant);
+            .set(&division_safety_constant);
 
-        self.reward_token_id().set_if_empty(&reward_token_id);
-        self.farming_token_id().set_if_empty(&farming_token_id);
+        self.reward_token_id().set(&reward_token_id);
+        self.farming_token_id().set(&farming_token_id);
 
         if !owner.is_zero() {
             self.add_permissions(owner, Permissions::OWNER | Permissions::PAUSE);

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

@@ -9,6 +9,28 @@ use mergeable::Mergeable;
 use multiversx_sc_modules::transfer_role_proxy::PaymentsVec;
 use rewards::RewardsModule;
 
+pub struct RewardPair<M: ManagedTypeApi> {
+    pub base: BigUint<M>,
+    pub boosted: BigUint<M>,
+}
+
+impl<M: ManagedTypeApi> RewardPair<M> {
+    #[inline]
+    pub fn new(base: BigUint<M>, boosted: BigUint<M>) -> Self {
+        Self { base, boosted }
+    }
+
+    #[inline]
+    pub fn new_zero() -> Self {
+        Self::new(BigUint::zero(), BigUint::zero())
+    }
+
+    #[inline]
+    pub fn total_rewards(&self) -> BigUint<M> {
+        &self.base + &self.boosted
+    }
+}
+
 pub trait AllBaseFarmImplTraits =
     rewards::RewardsModule
         + config::ConfigModule
@@ -63,34 +85,35 @@ pub trait FarmContract {
     ) -> BigUint<<Self::FarmSc as ContractBase>::Api> {
         let current_block_nonce = sc.blockchain().get_block_nonce();
         let last_reward_nonce = sc.last_reward_block_nonce().get();
-        if current_block_nonce > last_reward_nonce {
-            let to_mint =
-                Self::calculate_per_block_rewards(sc, current_block_nonce, last_reward_nonce);
-            if to_mint != 0 {
-                Self::mint_rewards(sc, token_id, &to_mint);
-            }
-
-            sc.last_reward_block_nonce().set(current_block_nonce);
+        if current_block_nonce <= last_reward_nonce {
+            return BigUint::zero();
+        }
 
-            to_mint
-        } else {
-            BigUint::zero()
+        let to_mint = Self::calculate_per_block_rewards(sc, current_block_nonce, last_reward_nonce);
+        if to_mint != 0 {
+            Self::mint_rewards(sc, token_id, &to_mint);
         }
+
+        sc.last_reward_block_nonce().set(current_block_nonce);
+
+        to_mint
     }
 
     fn generate_aggregated_rewards(
         sc: &Self::FarmSc,
         storage_cache: &mut StorageCache<Self::FarmSc>,
     ) {
         let total_reward = Self::mint_per_block_rewards(sc, &storage_cache.reward_token_id);
-        if total_reward > 0u64 {
-            storage_cache.reward_reserve += &total_reward;
+        if total_reward == 0u64 {
+            return;
+        }
 
-            if storage_cache.farm_token_supply != 0u64 {
-                let increase = (&total_reward * &storage_cache.division_safety_constant)
-                    / &storage_cache.farm_token_supply;
-                storage_cache.reward_per_share += &increase;
-            }
+        storage_cache.reward_reserve += &total_reward;
+
+        if storage_cache.farm_token_supply != 0u64 {
+            let increase = (&total_reward * &storage_cache.division_safety_constant)
+                / &storage_cache.farm_token_supply;
+            storage_cache.reward_per_share += &increase;
         }
     }
 
@@ -100,14 +123,16 @@ pub trait FarmContract {
         farm_token_amount: &BigUint<<Self::FarmSc as ContractBase>::Api>,
         token_attributes: &Self::AttributesType,
         storage_cache: &StorageCache<Self::FarmSc>,
-    ) -> BigUint<<Self::FarmSc as ContractBase>::Api> {
+    ) -> RewardPair<<Self::FarmSc as ContractBase>::Api> {
         let token_rps = token_attributes.get_reward_per_share();
-        if storage_cache.reward_per_share > token_rps {
-            let rps_diff = &storage_cache.reward_per_share - &token_rps;
-            farm_token_amount * &rps_diff / &storage_cache.division_safety_constant
-        } else {
-            BigUint::zero()
+        if storage_cache.reward_per_share <= token_rps {
+            return RewardPair::new_zero();
         }
+
+        let rps_diff = &storage_cache.reward_per_share - &token_rps;
+        let base_rewards = farm_token_amount * &rps_diff / &storage_cache.division_safety_constant;
+
+        RewardPair::new(base_rewards, BigUint::zero())
     }
 
     fn create_enter_farm_initial_attributes(
@@ -212,7 +237,6 @@ pub trait FarmContract {
         }
     }
 
-    #[inline]
     fn increase_user_farm_position(
         sc: &Self::FarmSc,
         user: &ManagedAddress<<Self::FarmSc as ContractBase>::Api>,

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

@@ -1,6 +1,6 @@
 multiversx_sc::imports!();
 
-use crate::base_traits_impl::FarmContract;
+use crate::base_traits_impl::{FarmContract, RewardPair};
 use common_structs::{PaymentAttributesPair, PaymentsVec};
 use contexts::{
     claim_rewards_context::ClaimRewardsContext,
@@ -15,7 +15,7 @@ where
 {
     pub context: ClaimRewardsContext<C::Api, T>,
     pub storage_cache: StorageCache<'a, C>,
-    pub rewards: EsdtTokenPayment<C::Api>,
+    pub rewards: RewardPair<C::Api>,
     pub new_farm_token: PaymentAttributesPair<C::Api, T>,
     pub created_with_merge: bool,
 }
@@ -72,14 +72,14 @@ pub trait BaseClaimRewardsModule:
             .clone()
             .into_part(farm_token_amount);
 
-        let reward = FC::calculate_rewards(
+        let rewards = FC::calculate_rewards(
             self,
             &caller,
             farm_token_amount,
             &token_attributes,
             &storage_cache,
         );
-        storage_cache.reward_reserve -= &reward;
+        storage_cache.reward_reserve -= rewards.total_rewards();
 
         FC::check_and_update_user_farm_position(self, &caller, &payments);
 
@@ -112,7 +112,7 @@ pub trait BaseClaimRewardsModule:
         InternalClaimRewardsResult {
             created_with_merge: !claim_rewards_context.additional_payments.is_empty(),
             context: claim_rewards_context,
-            rewards: EsdtTokenPayment::new(storage_cache.reward_token_id.clone(), 0, reward),
+            rewards,
             new_farm_token,
             storage_cache,
         }

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

@@ -60,15 +60,16 @@ pub trait BaseCompoundRewardsModule:
             .clone()
             .into_part(farm_token_amount);
 
-        let reward = FC::calculate_rewards(
+        let rewards = FC::calculate_rewards(
             self,
             &caller,
             farm_token_amount,
             &token_attributes,
             &storage_cache,
         );
-        storage_cache.reward_reserve -= &reward;
-        storage_cache.farm_token_supply += &reward;
+        let total_rewards = rewards.total_rewards();
+        storage_cache.reward_reserve -= &total_rewards;
+        storage_cache.farm_token_supply += &total_rewards;
 
         FC::check_and_update_user_farm_position(self, &caller, &payments);
 
@@ -78,15 +79,15 @@ pub trait BaseCompoundRewardsModule:
             caller.clone(),
             token_attributes,
             storage_cache.reward_per_share.clone(),
-            &reward,
+            &total_rewards,
         );
         let new_farm_token = self.merge_and_create_token(
             base_attributes,
             &compound_rewards_context.additional_payments,
             &farm_token_mapper,
         );
 
-        FC::increase_user_farm_position(self, &caller, &reward);
+        FC::increase_user_farm_position(self, &caller, &total_rewards);
 
         let first_farm_token = &compound_rewards_context.first_farm_token.payment;
         farm_token_mapper.nft_burn(first_farm_token.token_nonce, &first_farm_token.amount);
@@ -97,7 +98,7 @@ pub trait BaseCompoundRewardsModule:
             created_with_merge: !compound_rewards_context.additional_payments.is_empty(),
             context: compound_rewards_context,
             new_farm_token,
-            compounded_rewards: reward,
+            compounded_rewards: total_rewards,
             storage_cache,
         }
     }

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

@@ -6,6 +6,7 @@ use contexts::{
     enter_farm_context::EnterFarmContext,
     storage_cache::{FarmContracTraitBounds, StorageCache},
 };
+use fixed_supply_token::FixedSupplyToken;
 
 pub struct InternalEnterFarmResult<'a, C, T>
 where
@@ -34,6 +35,21 @@ pub trait BaseEnterFarmModule:
         &self,
         caller: ManagedAddress,
         payments: PaymentsVec<Self::Api>,
+    ) -> InternalEnterFarmResult<Self, FC::AttributesType> {
+        let mut result = self.enter_farm_base_no_token_create::<FC>(caller, payments);
+        let new_farm_token_payment = self.farm_token().nft_create(
+            result.new_farm_token.payment.amount,
+            &result.new_farm_token.attributes,
+        );
+        result.new_farm_token.payment = new_farm_token_payment;
+
+        result
+    }
+
+    fn enter_farm_base_no_token_create<FC: FarmContract<FarmSc = Self>>(
+        &self,
+        caller: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
     ) -> InternalEnterFarmResult<Self, FC::AttributesType> {
         let mut storage_cache = StorageCache::new(self);
         self.validate_contract_state(storage_cache.contract_state, &storage_cache.farm_token_id);
@@ -67,11 +83,19 @@ pub trait BaseEnterFarmModule:
             enter_farm_context.farming_token_payment.amount.clone(),
             storage_cache.reward_per_share.clone(),
         );
-        let new_farm_token = self.merge_and_create_token(
+        let new_token_attributes = self.merge_attributes_from_payments(
             base_attributes,
             &enter_farm_context.additional_farm_tokens,
             &farm_token_mapper,
         );
+        let new_farm_token = PaymentAttributesPair {
+            payment: EsdtTokenPayment::new(
+                storage_cache.farm_token_id.clone(),
+                0,
+                new_token_attributes.get_total_supply(),
+            ),
+            attributes: new_token_attributes,
+        };
 
         self.send()
             .esdt_local_burn_multi(&enter_farm_context.additional_farm_tokens);