defi-state-querier 0.0.6__py3-none-any.whl → 0.0.9__py3-none-any.whl

defi_services/services/lending/morpho_compound_services.py

@@ -0,0 +1,233 @@
+import logging
+import time
+
+from web3 import Web3
+
+from defi_services.abis.lending.cream.cream_comptroller_abi import CREAM_COMPTROLLER_ABI
+from defi_services.abis.lending.cream.cream_lens_abi import CREAM_LENS_ABI
+from defi_services.abis.lending.morpho.morpho_compound_comptroller_abi import MORPHO_COMPOUND_COMPTROLLER_ABI
+from defi_services.abis.lending.morpho.morpho_compound_lens_abi import MORPHO_COMPOUND_LENS_ABI
+from defi_services.abis.token.erc20_abi import ERC20_ABI
+from defi_services.constants.chain_constant import Chain
+from defi_services.constants.entities.lending_constant import Lending
+from defi_services.constants.query_constant import Query
+from defi_services.constants.token_constant import ContractAddresses, Token
+from defi_services.jobs.queriers.state_querier import StateQuerier
+from defi_services.services.lending.compound_service import CompoundInfo
+from defi_services.services.lending.lending_info.ethereum.morpho_compound_eth import MORPHO_COMPOUND_ETH
+from defi_services.services.protocol_services import ProtocolServices
+
+logger = logging.getLogger("Compound Lending Pool State Service")
+
+
+class MorphoCompoundInfo:
+    mapping = {
+        Chain.ethereum: MORPHO_COMPOUND_ETH
+    }
+
+
+class MorphoCompoundServices(ProtocolServices):
+    def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
+        self.name = f"{chain_id}_{Lending.morpho_compound}"
+        self.chain_id = chain_id
+        self.compound_info = CompoundInfo.mapping.get(chain_id)
+        self.pool_info = MorphoCompoundInfo.mapping.get(chain_id)
+        self.state_service = state_service
+        self.compound_lens_abi = CREAM_LENS_ABI
+        self.compound_comptroller_abi = CREAM_COMPTROLLER_ABI
+        self.lens_abi = MORPHO_COMPOUND_LENS_ABI
+        self.comptroller_abi = MORPHO_COMPOUND_COMPTROLLER_ABI
+        self.market_key = 'cToken'
+
+    # BASIC FUNCTIONS
+    def get_service_info(self):
+        info = {
+            Lending.morpho_compound: {
+                "chain_id": self.chain_id,
+                "type": "lending",
+                "protocol_info": self.pool_info
+            }
+        }
+        return info
+
+    def get_dapp_asset_info(
+            self,
+            block_number: int = "latest"):
+        _w3 = self.state_service.get_w3()
+        comptroller_contract = _w3.eth.contract(
+            address=_w3.toChecksumAddress(self.pool_info.get("comptrollerAddress")), abi=self.comptroller_abi)
+        ctokens = []
+        for token in comptroller_contract.functions.getAllMarkets().call(block_identifier=block_number):
+            if token in [ContractAddresses.LUNA.lower(), ContractAddresses.UST.lower(), ContractAddresses.LUNA,
+                         ContractAddresses.UST]:
+                continue
+            ctokens.append(token)
+
+        compound_lens_contract = _w3.eth.contract(
+            address=Web3.toChecksumAddress(self.compound_info.get("lensAddress")), abi=self.compound_lens_abi
+        )
+        tokens = [Web3.toChecksumAddress(i) for i in ctokens]
+        metadata = compound_lens_contract.functions.cTokenMetadataAll(tokens).call(block_identifier=block_number)
+        reserves_info = {}
+        for data in metadata:
+            underlying = data[11].lower()
+            ctoken = data[0].lower()
+            lt = data[10] / 10 ** 18
+            reserves_info[underlying] = {
+                "cToken": ctoken,
+                "liquidationThreshold": lt
+            }
+
+        return reserves_info
+
+    def get_token_list(self):
+        begin = time.time()
+        tokens = [self.pool_info.get('rewardToken'), self.pool_info.get("poolToken")]
+        for token in self.pool_info.get("reservesList"):
+            if token == Token.native_token:
+                tokens.append(Token.wrapped_token.get(self.chain_id))
+                continue
+            tokens.append(token)
+        logger.info(f"Get token list related in {time.time() - begin}s")
+        return tokens
+
+    def get_data(
+            self,
+            query_types: list,
+            wallet: str,
+            decoded_data: dict,
+            block_number: int = 'latest',
+            **kwargs
+    ):
+        begin = time.time()
+        reserves_info = kwargs.get("reserves_info", self.pool_info.get("reservesList"))
+        token_prices = kwargs.get("token_prices", {})
+        result = {}
+        if Query.deposit_borrow in query_types and wallet:
+            result.update(self.calculate_wallet_deposit_borrow_balance(
+                wallet, reserves_info, decoded_data, token_prices, block_number
+            ))
+
+        if Query.protocol_reward in query_types and wallet:
+            result.update(self.calculate_claimable_rewards_balance(
+                wallet, decoded_data, block_number
+            ))
+        logger.info(f"Process protocol data in {time.time() - begin}")
+        return result
+
+    def get_function_info(
+            self,
+            query_types: list,
+            wallet: str = None,
+            block_number: int = "latest",
+            **kwargs
+    ):
+        begin = time.time()
+        reserves_info = kwargs.get("reserves_info", {})
+        if not reserves_info:
+            reserves_info = self.pool_info['reservesList']
+        rpc_calls = {}
+        if Query.deposit_borrow in query_types and wallet:
+            rpc_calls.update(self.get_wallet_deposit_borrow_balance_function_info(
+                wallet, reserves_info, block_number
+            ))
+
+        if Query.protocol_reward in query_types and wallet:
+            rpc_calls.update(self.get_claimable_rewards_balance_function_info(wallet, block_number))
+
+        logger.info(f"Get encoded rpc calls in {time.time() - begin}s")
+        return rpc_calls
+
+    # REWARDS BALANCE
+    def get_claimable_rewards_balance_function_info(
+            self,
+            wallet_address: str,
+            block_number: int = "latest",
+    ):
+        reserves_info = self.pool_info.get("reservesList")
+        params = [
+            [Web3.toChecksumAddress(value.get(self.market_key)) for key, value in reserves_info.items()],
+            Web3.toChecksumAddress(wallet_address)
+        ]
+        rpc_call = self.get_lens_function_info("getUserUnclaimedRewards", params, block_number)
+        get_reward_id = f"getUserUnclaimedRewards_{self.name}_{wallet_address}_{block_number}".lower()
+        return {get_reward_id: rpc_call}
+
+    def calculate_claimable_rewards_balance(self, wallet_address: str, decoded_data: dict,
+                                            block_number: int = "latest"):
+        get_reward_id = f"getUserUnclaimedRewards_{self.name}_{wallet_address}_{block_number}".lower()
+        rewards = decoded_data.get(get_reward_id) / 10 ** 18
+        reward_token = self.pool_info.get("rewardToken")
+        result = {
+            reward_token: {"amount": rewards}
+        }
+        return result
+
+    # WALLET DEPOSIT BORROW BALANCE
+    def get_wallet_deposit_borrow_balance_function_info(
+            self,
+            wallet_address: str,
+            reserves_info: dict,
+            block_number: int = "latest"
+    ):
+
+        rpc_calls = {}
+        for token, value in reserves_info.items():
+            underlying = token
+            ctoken = value.get(self.market_key)
+            if token == Token.native_token:
+                underlying = Token.wrapped_token.get(self.chain_id)
+            underlying_borrow_key = f"getCurrentBorrowBalanceInOf_{self.name}_{ctoken}_{wallet_address}_{block_number}".lower()
+            underlying_balance_key = f"getCurrentSupplyBalanceInOf_{self.name}_{ctoken}_{wallet_address}_{block_number}".lower()
+            underlying_decimals_key = f"decimals_{underlying}_{block_number}".lower()
+            rpc_calls[underlying_borrow_key] = self.get_lens_function_info(
+                "getCurrentBorrowBalanceInOf", [ctoken, wallet_address], block_number)
+            rpc_calls[underlying_balance_key] = self.get_lens_function_info(
+                "getCurrentSupplyBalanceInOf", [ctoken, wallet_address], block_number)
+            rpc_calls[underlying_decimals_key] = self.state_service.get_function_info(
+                underlying, ERC20_ABI, "decimals", [], block_number
+            )
+
+        return rpc_calls
+
+    def calculate_wallet_deposit_borrow_balance(
+            self, wallet_address: str, reserves_info: dict, decoded_data: dict, token_prices: dict = None,
+            block_number: int = "latest"):
+        if token_prices is None:
+            token_prices = {}
+        result = {}
+        for token, value in reserves_info.items():
+            underlying = token
+            ctoken = value.get(self.market_key)
+            if token == Token.native_token:
+                underlying = Token.wrapped_token.get(self.chain_id)
+            get_total_deposit_id = f"getCurrentSupplyBalanceInOf_{self.name}_{ctoken}_{wallet_address}_{block_number}".lower()
+            get_total_borrow_id = f"getCurrentBorrowBalanceInOf_{self.name}_{ctoken}_{wallet_address}_{block_number}".lower()
+            get_decimals_id = f"decimals_{underlying}_{block_number}".lower()
+            decimals = decoded_data[get_decimals_id]
+            deposit_amount = decoded_data[get_total_deposit_id][-1] / 10 ** decimals
+            borrow_amount = decoded_data[get_total_borrow_id][-1] / 10 ** decimals
+            result[token] = {
+                "borrow_amount": borrow_amount,
+                "deposit_amount": deposit_amount,
+            }
+            if token_prices:
+                token_price = token_prices.get(underlying)
+            else:
+                token_price = None
+            if token_price is not None:
+                deposit_amount_in_usd = deposit_amount * token_price
+                borrow_amount_in_usd = borrow_amount * token_price
+                result[token]['borrow_amount_in_usd'] += borrow_amount_in_usd
+                result[token]['deposit_amount_in_usd'] += deposit_amount_in_usd
+        return result
+
+    def get_lens_function_info(self, fn_name: str, fn_paras: list, block_number: int = "latest"):
+        return self.state_service.get_function_info(
+            self.pool_info['lensAddress'], self.lens_abi, fn_name, fn_paras, block_number
+        )
+
+    def get_comptroller_function_info(self, fn_name: str, fn_paras: list, block_number: int = "latest"):
+        return self.state_service.get_function_info(
+            self.pool_info['comptrollerAddress'], self.comptroller_abi, fn_name, fn_paras, block_number
+        )

