[MEX-822] safe price sc testing

contracts/base_contracts.py

@@ -46,33 +46,13 @@ def get_first_week_start_epoch(self, proxy: ProxyNetworkProvider) -> int:
         result = int(raw_results)
 
         return result
-
-    def get_last_global_update_week(self, proxy: ProxyNetworkProvider) -> int:
-        data_fetcher = BaseBoostedContractDataFetcher(Address(self.address), proxy.url)
-        raw_results = data_fetcher.get_data('getLastGlobalUpdateWeek')
-        if not raw_results:
-            return 0
-        result = int(raw_results)
 
-        return result
-
-    def get_current_week(self, proxy: ProxyNetworkProvider) -> int:
-        data_fetcher = BaseBoostedContractDataFetcher(Address(self.address), proxy.url)
-        raw_results = data_fetcher.get_data('getCurrentWeek')
-        if not raw_results:
-            return 0
-        current_week = int(raw_results)
+    def get_next_week_start_epoch(self, proxy: ProxyNetworkProvider) -> int:
+        first_week = self.get_first_week_start_epoch(proxy)
+        current_week = self.get_current_week(proxy)
+        next_week_at_epoch = first_week + current_week * 7
 
-        return current_week
-
-    def get_first_week_start_epoch(self, proxy: ProxyNetworkProvider) -> int:
-        data_fetcher = BaseBoostedContractDataFetcher(Address(self.address), proxy.url)
-        raw_results = data_fetcher.get_data('getFirstWeekStartEpoch')
-        if not raw_results:
-            return 0
-        result = int(raw_results)
-
-        return result
+        return next_week_at_epoch
 
     def get_last_global_update_week(self, proxy: ProxyNetworkProvider) -> int:
         data_fetcher = BaseBoostedContractDataFetcher(Address(self.address), proxy.url)
