Merge pull request #1032 from multiversx/timestamp-based-exchange-scs

Timestamp based exchange SCs

Author: psorinionut

README.md

@@ -38,11 +38,11 @@ The owner of all the Pair SCs is the Router SC. It is used for deploying, upgrad
 
 ### Farm Contract
 
-In order to gain users trust, the liquidity inside the DEX must be somewhat stable. To achieve that, Farm contracts come in place to incentivise liquidity providers to lock their LP tokens in exchange for MEX rewards. Rewards are generated per block and their rate is configurable in sync with the MEX tokenomics.
+In order to gain users trust, the liquidity inside the DEX must be somewhat stable. To achieve that, Farm contracts come in place to incentivise liquidity providers to lock their LP tokens in exchange for MEX rewards. Rewards are generated based on timestamps and their rate is configurable in sync with the MEX tokenomics.
 
 ### Farm with Lock Contract
 
-Works the same as the regular Farm with the exception that it does not generate MEX as rewards. Instead, it generates Locked MEX, with the help of the Factory SC. The reason one would choose to go with the locked rewards (LKMEX) instead of the regular rewards (MEX) is that the reward emission rate (reward per block rate) is bigger, meaning the APR is higher.
+It works the same as a regular Farm SC, with the exception that it does not generate MEX as rewards. Instead, it generates Locked MEX (XMEX), with the help of the Energy Factory smart contract. Users may choose to receive locked rewards instead of regular MEX because XMEX also provides Energy, which can be used across the entire xExchange protocol.
 
 ### Price discovery
 

common/common_structs/src/alias_types.rs

@@ -6,6 +6,7 @@ pub type Nonce = u64;
 pub type Epoch = u64;
 pub type Week = usize;
 pub type Percent = u64;
+pub type Timestamp = u64;
 pub type PaymentsVec<M> = ManagedVec<M, EsdtTokenPayment<M>>;
 pub type UnlockPeriod<M> = UnlockSchedule<M>;
 pub type OldLockedTokenAttributes<M> = LockedAssetTokenAttributesEx<M>;

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

@@ -3,7 +3,7 @@
 multiversx_sc::imports!();
 multiversx_sc::derive_imports!();
 
-use common_structs::Nonce;
+use common_structs::{Nonce, Timestamp};
 use pausable::State;
 
 pub const DEFAULT_NFT_DEPOSIT_MAX_LEN: usize = 10;
@@ -52,16 +52,16 @@ pub trait ConfigModule: pausable::PausableModule + permissions_module::Permissio
     #[storage_mapper("reward_token_id")]
     fn reward_token_id(&self) -> SingleValueMapper<TokenIdentifier>;
 
-    #[view(getPerBlockRewardAmount)]
-    #[storage_mapper("per_block_reward_amount")]
-    fn per_block_reward_amount(&self) -> SingleValueMapper<BigUint>;
-
     #[storage_mapper("produce_rewards_enabled")]
     fn produce_rewards_enabled(&self) -> SingleValueMapper<bool>;
 
-    #[view(getLastRewardBlockNonce)]
-    #[storage_mapper("last_reward_block_nonce")]
-    fn last_reward_block_nonce(&self) -> SingleValueMapper<Nonce>;
+    #[view(getPerSecondRewardAmount)]
+    #[storage_mapper("per_second_reward_amount")]
+    fn per_second_reward_amount(&self) -> SingleValueMapper<BigUint>;
+
+    #[view(getLastRewardTimestamp)]
+    #[storage_mapper("last_reward_timestamp")]
+    fn last_reward_timestamp(&self) -> SingleValueMapper<Timestamp>;
 
     #[view(getDivisionSafetyConstant)]
     #[storage_mapper("division_safety_constant")]

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

@@ -1,6 +1,6 @@
 multiversx_sc::imports!();
 
-use common_structs::{FarmToken, FarmTokenAttributes, Nonce};
+use common_structs::{FarmToken, FarmTokenAttributes, Timestamp};
 use config::ConfigModule;
 use contexts::storage_cache::StorageCache;
 use core::marker::PhantomData;
@@ -54,35 +54,35 @@ pub trait FarmContract {
         sc.send().esdt_local_mint(token_id, 0, amount);
     }
 