defi_services/services/lending/onyx_service.py

@@ -3,17 +3,16 @@ import time
 
 from web3 import Web3
 
+from defi_services.abis.lending.onyx.onyx_comptroller_abi import ONYX_COMPTROLLER_ABI
 from defi_services.abis.lending.onyx.onyx_lens_abi import ONYX_LENS_ABI
 from defi_services.abis.lending.onyx.onyx_token_abi import ONYX_TOKEN_ABI
-from defi_services.abis.token.ctoken_abi import CTOKEN_ABI
 from defi_services.abis.token.erc20_abi import ERC20_ABI
 from defi_services.constants.chain_constant import Chain
-from defi_services.constants.db_constant import DBConst
+from defi_services.constants.entities.lending_constant import Lending
 from defi_services.constants.query_constant import Query
 from defi_services.constants.token_constant import ContractAddresses, Token
-from defi_services.jobs.state_querier import StateQuerier
+from defi_services.jobs.queriers.state_querier import StateQuerier
 from defi_services.services.lending.lending_info.ethereum.onyx_eth import ONYX_ETH
-from defi_services.abis.lending.onyx.onyx_comptroller_abi import ONYX_COMPTROLLER_ABI
 from defi_services.services.protocol_services import ProtocolServices
 
 logger = logging.getLogger("Onyx Lending Pool State Service")