@@ -123,6 +103,13 @@ def get_total_locked_tokens_for_week(self, proxy: ProxyNetworkProvider, week: in
         if not raw_results:
             return 0
         return int(raw_results)
+
+    def get_accumulated_rewards_for_week(self, proxy: ProxyNetworkProvider, week: int) -> int:
+        data_fetcher = BaseBoostedContractDataFetcher(Address(self.address), proxy.url)
+        raw_results = data_fetcher.get_data('getAccumulatedRewardsForWeek', [U64Value(week)])
+        if not raw_results:
+            return 0
+        return int(raw_results)
 
     def get_total_energy_for_week(self, proxy: ProxyNetworkProvider, week: int) -> int:
         data_fetcher = BaseBoostedContractDataFetcher(Address(self.address), proxy.url)
@@ -163,7 +150,9 @@ def get_all_boosted_global_stats(self, proxy: ProxyNetworkProvider, week: int =
             "first_week": self.get_first_week_start_epoch(proxy),
             "current_week": self.get_current_week(proxy),
             "farm_supply_for_week": self.get_farm_supply_for_week(proxy, week),
+            "total_rewards_for_week": self.get_total_rewards_for_week(proxy, week),
             "total_locked_tokens_for_week": self.get_total_locked_tokens_for_week(proxy, week),
+            "accumulated_rewards_for_week": self.get_accumulated_rewards_for_week(proxy, week),
             "total_energy_for_week": self.get_total_energy_for_week(proxy, week)
         }
         return staking_stats
@@ -206,6 +195,13 @@ def get_last_reward_block_nonce(self, proxy: ProxyNetworkProvider) -> int:
         if not raw_results:
             return 0
         return int(raw_results)
+
+    def get_last_reward_timestamp(self, proxy: ProxyNetworkProvider) -> int:
+        data_fetcher = BaseFarmContractDataFetcher(Address(self.address), proxy.url)
+        raw_results = data_fetcher.get_data('getLastRewardTimestamp')
+        if not raw_results:
+            return 0
+        return int(raw_results)
 
     def get_per_block_reward_amount(self, proxy: ProxyNetworkProvider) -> int:
         data_fetcher = BaseFarmContractDataFetcher(Address(self.address), proxy.url)
@@ -259,6 +255,7 @@ def get_all_farm_global_stats(self, proxy: ProxyNetworkProvider) -> Dict[str, An
             "reward_reserve": self.get_reward_reserve(proxy),
             "reward_per_share": self.get_reward_per_share(proxy),
             "last_reward_block_nonce": self.get_last_reward_block_nonce(proxy),
+            "last_reward_timestamp": self.get_last_reward_timestamp(proxy),
             "state": self.get_state(proxy)
         }
         return farm_stats

contracts/fees_collector_contract.py

@@ -105,7 +105,7 @@ def add_known_tokens(self, deployer: Account, proxy: ProxyNetworkProvider, args:
             log_unexpected_args(function_purpose, args)
             return ""
 
-        gas_limit = 10000000
+        gas_limit = 10000000 + len(args) * 1000000
         return endpoint_call(proxy, gas_limit, deployer, Address(self.address), "addKnownTokens", args)
 
     def remove_known_contracts(self, deployer: Account, proxy: ProxyNetworkProvider, args: list):

contracts/metastaking_contract.py

@@ -6,7 +6,7 @@
 from utils.utils_tx import deploy, upgrade_call, \
     endpoint_call, multi_esdt_endpoint_call
 from utils.utils_chain import Account, WrapperAddress as Address, base64_to_hex, decode_merged_attributes, hex_to_string
-from multiversx_sdk import CodeMetadata, ProxyNetworkProvider
+from multiversx_sdk import CodeMetadata, ProxyNetworkProvider, Token
 from utils.utils_generic import log_step_pass, log_substep, log_unexpected_args
 from utils.decoding_structures import FARM_TOKEN_ATTRIBUTES, METASTAKE_TOKEN_ATTRIBUTES, STAKE_V2_TOKEN_ATTRIBUTES, STAKE_V1_TOKEN_ATTRIBUTES
 import config
@@ -221,7 +221,7 @@ def exit_metastake(self, proxy: ProxyNetworkProvider, user: Account, args: List[
         logger.info(function_purpose)
         logger.debug(f"Account: {user.address}")
 
-        gas_limit = 70000000
+        gas_limit = 90000000
         exit_metastake_fn = 'unstakeFarmTokens'
 
         return multi_esdt_endpoint_call(function_purpose, proxy, gas_limit,
@@ -281,9 +281,9 @@ def get_decoded_metastake_token_attributes_from_proxy(self, proxy: ProxyNetworkP
                                                               holder_address: str, token_nonce: int) -> Dict[str, Any]:
         """ Get decoded attributes of the metastake token from the proxy without underlying farm and stake tokens.
         Proxy usage requires to know the holder address."""
-        metastake_token_on_network = proxy.get_nonfungible_token_of_account(Address(holder_address), self.metastake_token, token_nonce)
+        metastake_token_on_network = proxy.get_token_of_account(Address(holder_address), Token(self.metastake_token, token_nonce))
 
-        decoded_attributes = decode_merged_attributes(base64_to_hex(metastake_token_on_network.attributes), METASTAKE_TOKEN_ATTRIBUTES)
+        decoded_attributes = decode_merged_attributes(metastake_token_on_network.attributes.hex(), METASTAKE_TOKEN_ATTRIBUTES)
         logger.debug(f'Metastake Tokens: {decoded_attributes}')
 
         return decoded_attributes
@@ -294,16 +294,16 @@ def get_all_decoded_metastake_token_attributes_from_proxy(self, proxy: ProxyNetw
         Proxy usage requires to know the holder address."""
         decoded_attributes = self.get_decoded_metastake_token_attributes_from_proxy(proxy, holder_address, token_nonce)
 
-        farm_token_on_network = proxy.get_nonfungible_token_of_account(Address(self.address), self.farm_token, decoded_attributes.get('lp_farm_token_nonce'))
-        farm_token_decoded_attributes = decode_merged_attributes(base64_to_hex(farm_token_on_network.attributes), FARM_TOKEN_ATTRIBUTES)
+        farm_token_on_network = proxy.get_token_of_account(Address(self.address), Token(self.farm_token, decoded_attributes.get('lp_farm_token_nonce')))
+        farm_token_decoded_attributes = decode_merged_attributes(farm_token_on_network.attributes.hex(), FARM_TOKEN_ATTRIBUTES)
         logger.debug(f'Underlying Farm Tokens: {farm_token_decoded_attributes}')
 
-        stake_token_on_network = proxy.get_nonfungible_token_of_account(Address(self.address), self.stake_token, decoded_attributes.get('staking_farm_token_nonce'))
+        stake_token_on_network = proxy.get_token_of_account(Address(self.address), Token(self.stake_token, decoded_attributes.get('staking_farm_token_nonce')))
         try:
-            stake_token_decoded_attributes = decode_merged_attributes(base64_to_hex(stake_token_on_network.attributes), STAKE_V2_TOKEN_ATTRIBUTES)
+            stake_token_decoded_attributes = decode_merged_attributes(stake_token_on_network.attributes.hex(), STAKE_V2_TOKEN_ATTRIBUTES)
         except ValueError as e:
             # handle for old stake token attributes
-            stake_token_decoded_attributes = decode_merged_attributes(base64_to_hex(stake_token_on_network.attributes), STAKE_V1_TOKEN_ATTRIBUTES)
+            stake_token_decoded_attributes = decode_merged_attributes(stake_token_on_network.attributes.hex(), STAKE_V1_TOKEN_ATTRIBUTES)
         logger.debug(f'Underlying Stake Tokens: {stake_token_decoded_attributes}')
 
         return decoded_attributes, farm_token_decoded_attributes, stake_token_decoded_attributes

contracts/router_contract.py

@@ -320,35 +320,49 @@ def withdraw_egld(self, deployer: Account, proxy: ProxyNetworkProvider):
         gas_limit = 10000000
         return endpoint_call(proxy, gas_limit, deployer, Address(self.address), "withdrawEgld", [])
 
-    def set_safe_price_round_save_interval(self, deployer: Account, proxy: ProxyNetworkProvider, args: list):
+    def set_safe_price_round_save_interval(self, deployer: Account, proxy: ProxyNetworkProvider, interval: int):
         """ Expected as args:
             type[int]: interval
-            type[list[str]]: pair addresses
         """
         function_purpose = f"Set safe price round save interval"
         logger.info(function_purpose)
 
-        if len(args) != 2:
-            log_unexpected_args(function_purpose, args)
-            return ""
-
         gas_limit = 10000000
         sc_args = [
-            args[0]
+            interval
         ]
+        return endpoint_call(proxy, gas_limit, deployer, Address(self.address), "setSafePriceRoundSaveInterval", sc_args)
 
-        if type(args[1]) != list:
-            log_unexpected_args(function_purpose, args)
-            return ""
-        sc_args.extend([Address(address) for address in args[1]])
+    def set_default_safe_price_rounds_offset(self, deployer: Account, proxy: ProxyNetworkProvider, offset: int):
+        """ 
+        Sets the default safe price rounds offset for the legacy safe price views.
+        Expected as args:
+            type[int]: offset
+        """
+        function_purpose = f"Set default safe price rounds offset"
+        logger.info(function_purpose)
 
-        return endpoint_call(proxy, gas_limit, deployer, Address(self.address), "setSafePriceRoundSaveInterval", sc_args)
+        gas_limit = 10000000
+        sc_args = [
+            offset
+        ]
+        return endpoint_call(proxy, gas_limit, deployer, Address(self.address), "setDefaultSafePriceRoundsOffset", sc_args)
 
     def get_pair_template_address(self, proxy: ProxyNetworkProvider):
         router_data_fetcher = RouterContractDataFetcher(Address(self.address), proxy.url)
         template_pair_address = Address.from_hex(router_data_fetcher.get_data("getPairTemplateAddress")).bech32()
         return template_pair_address
 
+    def get_safe_price_round_save_interval(self, proxy: ProxyNetworkProvider):
+        router_data_fetcher = RouterContractDataFetcher(Address(self.address), proxy.url)
+        interval = router_data_fetcher.get_data("getSafePriceRoundSaveInterval")
+        return int(interval)
+
+    def get_default_safe_price_rounds_offset(self, proxy: ProxyNetworkProvider):
+        router_data_fetcher = RouterContractDataFetcher(Address(self.address), proxy.url)
+        offset = router_data_fetcher.get_data("getDefaultSafePriceRoundsOffset")
+        return int(offset)
+
     def contract_start(self, deployer: Account, proxy: ProxyNetworkProvider, args: list = []):
         pass
 

contracts/staking_contract.py

@@ -7,7 +7,7 @@
 from utils.utils_tx import NetworkProviders, ESDTToken, multi_esdt_endpoint_call, deploy, upgrade_call, endpoint_call
 from utils.utils_chain import Account, WrapperAddress as Address, decode_merged_attributes, hex_to_string, base64_to_hex
 from utils.contract_data_fetchers import StakingContractDataFetcher
-from multiversx_sdk import CodeMetadata, ProxyNetworkProvider
+from multiversx_sdk import CodeMetadata, ProxyNetworkProvider, Token
 from multiversx_sdk.abi import AddressValue
 from utils.utils_generic import log_step_pass, log_substep, log_unexpected_args
 from events.farm_events import (EnterFarmEvent, ExitFarmEvent,
@@ -469,6 +469,13 @@ def get_accumulated_rewards(self, proxy: ProxyNetworkProvider) -> int:
         if not raw_results:
             return 0
         return int(raw_results)
+
+    def get_max_apr(self, proxy: ProxyNetworkProvider) -> int:
+        data_fetcher = StakingContractDataFetcher(Address(self.address), proxy.url)
+        raw_results = data_fetcher.get_data('getAnnualPercentageRewards')
+        if not raw_results:
+            return 0
+        return int(raw_results)
 
     def get_permissions(self, address: str, proxy: ProxyNetworkProvider) -> int:
         data_fetcher = StakingContractDataFetcher(Address(self.address), proxy.url)
@@ -481,17 +488,17 @@ def get_decoded_farm_token_attributes_from_proxy(self, proxy: ProxyNetworkProvid
                                                               holder_address: str, token_nonce: int) -> Dict[str, Any]:
         """ Get decoded attributes of the farm token from the proxy without underlying farm and stake tokens.
         Proxy usage requires to know the holder address."""
-        farm_token_on_network = proxy.get_nonfungible_token_of_account(Address(holder_address), self.farm_token, token_nonce)
+        farm_token_on_network = proxy.get_token_of_account(Address(holder_address), Token(self.farm_token, token_nonce))
 
         try:
-            farm_token_decoded_attributes = decode_merged_attributes(base64_to_hex(farm_token_on_network.attributes), STAKE_V2_TOKEN_ATTRIBUTES)
+            farm_token_decoded_attributes = decode_merged_attributes(farm_token_on_network.attributes.hex(), STAKE_V2_TOKEN_ATTRIBUTES)
         except ValueError as e:
             try:
                 # handle for old stake token attributes
-                farm_token_decoded_attributes = decode_merged_attributes(base64_to_hex(farm_token_on_network.attributes), STAKE_V1_TOKEN_ATTRIBUTES)
+                farm_token_decoded_attributes = decode_merged_attributes(farm_token_on_network.attributes.hex(), STAKE_V1_TOKEN_ATTRIBUTES)
             except ValueError as e:
                 # unstake token
-                farm_token_decoded_attributes = decode_merged_attributes(base64_to_hex(farm_token_on_network.attributes), STAKE_UNBOND_TOKEN_ATTRIBUTES)
+                farm_token_decoded_attributes = decode_merged_attributes(farm_token_on_network.attributes.hex(), STAKE_UNBOND_TOKEN_ATTRIBUTES)
 
         logger.debug(f'Farm Tokens: {farm_token_decoded_attributes}')
 

deploy/configs-devnet/deploy_structure.json

@@ -248,6 +248,17 @@
             "special_fee": 100,
             "fees_collector": 0,
             "fees_collector_cut": 500
+        },
+        {
+            "launched_token": 0,
+            "accepted_token": 2,
+            "lp_token": "MEXUSDC",
+            "lp_token_name": "MEXUSDCLP",
+            "fee_token": 1,
+            "total_fee": 300,
+            "special_fee": 100,
+            "fees_collector": 0,
+            "fees_collector_cut": 500
         }
     ],
 

deploy/configs-devnet/deployed_pairs_v2.json

@@ -89,5 +89,12 @@
         "lpToken": "USHWEGLD-0b8b66",
         "address": "erd1qqqqqqqqqqqqqpgq2uxpprk08dn6523s0cre2v86h9cd57vf0n4ss7r54t",
         "version": 2
+    },
+    {
+        "firstToken": "MEX-a659d0",
+        "secondToken": "USDC-350c4e",
+        "lpToken": "MEXUSDC-fe3eb4",
+        "address": "erd1qqqqqqqqqqqqqpgqlmwaf993zd0ukglm5m59w4fd8mwp95us0n4sl223md",
+        "version": 2
     }
 ]