-    fn calculate_per_block_rewards(
+    fn calculate_per_second_rewards(
         sc: &Self::FarmSc,
-        current_block_nonce: Nonce,
-        last_reward_block_nonce: Nonce,
+        current_timestamp: Timestamp,
+        last_reward_timestamp: Timestamp,
     ) -> BigUint<<Self::FarmSc as ContractBase>::Api> {
-        if current_block_nonce <= last_reward_block_nonce || !sc.produces_per_block_rewards() {
+        if current_timestamp <= last_reward_timestamp || !sc.produces_per_second_rewards() {
             return BigUint::zero();
         }
 
-        let per_block_reward = sc.per_block_reward_amount().get();
-        let block_nonce_diff = current_block_nonce - last_reward_block_nonce;
+        let per_second_reward = sc.per_second_reward_amount().get();
+        let timestamp_diff = current_timestamp - last_reward_timestamp;
 
-        per_block_reward * block_nonce_diff
+        per_second_reward * timestamp_diff
     }
 
-    fn mint_per_block_rewards(
+    fn mint_per_second_rewards(
         sc: &Self::FarmSc,
         token_id: &TokenIdentifier<<Self::FarmSc as ContractBase>::Api>,
     ) -> 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 current_timestamp = sc.blockchain().get_block_timestamp();
+        let last_reward_timestamp = sc.last_reward_timestamp().get();
+        if current_timestamp > last_reward_timestamp {
             let to_mint =
-                Self::calculate_per_block_rewards(sc, current_block_nonce, last_reward_nonce);
+                Self::calculate_per_second_rewards(sc, current_timestamp, last_reward_timestamp);
             if to_mint != 0 {
                 Self::mint_rewards(sc, token_id, &to_mint);
             }
 
-            sc.last_reward_block_nonce().set(current_block_nonce);
+            sc.last_reward_timestamp().set(current_timestamp);
 
             to_mint
         } else {
@@ -94,7 +94,7 @@ pub trait FarmContract {
         sc: &Self::FarmSc,
         storage_cache: &mut StorageCache<Self::FarmSc>,
     ) {
-        let total_reward = Self::mint_per_block_rewards(sc, &storage_cache.reward_token_id);
+        let total_reward = Self::mint_per_second_rewards(sc, &storage_cache.reward_token_id);
         if total_reward > 0u64 {
             storage_cache.reward_reserve += &total_reward;
 

common/modules/farm/rewards/src/rewards.rs

@@ -8,20 +8,20 @@ pub trait RewardsModule:
 {
     fn start_produce_rewards(&self) {
         require!(
-            self.per_block_reward_amount().get() != 0u64,
+            self.per_second_reward_amount().get() != 0u64,
             "Cannot produce zero reward amount"
         );
         require!(
             !self.produce_rewards_enabled().get(),
             "Producing rewards is already enabled"
         );
-        let current_nonce = self.blockchain().get_block_nonce();
+        let current_timestamp = self.blockchain().get_block_timestamp();
         self.produce_rewards_enabled().set(true);
-        self.last_reward_block_nonce().set(current_nonce);
+        self.last_reward_timestamp().set(current_timestamp);
     }
 
     #[inline]
-    fn produces_per_block_rewards(&self) -> bool {
+    fn produces_per_second_rewards(&self) -> bool {
         self.produce_rewards_enabled().get()
     }
 

dex/farm-with-locked-rewards/README.md

@@ -64,7 +64,7 @@ This endpoint will give back to the caller a Farm position as a result. The Farm
 
 This endpoint receives one payment, and that is the Farm Position. Based on an internal counter that the contract keeps track of, which is the __rps__ - meaning reward per share, the contract can calculate the reward that it needs to return to the caller for those specific tokens that he has sent. The output will consist of two payments: the LP tokens initially added and the accumulated rewards.
 
-This contract simulates per-block-reward-generation by keeping track of the last block that generated mex and keeps updating on every endpoint execution. Everytime an execution happens, the contract will generate the rewards for previous blocks. This is the case for the first successful TX inside a block, so only once per block this check has to be made and the action to be taken.
+This contract simulates timestamp-based reward generation by keeping track of the last timestamp that generated rewards and keeps updating on every endpoint execution. Everytime an execution happens, the contract will generate the rewards for the previous time period. This is the case for the first successful transaction within a timestamp interval, so only once per interval this check has to be made and the action to be taken.
 
 ### claimRewards
 

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

@@ -9,6 +9,7 @@ use common_structs::FarmTokenAttributes;
 use contexts::storage_cache::StorageCache;
 use core::marker::PhantomData;
 use fixed_supply_token::FixedSupplyToken;
+use multiversx_sc::storage::StorageKey;
 
 use farm::{
     base_functions::{BaseFunctionsModule, ClaimRewardsResultType, DoubleMultiPayment, Wrapper},
@@ -88,12 +89,50 @@ pub trait Farm:
 
     #[upgrade]
     fn upgrade(&self) {
-        let current_epoch = self.blockchain().get_block_epoch();
-        self.first_week_start_epoch().set_if_empty(current_epoch);
+        // Aggregate rewards before migration
+        let mut storage_cache = StorageCache::new(self);
+        let current_block_nonce = self.blockchain().get_block_nonce();
 
-        // Farm position migration code
-        let farm_token_mapper = self.farm_token();
-        self.try_set_farm_position_migration_nonce(farm_token_mapper);
+        let last_reward_block_nonce_mapper =
+            SingleValueMapper::<Self::Api, u64>::new(StorageKey::new(b"last_reward_block_nonce"));
+        let per_block_reward_amount_mapper = SingleValueMapper::<Self::Api, BigUint>::new(
+            StorageKey::new(b"per_block_reward_amount"),
+        );
+
+        let per_block_reward_amount: BigUint<Self::Api> = per_block_reward_amount_mapper.take();
+        let last_reward_nonce = last_reward_block_nonce_mapper.take();
+
+        if self.produces_per_second_rewards() {
+            let total_reward = if current_block_nonce > last_reward_nonce {
+                let block_nonce_diff = current_block_nonce - last_reward_nonce;
+                &per_block_reward_amount * block_nonce_diff
+            } else {
+                BigUint::zero()
+            };
+
+            // No minting, even if total_reward is not zero (NoMintWrapper)
+            if total_reward > 0u64 {
+                storage_cache.reward_reserve += &total_reward;
+                let split_rewards = self.take_reward_slice(total_reward);
+
+                if storage_cache.farm_token_supply != 0u64 {
+                    let increase = (&split_rewards.base_farm
+                        * &storage_cache.division_safety_constant)
+                        / &storage_cache.farm_token_supply;
+                    storage_cache.reward_per_share += &increase;
+                }
+            }
+
+            // Set farm supply for current week to ensure boosted rewards can be claimed correctly
+            self.set_farm_supply_for_current_week(&storage_cache.farm_token_supply);
+        }
+
+        // Migrate storage
+        let per_second_reward_amount = per_block_reward_amount / 6u64; // 6 seconds per block
+        self.per_second_reward_amount()
+            .set(&per_second_reward_amount);
+        self.last_reward_timestamp()
+            .set(self.blockchain().get_block_timestamp());
     }
 
     #[payable("*")]
@@ -265,10 +304,10 @@ pub trait Farm:
         self.end_produce_rewards::<NoMintWrapper<Self>>();
     }
 
-    #[endpoint(setPerBlockRewardAmount)]
-    fn set_per_block_rewards_endpoint(&self, per_block_amount: BigUint) {
+    #[endpoint(setPerSecondRewardAmount)]
+    fn set_per_second_rewards_endpoint(&self, per_second_amount: BigUint) {
         self.require_caller_has_admin_permissions();
-        self.set_per_block_rewards::<NoMintWrapper<Self>>(per_block_amount);
+        self.set_per_second_rewards::<NoMintWrapper<Self>>(per_second_amount);
     }
 
     #[endpoint(setBoostedYieldsRewardsPercentage)]
@@ -326,7 +365,7 @@ where
         sc: &Self::FarmSc,
         storage_cache: &mut StorageCache<Self::FarmSc>,
     ) {
-        let total_reward = Self::mint_per_block_rewards(sc, &storage_cache.reward_token_id);
+        let total_reward = Self::mint_per_second_rewards(sc, &storage_cache.reward_token_id);
         if total_reward > 0u64 {
             storage_cache.reward_reserve += &total_reward;
             let split_rewards = sc.take_reward_slice(total_reward);

dex/farm-with-locked-rewards/tests/farm_with_locked_rewards_setup/mod.rs

@@ -4,8 +4,9 @@ use common_structs::FarmTokenAttributes;
 use config::ConfigModule;
 use multiversx_sc::{
     codec::multi_types::OptionalValue,
+    imports::{SingleValueMapper, StorageMapper},
     storage::mappers::StorageTokenWrapper,
-    types::{Address, BigInt, EsdtLocalRole, MultiValueEncoded},
+    types::{Address, BigInt, BigUint, EsdtLocalRole, MultiValueEncoded},
 };
 use multiversx_sc_scenario::{
     imports::TxTokenTransfer,
@@ -37,8 +38,8 @@ pub static LOCKED_REWARD_TOKEN_ID: &[u8] = b"LOCKED-123456";
 pub static LEGACY_LOCKED_TOKEN_ID: &[u8] = b"LEGACY-123456";
 pub static FARMING_TOKEN_ID: &[u8] = b"LPTOK-123456";
 pub static FARM_TOKEN_ID: &[u8] = b"FARM-123456";
-const DIV_SAFETY: u64 = 1_000_000_000_000;
-pub const PER_BLOCK_REWARD_AMOUNT: u64 = 1_000;
+pub const DIV_SAFETY: u64 = 1_000_000_000_000;
+pub const PER_SECOND_REWARD_AMOUNT: u64 = 1_000;
 pub const FARMING_TOKEN_BALANCE: u64 = 100_000_000;
 pub const MAX_PERCENTAGE: u64 = 10_000; // 100%
 pub const BOOSTED_YIELDS_PERCENTAGE: u64 = 2_500; // 25%
@@ -180,8 +181,8 @@ where
                 sc.add_sc_address_to_whitelist(managed_address!(&second_user));
                 sc.add_sc_address_to_whitelist(managed_address!(&third_user));
 
-                sc.per_block_reward_amount()
-                    .set(&managed_biguint!(PER_BLOCK_REWARD_AMOUNT));
+                sc.per_second_reward_amount()
+                    .set(&managed_biguint!(PER_SECOND_REWARD_AMOUNT));
 
                 sc.state().set(State::Active);
                 sc.produce_rewards_enabled().set(true);
@@ -595,4 +596,90 @@ where
             })
             .assert_ok();
     }
+
+    pub fn simulate_per_block_migration_storage(
+        &mut self,
+        per_block_reward_amount: u64,
+        last_reward_block_nonce: u64,
+    ) {
+        self.b_mock
+            .execute_tx(&self.owner, &self.farm_wrapper, &rust_biguint!(0), |sc| {
+                use multiversx_sc::storage::StorageKey;
+
+                // Set old storage values
+                let last_reward_block_nonce_mapper = SingleValueMapper::<DebugApi, u64>::new(
+                    StorageKey::new(b"last_reward_block_nonce"),
+                );
+                let per_block_reward_amount_mapper =
+                    SingleValueMapper::<DebugApi, BigUint<DebugApi>>::new(StorageKey::new(
+                        b"per_block_reward_amount",
+                    ));
+
+                last_reward_block_nonce_mapper.set(last_reward_block_nonce);
+                per_block_reward_amount_mapper.set(managed_biguint!(per_block_reward_amount));
+
+                // Clear the new storage to simulate pre-upgrade state
+                sc.per_second_reward_amount().clear();
+                sc.last_reward_timestamp().clear();
+
+                sc.produce_rewards_enabled().set(true);
+            })
+            .assert_ok();
+    }
+
+    pub fn verify_old_storage_cleared(&mut self) {
+        self.b_mock
+            .execute_query(&self.farm_wrapper, |_sc| {
+                use multiversx_sc::storage::StorageKey;
+
+                let last_reward_block_nonce_mapper = SingleValueMapper::<DebugApi, u64>::new(
+                    StorageKey::new(b"last_reward_block_nonce"),
+                );
+                let per_block_reward_amount_mapper =
+                    SingleValueMapper::<DebugApi, BigUint<DebugApi>>::new(StorageKey::new(
+                        b"per_block_reward_amount",
+                    ));
+
+                let old_block_nonce: u64 = last_reward_block_nonce_mapper.get();
+                let old_per_block_amount: BigUint<DebugApi> = per_block_reward_amount_mapper.get();
+
+                assert_eq!(
+                    old_block_nonce, 0u64,
+                    "Old block nonce storage should be cleared"
+                );
+                assert_eq!(
+                    old_per_block_amount,
+                    managed_biguint!(0),
+                    "Old per block amount storage should be cleared"
+                );
+            })
+            .assert_ok();
+    }
+
+    pub fn get_reward_per_share(&mut self) -> u64 {
+        let mut reward_per_share = 0u64;
+        self.b_mock
+            .execute_query(&self.farm_wrapper, |sc| {
+                reward_per_share = sc.reward_per_share().get().to_u64().unwrap();
+            })
+            .assert_ok();
+
+        reward_per_share
+    }
+
+    pub fn advance_time(&mut self, seconds: u64) {
+        let mut current_timestamp = 0u64;
+        let mut current_block = 0u64;
+        self.b_mock
+            .execute_query(&self.farm_wrapper, |sc| {
+                use multiversx_sc::contract_base::ContractBase;
+
+                current_timestamp = sc.blockchain().get_block_timestamp();
+                current_block = sc.blockchain().get_block_nonce();
+            })
+            .assert_ok();
+
+        self.b_mock.set_block_timestamp(current_timestamp + seconds);
+        self.b_mock.set_block_nonce(current_block + seconds / 6); // 6 seconds per block
+    }
 }