@@ -27,7 +26,7 @@ class OnyxInfo:
 
 class OnyxStateService(ProtocolServices):
     def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
-        self.name = f"{chain_id}_onyx-protocol"
+        self.name = f"{chain_id}_{Lending.onyx}"
         self.chain_id = chain_id
         self.pool_info = OnyxInfo.mapping.get(chain_id)
         self.state_service = state_service
@@ -38,7 +37,7 @@ class OnyxStateService(ProtocolServices):
     # BASIC FUNCTIONS
     def get_service_info(self):
         info = {
-            "onyx-protocol": {
+            Lending.onyx: {
                 "chain_id": self.chain_id,
                 "type": "lending",
                 "protocol_info": self.pool_info
@@ -106,7 +105,7 @@ class OnyxStateService(ProtocolServices):
             ))
 
         if Query.protocol_reward in query_types and wallet:
-            result.update(self.calculate_rewards_balance(
+            result.update(self.calculate_claimable_rewards_balance(
                 wallet, decoded_data, block_number
             ))
 
@@ -132,12 +131,31 @@ class OnyxStateService(ProtocolServices):
             ))
 
         if Query.protocol_reward in query_types and wallet:
-            rpc_calls.update(self.get_rewards_balance_function_info(wallet, block_number))
+            rpc_calls.update(self.get_claimable_rewards_balance_function_info(wallet, block_number))
 
         logger.info(f"Get encoded rpc calls in {time.time() - begin}s")
         return rpc_calls
 
     # REWARDS BALANCE
+    def get_claimable_rewards_balance_function_info(
+            self,
+            wallet_address: str,
+            block_number: int = "latest",
+    ):
+        rpc_call = self.get_comptroller_function_info("xcnAccrued", [wallet_address], block_number)
+        get_reward_id = f"xcnAccrued_{self.name}_{wallet_address}_{block_number}".lower()
+        return {get_reward_id: rpc_call}
+
+    def calculate_claimable_rewards_balance(self, wallet_address: str, decoded_data: dict,
+                                            block_number: int = "latest"):
+        get_reward_id = f"xcnAccrued_{self.name}_{wallet_address}_{block_number}".lower()
+        rewards = decoded_data.get(get_reward_id) / 10 ** 18
+        reward_token = self.pool_info.get("rewardToken")
+        result = {
+            reward_token: {"amount": rewards}
+        }
+        return result
+
     def get_rewards_balance_function_info(
             self,
             wallet_address: str,
@@ -148,11 +166,11 @@ class OnyxStateService(ProtocolServices):
                     Web3.toChecksumAddress(self.pool_info.get("comptrollerAddress")),
                     Web3.toChecksumAddress(wallet_address)]
         rpc_call = self.get_lens_function_info("getXcnBalanceMetadataExt", fn_paras, block_number)
-        get_reward_id = f"getXcnBalanceMetadataExt_{wallet_address}_{block_number}".lower()
+        get_reward_id = f"getXcnBalanceMetadataExt_{self.name}_{wallet_address}_{block_number}".lower()
         return {get_reward_id: rpc_call}
 
     def calculate_rewards_balance(self, wallet_address: str, decoded_data: dict, block_number: int = "latest"):
-        get_reward_id = f"getXcnBalanceMetadataExt_{wallet_address}_{block_number}".lower()
+        get_reward_id = f"getXcnBalanceMetadataExt_{self.name}_{wallet_address}_{block_number}".lower()
         rewards = decoded_data.get(get_reward_id)[-1] / 10 ** 18
         reward_token = self.pool_info.get("rewardToken")
         result = {
@@ -184,8 +202,9 @@ class OnyxStateService(ProtocolServices):
             rpc_calls[underlying_decimals_key] = self.state_service.get_function_info(
                 underlying, ERC20_ABI, "decimals", [], block_number
             )
-        key = f"oTokenBalancesAll_{wallet_address}_{block_number}".lower()
-        rpc_calls[key] = self.get_lens_function_info("oTokenBalancesAll", [ctokens, Web3.toChecksumAddress(wallet_address)])
+        key = f"oTokenBalancesAll_{self.name}_{wallet_address}_{block_number}".lower()
+        rpc_calls[key] = self.get_lens_function_info("oTokenBalancesAll",
+                                                     [ctokens, Web3.toChecksumAddress(wallet_address)])
         return rpc_calls
 
     def calculate_wallet_deposit_borrow_balance(
@@ -194,7 +213,7 @@ class OnyxStateService(ProtocolServices):
         if token_prices is None:
             token_prices = {}
         result = {}
-        key = f"oTokenBalancesAll_{wallet_address}_{block_number}".lower()
+        key = f"oTokenBalancesAll_{self.name}_{wallet_address}_{block_number}".lower()
         ctoken_balance = {}
         for item in decoded_data.get(key):
             ctoken_balance[item[0]] = {

defi_services/services/lending/radiant_v2_services.py

@@ -1,7 +1,9 @@
 import logging
 
+from defi_services.abis.lending.radiant_v2.radiant_v2_incentive_abi import RADIANT_V2_INCENTIVE_ABI
 from defi_services.constants.chain_constant import Chain
-from defi_services.jobs.state_querier import StateQuerier
+from defi_services.constants.entities.lending_constant import Lending
+from defi_services.jobs.queriers.state_querier import StateQuerier
 from defi_services.services.lending.lending_info.arbitrum.radiant_arbitrum import RADIANT_ARB
 from defi_services.services.lending.lending_info.bsc.radiant_bsc import RADIANT_BSC
 from defi_services.services.lending.valas_services import ValasStateService
@@ -19,15 +21,40 @@ class RadiantInfo:
 class RadiantStateService(ValasStateService):
     def __init__(self, state_service: StateQuerier, chain_id: str = "0xa4b1"):
         super().__init__(state_service, chain_id)
-        self.name = f"{chain_id}_radiant-v2"
+        self.name = f"{chain_id}_{Lending.radiant_v2}"
         self.pool_info = RadiantInfo.mapping.get(chain_id)
+        self.incentive_abi = RADIANT_V2_INCENTIVE_ABI
 
     def get_service_info(self):
         info = {
-            "radiant-v2": {
+            Lending.radiant_v2: {
                 "chain_id": self.chain_id,
                 "type": "lending",
                 "protocol_info": self.pool_info
             }
         }
         return info
+
+    # REWARDS BALANCE
+    def get_all_rewards_balance_function_info(
+            self,
+            wallet_address,
+            block_number: int = "latest"
+    ):
+        rpc_calls = {}
+        key = f"allPendingRewards_{self.name}_{wallet_address}_{block_number}".lower()
+        rpc_calls[key] = self.get_function_incentive_info(
+            "allPendingRewards", [wallet_address], block_number)
+
+        return rpc_calls
+
+    def calculate_all_rewards_balance(
+            self, decoded_data: dict, wallet_address: str, block_number: int = "latest"):
+        reward_token = self.pool_info['rewardToken']
+        key = f"allPendingRewards_{self.name}_{wallet_address}_{block_number}".lower()
+        rewards = decoded_data.get(key) / 10 ** 18
+        result = {
+            reward_token: {"amount": rewards}
+        }
+
+        return result

defi_services/services/lending/strike_service.py

@@ -8,10 +8,10 @@ from defi_services.abis.lending.strike.strike_lens_abi import STRIKE_LENS_ABI
 from defi_services.abis.token.ctoken_abi import CTOKEN_ABI
 from defi_services.abis.token.erc20_abi import ERC20_ABI
 from defi_services.constants.chain_constant import Chain
-from defi_services.constants.db_constant import DBConst
+from defi_services.constants.entities.lending_constant import Lending
 from defi_services.constants.query_constant import Query
 from defi_services.constants.token_constant import ContractAddresses, Token
-from defi_services.jobs.state_querier import StateQuerier
+from defi_services.jobs.queriers.state_querier import StateQuerier
 from defi_services.services.lending.lending_info.ethereum.strike_eth import STRIKE_ETH
 from defi_services.services.protocol_services import ProtocolServices
 
@@ -26,7 +26,7 @@ class StrikeInfo:
 
 class StrikeStateService(ProtocolServices):
     def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
-        self.name = f"{chain_id}_strike"
+        self.name = f"{chain_id}_{Lending.strike}"
         self.chain_id = chain_id
         self.pool_info = StrikeInfo.mapping.get(chain_id)
         self.state_service = state_service
@@ -36,7 +36,7 @@ class StrikeStateService(ProtocolServices):
     # BASIC FUNCTIONS
     def get_service_info(self):
         info = {
-            "strike": {
+            Lending.strike: {
                 "chain_id": self.chain_id,
                 "type": "lending",
                 "protocol_info": self.pool_info
@@ -105,7 +105,7 @@ class StrikeStateService(ProtocolServices):
             ))
 
         if Query.protocol_reward in query_types and wallet:
-            result.update(self.calculate_rewards_balance(
+            result.update(self.calculate_claimable_rewards_balance(
                 wallet, decoded_data, block_number
             ))
 
@@ -130,16 +130,35 @@ class StrikeStateService(ProtocolServices):
                 wallet, reserves_info, block_number, is_oracle_price
             ))
 
-        if Query.protocol_apy in query_types:
-            rpc_calls.update(self.get_apy_lending_pool_function_info(reserves_info, block_number, is_oracle_price))
+        # if Query.protocol_apy in query_types:
+        #     rpc_calls.update(self.get_apy_lending_pool_function_info(reserves_info, block_number, is_oracle_price))
 
         if Query.protocol_reward in query_types and wallet:
-            rpc_calls.update(self.get_rewards_balance_function_info(wallet, block_number))
+            rpc_calls.update(self.get_claimable_rewards_balance_function_info(wallet, block_number))
 
         logger.info(f"Get encoded rpc calls in {time.time() - begin}s")
         return rpc_calls
 
     # REWARDS BALANCE
+    def get_claimable_rewards_balance_function_info(
+            self,
+            wallet_address: str,
+            block_number: int = "latest",
+    ):
+        rpc_call = self.get_comptroller_function_info("strikeAccrued", [wallet_address], block_number)
+        get_reward_id = f"strikeAccrued_{self.name}_{wallet_address}_{block_number}".lower()
+        return {get_reward_id: rpc_call}
+
+    def calculate_claimable_rewards_balance(self, wallet_address: str, decoded_data: dict,
+                                            block_number: int = "latest"):
+        get_reward_id = f"strikeAccrued_{self.name}_{wallet_address}_{block_number}".lower()
+        rewards = decoded_data.get(get_reward_id) / 10 ** 18
+        reward_token = self.pool_info.get("rewardToken")
+        result = {
+            reward_token: {"amount": rewards}
+        }
+        return result
+
     def get_rewards_balance_function_info(
             self,
             wallet_address: str,
@@ -150,11 +169,11 @@ class StrikeStateService(ProtocolServices):
                     Web3.toChecksumAddress(self.pool_info.get("comptrollerAddress")),
                     Web3.toChecksumAddress(wallet_address)]
         rpc_call = self.get_lens_function_info("getStrikeBalanceMetadataExt", fn_paras, block_number)
-        get_reward_id = f"getStrikeBalanceMetadataExt_{wallet_address}_{block_number}".lower()
+        get_reward_id = f"getStrikeBalanceMetadataExt_{self.name}_{wallet_address}_{block_number}".lower()
         return {get_reward_id: rpc_call}
 
     def calculate_rewards_balance(self, wallet_address: str, decoded_data: dict, block_number: int = "latest"):
-        get_reward_id = f"getStrikeBalanceMetadataExt_{wallet_address}_{block_number}".lower()
+        get_reward_id = f"getStrikeBalanceMetadataExt_{self.name}_{wallet_address}_{block_number}".lower()
         rewards = decoded_data.get(get_reward_id)[-1] / 10 ** 18
         reward_token = self.pool_info.get("rewardToken")
         result = {

defi_services/services/lending/trava_services.py

@@ -9,10 +9,11 @@ from defi_services.abis.lending.trava.trava_lending_pool_abi import TRAVA_LENDIN
 from defi_services.abis.token.erc20_abi import ERC20_ABI
 from defi_services.constants.chain_constant import Chain
 from defi_services.constants.db_constant import DBConst
+from defi_services.constants.entities.lending_constant import Lending
 from defi_services.constants.query_constant import Query
 from defi_services.constants.time_constant import TimeConstants
 from defi_services.constants.token_constant import Token
-from defi_services.jobs.state_querier import StateQuerier
+from defi_services.jobs.queriers.state_querier import StateQuerier
 from defi_services.services.lending.lending_info.bsc.trava_bsc import TRAVA_BSC
 from defi_services.services.lending.lending_info.ethereum.trava_eth import TRAVA_ETH
 from defi_services.services.lending.lending_info.fantom.trava_ftm import TRAVA_FTM
@@ -31,7 +32,7 @@ class TravaInfo:
 
 class TravaStateService(ProtocolServices):
     def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
-        self.name = f"{chain_id}_trava-finance"
+        self.name = f"{chain_id}_{Lending.trava}"
         self.chain_id = chain_id
         self.pool_info = TravaInfo.mapping.get(chain_id)
         self.lending_abi = TRAVA_LENDING_POOL_ABI
@@ -42,7 +43,7 @@ class TravaStateService(ProtocolServices):
     # BASIC FUNCTION
     def get_service_info(self):
         info = {
-            "trava-finance": {
+            Lending.trava: {
                 "chain_id": self.chain_id,
                 "type": "lending",
                 "protocol_info": self.pool_info
@@ -150,7 +151,7 @@ class TravaStateService(ProtocolServices):
                 "getAssetsPrices", list(reserves_info.keys()), block_number)
 
         for token_address, value in reserves_info.items():
-            reserve_key = f"getReserveData_{token_address}_{block_number}".lower()
+            reserve_key = f"getReserveData_{self.name}_{token_address}_{block_number}".lower()
             atoken_assets_key = f"assets_{value['tToken']}_{block_number}".lower()
             debt_token_assets_key = f"assets_{value['dToken']}_{block_number}".lower()
             atoken_total_supply_key = f'totalSupply_{value["tToken"]}_{block_number}'.lower()
@@ -236,7 +237,7 @@ class TravaStateService(ProtocolServices):
     ):
         reserves_data = {}
         for token in reserves_info:
-            get_reserve_data_call_id = f'getReserveData_{token}_{block_number}'.lower()
+            get_reserve_data_call_id = f'getReserveData_{self.name}_{token}_{block_number}'.lower()
             reserves_data[token.lower()] = decoded_data.get(get_reserve_data_call_id)
 
         interest_rate, atokens, debt_tokens, decimals, asset_data_tokens = {}, {}, {}, {}, {}
@@ -378,7 +379,7 @@ class TravaStateService(ProtocolServices):
         for token, value in reserves_info.items():
             atoken, debt_token = Web3.toChecksumAddress(value['tToken']), Web3.toChecksumAddress(value['dToken'])
             tokens += [atoken, debt_token]
-        key = f"getRewardsBalance_{wallet_address}_{block_number}".lower()
+        key = f"getRewardsBalance_{self.name}_{wallet_address}_{block_number}".lower()
         rpc_calls[key] = self.get_function_incentive_info(
             "getRewardsBalance", [tokens, wallet_address], block_number)
 
@@ -387,7 +388,7 @@ class TravaStateService(ProtocolServices):
     def calculate_all_rewards_balance(
             self, decoded_data: dict, wallet_address: str, block_number: int = "latest"):
         reward_token = self.pool_info['rewardToken']
-        key = f"getRewardsBalance_{wallet_address}_{block_number}".lower()
+        key = f"getRewardsBalance_{self.name}_{wallet_address}_{block_number}".lower()
         rewards = decoded_data.get(key) / 10 ** 18
         result = {
             reward_token: {"amount": rewards}

defi_services/services/lending/uwu_services.py

@@ -8,10 +8,11 @@ from defi_services.abis.lending.aave_v2_and_forlks.oracle_abi import ORACLE_ABI
 from defi_services.abis.token.erc20_abi import ERC20_ABI
 from defi_services.constants.chain_constant import Chain
 from defi_services.constants.db_constant import DBConst
+from defi_services.constants.entities.lending_constant import Lending
 from defi_services.constants.query_constant import Query
 from defi_services.constants.time_constant import TimeConstants
 from defi_services.constants.token_constant import Token
-from defi_services.jobs.state_querier import StateQuerier
+from defi_services.jobs.queriers.state_querier import StateQuerier
 from defi_services.services.lending.lending_info.ethereum.uwu_eth import UWU_ETH
 from defi_services.services.protocol_services import ProtocolServices
 
@@ -26,7 +27,7 @@ class UwuInfo:
 
 class UwuStateService(ProtocolServices):
     def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
-        self.name = f"{chain_id}_uwu-lend"
+        self.name = f"{chain_id}_{Lending.uwu}"
         self.chain_id = chain_id
         self.uwu_info = UwuInfo.mapping.get(chain_id)
         self.lending_abi = LENDING_POOL_ABI
@@ -37,7 +38,7 @@ class UwuStateService(ProtocolServices):
     # BASIC FUNCTION
     def get_service_info(self):
         info = {
-            "uwu-lend": {
+            Lending.uwu: {
                 "chain_id": self.chain_id,
                 "type": "lending",
                 "protocol_info": self.uwu_info
@@ -150,7 +151,7 @@ class UwuStateService(ProtocolServices):
                 "getAssetsPrices", list(reserves_info.keys()), block_number)
 
         for token_address, value in reserves_info.items():
-            reserve_key = f"getReserveData_{token_address}_{block_number}".lower()
+            reserve_key = f"getReserveData_{self.name}_{token_address}_{block_number}".lower()
             atoken_assets_key = f"assets_{value['tToken']}_{block_number}".lower()
             debt_token_assets_key = f"assets_{value['dToken']}_{block_number}".lower()
             # sdebt_token_assets_key = f"assets_{value['sdToken']}_{block_number}".lower()
@@ -250,7 +251,7 @@ class UwuStateService(ProtocolServices):
     ):
         reserves_data = {}
         for token in reserves_info:
-            get_reserve_data_call_id = f'getReserveData_{token}_{block_number}'.lower()
+            get_reserve_data_call_id = f'getReserveData_{self.name}_{token}_{block_number}'.lower()
             reserves_data[token.lower()] = decoded_data.get(get_reserve_data_call_id)
 
         interest_rate, atokens, debt_tokens, sdebt_tokens, decimals, asset_data_tokens = {}, {}, {}, {}, {}, {}
@@ -412,7 +413,7 @@ class UwuStateService(ProtocolServices):
         for token, value in reserves_info.items():
             atoken, debt_token = Web3.toChecksumAddress(value['tToken']), Web3.toChecksumAddress(value['dToken'])
             tokens += [atoken, debt_token]
-        key = f"claimableReward_{wallet_address}_{block_number}".lower()
+        key = f"claimableReward_{self.name}_{wallet_address}_{block_number}".lower()
         rpc_calls[key] = self.get_function_incentive_info(
             "claimableReward", [wallet_address, tokens], block_number)
 
@@ -421,7 +422,7 @@ class UwuStateService(ProtocolServices):
     def calculate_all_rewards_balance(
             self, decoded_data: dict, wallet_address: str, block_number: int = "latest"):
         reward_token = self.uwu_info['rewardToken']
-        key = f"claimableReward_{wallet_address}_{block_number}".lower()
+        key = f"claimableReward_{self.name}_{wallet_address}_{block_number}".lower()
         rewards = sum(decoded_data.get(key))/ 10 ** 18
         result = {
             reward_token: {"amount": rewards}