add load contract by address class method for contracts

Signed-off-by: Claudiu Lataretu <claudiu.lataretu@gmail.com>

contracts/composable_tasks_contract.py

@@ -22,6 +22,10 @@ def get_config_dict(self) -> dict:
     def load_config_dict(cls, config_dict: dict):
         return ComposableTasksContract(address=config_dict['address'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list = None):
         """Expecting as args:
         """
@@ -84,3 +88,4 @@ def set_pair_address_for_tokens(self, deployer: Account, proxy: ProxyNetworkProv
         logger.info(function_purpose)
 
         return endpoint_call(proxy, 10000000, deployer, Address(self.address), "setPairAddrForTokens", args)
+

contracts/contract_identities.py

@@ -23,6 +23,11 @@ def get_config_dict(self) -> dict:
     def load_config_dict(cls, config_dict: dict):
         pass
 
+    @classmethod
+    @abstractmethod
+    def load_contract_by_address(cls, address: str):
+        pass
+
     @abstractmethod
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list):
         pass

contracts/dex_proxy_contract.py

@@ -3,12 +3,13 @@
 from contracts.farm_contract import FarmContract
 from contracts.pair_contract import PairContract
 from multiversx_sdk import ApiNetworkProvider, ProxyNetworkProvider, CodeMetadata
+from utils.contract_data_fetchers import ProxyContractDataFetcher
 from utils.logger import get_logger
 from utils.utils_tx import deploy, upgrade_call, \
     endpoint_call, multi_esdt_endpoint_call, ESDTToken
 from utils.utils_generic import log_step_fail, log_step_pass, log_substep, \
     log_unexpected_args
-from utils.utils_chain import Account, WrapperAddress as Address, base64_to_hex, dec_to_padded_hex, decode_merged_attributes
+from utils.utils_chain import Account, WrapperAddress as Address, base64_to_hex, dec_to_padded_hex, decode_merged_attributes, hex_to_string
 
 from utils.decoding_structures import LKMEX_ATTRIBUTES, XMEX_ATTRIBUTES, XMEXFARM_ATTRIBUTES, XMEXLP_ATTRIBUTES
 
@@ -106,6 +107,17 @@ def load_config_dict(cls, config_dict: dict):
                                 address=config_dict['address'],
                                 version=ProxyContractVersion(config_dict['version']))
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        data_fetcher = ProxyContractDataFetcher(Address(address), config.DEFAULT_PROXY)
+        locked_tokens = [hex_to_string(res) for res in data_fetcher.get_data("getLockedTokenIds")]
+        token = hex_to_string(data_fetcher.get_data("getAssetTokenId"))
+        proxy_lp_token = data_fetcher.get_data("getWrappedLpTokenId")
+        proxy_farm_token = data_fetcher.get_data("getWrappedFarmTokenId")
+        version = ProxyContractVersion.V2
+
+        return DexProxyContract(locked_tokens, token, version, address, proxy_lp_token, proxy_farm_token)
+
     def add_liquidity_proxy(self, user: Account, proxy: ProxyNetworkProvider, event: DexProxyAddLiquidityEvent):
         function_purpose = "add liquidity via proxy"
         logger.debug(f"Executing {function_purpose} for user {user.address} with event {event.__dict__}")

contracts/egld_wrap_contract.py

@@ -26,6 +26,10 @@ def load_config_dict(cls, config_dict: dict):
         return EgldWrapContract(address=config_dict['address'],
                                 wrapped_token=config_dict['wrapped_token'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list = None):
         """ Expected as args:
         """

contracts/energy_update_contract.py

@@ -31,6 +31,10 @@ def get_config_dict(self) -> dict:
     def load_config_dict(cls, config_dict: dict):
         return EnergyUpdateContract(address=config_dict['address'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(
             self,
             deployer: Account,

contracts/escrow_contract.py

@@ -22,6 +22,10 @@ def get_config_dict(self) -> dict:
     def load_config_dict(cls, config_dict: dict):
         return EscrowContract(address=config_dict['address'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list):
         """Expecting as args:
             type[str]: energy factory address

contracts/farm_contract.py

@@ -6,7 +6,7 @@
 from utils.logger import get_logger
 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
+from utils.utils_chain import Account, WrapperAddress as Address, decode_merged_attributes, hex_to_string
 from multiversx_sdk import CodeMetadata, ProxyNetworkProvider
 from utils.utils_generic import log_step_pass, log_substep, log_unexpected_args
 from events.farm_events import (EnterFarmEvent, ExitFarmEvent, ClaimRewardsFarmEvent,
@@ -45,6 +45,19 @@ def load_config_dict(cls, config_dict: dict):
                             address=config_dict['address'],
                             version=FarmContractVersion(config_dict['version']))
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        data_fetcher = FarmContractDataFetcher(Address(address), config.DEFAULT_PROXY)
+        farming_token = hex_to_string(data_fetcher.get_data("getFarmingTokenId"))
+        farm_token = hex_to_string(data_fetcher.get_data("getFarmTokenId"))
+        farmed_token = hex_to_string(data_fetcher.get_data("getRewardTokenId"))
+        version = FarmContractVersion.V2Boosted    # TODO: find a way to determine this automatically
+
+        if not farming_token or not farmed_token:
+            return None
+
+        return FarmContract(farming_token, farm_token, farmed_token, address, version)
+
     def has_proxy(self) -> bool:
         if self.proxyContract is not None:
             return True

contracts/fees_collector_contract.py

@@ -23,6 +23,10 @@ def get_config_dict(self) -> dict:
     def load_config_dict(cls, config_dict: dict):
         return FeesCollectorContract(address=config_dict['address'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        return FeesCollectorContract(address=address)
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list = None):
         """ Expected as args:
             type[str]: locked token

contracts/governance_contract.py

@@ -29,6 +29,10 @@ def load_config_dict(cls, config_dict: dict):
         return GovernanceContract(address=config_dict['address'],
                                   fee_token=config_dict['fee_token'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list = []):
         """ Expected as args:
             type[int]: min_energy_for_propose

contracts/liquid_locking_contract.py

@@ -30,6 +30,10 @@ def load_config_dict(cls, config_dict: dict):
         return LiquidLockingContract(address=config_dict['address'],
                                      whitelisted_tokens=config_dict['whitelisted_tokens'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list = []):
         """ Expected as args:
             type[int]: unbond period

contracts/lk_wrap_contract.py

@@ -26,6 +26,10 @@ def load_config_dict(cls, config_dict: dict):
         return LkWrapContract(address=config_dict['address'],
                               wrapped_token=config_dict['wrapped_token'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list):
         """Expecting as args:
             type[str]: energy factory address

contracts/locked_asset_contract.py

@@ -2,9 +2,10 @@
 import traceback
 
 from contracts.contract_identities import DEXContractInterface
+from utils.contract_data_fetchers import LockedAssetContractDataFetcher
 from utils.utils_tx import multi_esdt_endpoint_call, prepare_contract_call_tx, send_contract_call_tx, deploy, upgrade_call, endpoint_call
 from utils.utils_generic import log_step_fail, log_step_pass, log_substep, log_unexpected_args
-from utils.utils_chain import Account, WrapperAddress as Address, log_explorer_transaction
+from utils.utils_chain import Account, WrapperAddress as Address, hex_to_string, log_explorer_transaction
 from multiversx_sdk import CodeMetadata, ProxyNetworkProvider
 from utils.logger import get_logger
 
@@ -31,6 +32,14 @@ def load_config_dict(cls, config_dict: dict):
                                    unlocked_asset=config_dict['unlocked_asset'],
                                    locked_asset=config_dict['locked_asset'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        data_fetcher = LockedAssetContractDataFetcher(Address(address), config.DEFAULT_PROXY)
+        base_token = hex_to_string(data_fetcher.get_data("getAssetTokenId"))
+        locked_token = hex_to_string(data_fetcher.get_data("getLockedAssetTokenId"))
+
+        return LockedAssetContract(locked_token, base_token, address)
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list = []):
         function_purpose = f"deploy {type(self).__name__} contract"
         logger.info(function_purpose)

contracts/locked_token_position_creator_contract.py

@@ -46,6 +46,10 @@ def get_config_dict(self) -> dict:
     def load_config_dict(cls, config_dict: dict):
         return LockedTokenPositionCreatorContract(address=config_dict['address'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(
             self,
             deployer: Account,

contracts/metastaking_contract.py

@@ -1,19 +1,14 @@
-import sys
-import traceback
-from operator import ne
-from typing import Any, Dict, List, Tuple
-
-from contracts.contract_identities import DEXContractInterface, MetaStakingContractIdentity, MetaStakingContractVersion
-from events.metastake_events import (EnterMetastakeEvent, ExitMetastakeEvent, ClaimRewardsMetastakeEvent,
-                                     MergeMetastakeWithStakeEvent)
-from multiversx_sdk import ApiNetworkProvider
+from typing import Any, Dict, List, Tuple, override
+from contracts.contract_identities import DEXContractInterface, MetaStakingContractVersion
+from utils.contract_data_fetchers import MetaStakingContractDataFetcher
 from utils.logger import get_logger
-from utils.utils_tx import NetworkProviders, deploy, upgrade_call, \
-    endpoint_call, ESDTToken, multi_esdt_endpoint_call
-from utils.utils_chain import Account, WrapperAddress as Address, base64_to_hex, decode_merged_attributes
+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 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
 
 logger = get_logger(__name__)
 
@@ -61,6 +56,32 @@ def load_config_dict(cls, config_dict: dict):
                                    stake_address=config_dict['stake_address'],
                                    version=MetaStakingContractVersion(config_dict['version']))
 
+    @classmethod
+    def load_contract_by_address(cls, address: str, version=MetaStakingContractVersion.V3Boosted):
+        data_fetcher = MetaStakingContractDataFetcher(Address(address), config.DEFAULT_PROXY)
+
+        staking_token = hex_to_string(data_fetcher.get_data("getStakingTokenId"))
+        lp_token = hex_to_string(data_fetcher.get_data("getLpTokenId"))
+        farm_token = hex_to_string(data_fetcher.get_data("getLpFarmTokenId"))
+        stake_token = hex_to_string(data_fetcher.get_data("getFarmTokenId"))
+        lp_address = Address.from_hex(data_fetcher.get_data("getPairAddress")).bech32()
+        farm_address = Address.from_hex(data_fetcher.get_data("getLpFarmAddress")).bech32()
+        stake_address = Address.from_hex(data_fetcher.get_data("getStakingFarmAddress")).bech32()
+        metastake_token = hex_to_string(data_fetcher.get_data("getDualYieldTokenId"))
+
+        return MetaStakingContract(
+            staking_token,
+            lp_token,
+            farm_token,
+            stake_token,
+            lp_address,
+            farm_address,
+            stake_address,
+            version,
+            metastake_token,
+            address
+        )
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list = []):
         function_purpose = f"Deploy metastaking contract"
         logger.info(function_purpose)

contracts/pair_contract.py

@@ -1,11 +1,13 @@
 import sys
 import traceback
+import config
 
 from contracts.contract_identities import (DEXContractInterface, PairContractVersion)
+from utils.contract_data_fetchers import PairContractDataFetcher
 from utils.logger import get_logger
 from utils.utils_tx import NetworkProviders, endpoint_call, upgrade_call, deploy, ESDTToken, multi_esdt_endpoint_call
 from utils.utils_generic import log_step_fail, log_step_pass, log_substep, log_unexpected_args
-from utils.utils_chain import Account, WrapperAddress as Address
+from utils.utils_chain import Account, WrapperAddress as Address, hex_to_string
 from multiversx_sdk import CodeMetadata, ProxyNetworkProvider
 
 
@@ -79,6 +81,18 @@ def load_config_dict(cls, config_dict: dict):
                             address=config_dict['address'],
                             version=PairContractVersion(config_dict['version']))
 
+    @classmethod
+    def load_contract_by_address(cls, address: str, version=PairContractVersion.V2, proxy_contract=None):
+        data_fetcher = PairContractDataFetcher(Address(address), config.DEFAULT_PROXY)
+        first_token = hex_to_string(data_fetcher.get_data("getFirstTokenId"))
+        second_token = hex_to_string(data_fetcher.get_data("getSecondTokenId"))
+        lp_token = hex_to_string(data_fetcher.get_data("getLpTokenIdentifier"))
+
+        if not first_token or not second_token:
+            return None
+
+        return PairContract(first_token, second_token, version, lp_token, address, proxy_contract)
+
     def hasProxy(self) -> bool:
         if self.proxy_contract is not None:
             return True

contracts/position_creator_contract.py

@@ -33,6 +33,10 @@ def get_config_dict(self) -> dict:
     def load_config_dict(cls, config_dict: dict):
         return PositionCreatorContract(address=config_dict['address'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        return PositionCreatorContract(address)
+
     def contract_deploy(
             self,
             deployer: Account,

contracts/price_discovery_contract.py

@@ -97,6 +97,10 @@ def load_config_dict(cls, config_dict: dict):
                                       max_penalty_percentage=config_dict['max_penalty_percentage'],
                                       fixed_penalty_percentage=config_dict['fixed_penalty_percentage'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def deposit_liquidity(self, network_provider: NetworkProviders, user: Account, event: DepositPDLiquidityEvent) -> str:
         function_purpose = f"Deposit Price Discovery liquidity"
         logger.info(function_purpose)

contracts/proxy_deployer_contract.py

@@ -32,6 +32,10 @@ def load_config_dict(cls, config_dict: dict):
         return ProxyDeployerContract(address=config_dict['address'],
                                      template_name=config_dict['template'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list):
         """Expecting as args:
         type[str]: template sc address

contracts/router_contract.py

@@ -27,6 +27,10 @@ def load_config_dict(cls, config_dict: dict):
         return RouterContract(address=config_dict['address'],
                               version=RouterContractVersion(config_dict['version']))
 
+    @classmethod
+    def load_contract_by_address(cls, address: str, version=RouterContractVersion.V2):
+        return RouterContract(version, address)
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list):
         """Expecting as args:
         type[str]: pair template address

contracts/simple_lock_contract.py

@@ -33,6 +33,10 @@ def load_config_dict(cls, config_dict: dict):
                                   lp_proxy_token=config_dict['lp_proxy_token'],
                                   farm_proxy_token=config_dict.get('farm_proxy_token'))
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        raise NotImplementedError
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list = []):
         function_purpose = f"Deploy simple lock contract"
         logger.info(function_purpose)

contracts/simple_lock_energy_contract.py

@@ -6,9 +6,11 @@
 from utils.logger import get_logger
 from utils.utils_tx import multi_esdt_endpoint_call, endpoint_call, deploy, upgrade_call
 from utils.utils_generic import log_step_pass, log_substep, log_unexpected_args
-from utils.utils_chain import Account, WrapperAddress as Address, decode_merged_attributes
+from utils.utils_chain import Account, WrapperAddress as Address, decode_merged_attributes, hex_to_string
 from multiversx_sdk import CodeMetadata, ProxyNetworkProvider
 
+import config
+
 
 logger = get_logger(__name__)
 
@@ -40,6 +42,14 @@ def load_config_dict(cls, config_dict: dict):
                                         lp_proxy_token=config_dict['lp_proxy_token'],
                                         farm_proxy_token=config_dict['farm_proxy_token'])
 
+    @classmethod
+    def load_contract_by_address(cls, address: str):
+        data_fetcher = SimpleLockEnergyContractDataFetcher(Address(address), config.DEFAULT_PROXY)
+        base_token = hex_to_string(data_fetcher.get_data("getBaseAssetTokenId"))
+        locked_token = hex_to_string(data_fetcher.get_data("getLockedTokenId"))
+
+        return SimpleLockEnergyContract(base_token, locked_token, address)
+
     def contract_deploy(self, deployer: Account, proxy: ProxyNetworkProvider, bytecode_path, args: list):
         """Expecting as args:
                     type[str]: legacy token id