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

defi_services/constants/chain_constant.py

@@ -1,4 +1,5 @@
 class Chain:
+    solana = "solana"
     bsc = "0x38"
     ethereum = "0x1"
     fantom = "0xfa"

defi_services/constants/entities/lending_constant.py

@@ -0,0 +1,26 @@
+class Lending:
+    # service
+    aave_v2 = "aave-v2"
+    aave_v3 = "aave-v3"
+    radiant_v2 = "radiant-v2"
+    compound = "compound"
+    flux = "flux-finance"
+    iron_bank = "iron-bank"
+    trava = "trava-finance"
+    valas = "valas-finance"
+    geist = "geist-finance"
+    cream = "cream-lending"
+    venus = "venus"
+    liqee = "liqee"
+    strike = "strike"
+    uwu = "uwu-lend"
+    onyx = "onyx-protocol"
+    granary = "granary-finance"
+    wepiggy = "wepiggy"
+    morpho_compound = 'morpho-compound'
+    morpho_aave_v2 = 'morpho-aave'
+    morpho_aave_v3 = 'morpho-aavev3'
+    all = [strike, aave_v2, aave_v3, radiant_v2, compound, flux, onyx, granary,
+           iron_bank, trava, valas, geist, cream, venus, liqee, strike, uwu, wepiggy,
+           morpho_compound, morpho_aave_v2, morpho_aave_v3
+           ]

defi_services/constants/entities/lending_services.py

@@ -0,0 +1,85 @@
+from defi_services.constants.chain_constant import Chain
+from defi_services.constants.entities.lending_constant import Lending
+from defi_services.services.lending.aave_v2_services import AaveV2StateService
+from defi_services.services.lending.granary_v1_services import GranaryV1StateService
+from defi_services.services.lending.morpho_aave_v2_services import MorphoAaveV2Services
+from defi_services.services.lending.morpho_aave_v3_services import MorphoAaveV3Services
+from defi_services.services.lending.morpho_compound_services import MorphoCompoundServices
+from defi_services.services.lending.uwu_services import UwuStateService
+from defi_services.services.lending.aave_v3_services import AaveV3StateService
+from defi_services.services.lending.compound_service import CompoundStateService
+from defi_services.services.lending.cream_services import CreamStateService
+from defi_services.services.lending.geist_services import GeistStateService
+from defi_services.services.lending.radiant_v2_services import RadiantStateService
+from defi_services.services.lending.trava_services import TravaStateService
+from defi_services.services.lending.valas_services import ValasStateService
+from defi_services.services.lending.flux_services import FluxStateService
+from defi_services.services.lending.iron_bank_service import IronBankStateService
+from defi_services.services.lending.venus_services import VenusStateService
+from defi_services.services.lending.liqee_service import LiqeeStateService
+from defi_services.services.lending.strike_service import StrikeStateService
+from defi_services.services.lending.onyx_service import OnyxStateService
+from defi_services.services.lending.wepiggy_services import WepiggyStateService
+
+
+class LendingServices:
+    # chain
+    ethereum = {
+        Lending.aave_v2: AaveV2StateService,
+        Lending.compound: CompoundStateService,
+        Lending.trava: TravaStateService,
+        Lending.flux: FluxStateService,
+        Lending.iron_bank: IronBankStateService,
+        Lending.uwu: UwuStateService,
+        Lending.aave_v3: AaveV3StateService,
+        Lending.liqee: LiqeeStateService,
+        Lending.strike: StrikeStateService,
+        Lending.onyx: OnyxStateService,
+        Lending.granary: GranaryV1StateService,
+        Lending.wepiggy: WepiggyStateService,
+        Lending.morpho_aave_v3: MorphoAaveV3Services,
+        Lending.morpho_aave_v2: MorphoAaveV2Services,
+        Lending.morpho_compound: MorphoCompoundServices
+    }
+    fantom = {
+        Lending.trava: TravaStateService,
+        Lending.geist: GeistStateService,
+        Lending.aave_v3: AaveV3StateService,
+    }
+
+    bsc = {
+        Lending.trava: TravaStateService,
+        Lending.valas: ValasStateService,
+        Lending.cream: CreamStateService,
+        Lending.venus: VenusStateService,
+        Lending.radiant_v2: RadiantStateService
+    }
+
+    avalanche = {
+        Lending.aave_v3: AaveV3StateService,
+        Lending.aave_v2: AaveV2StateService
+    }
+
+    polygon = {
+        Lending.aave_v2: AaveV2StateService,
+        Lending.aave_v3: AaveV3StateService
+    }
+
+    optimism = {
+        Lending.aave_v3: AaveV3StateService
+    }
+
+    arbitrum = {
+        Lending.radiant_v2: RadiantStateService,
+        Lending.aave_v3: AaveV3StateService
+    }
+    # mapping
+    mapping = {
+        Chain.ethereum: ethereum,
+        Chain.fantom: fantom,
+        Chain.bsc: bsc,
+        Chain.avalanche: avalanche,
+        Chain.polygon: polygon,
+        Chain.arbitrum: arbitrum,
+        Chain.optimism: optimism
+    }

defi_services/constants/query_constant.py

@@ -4,6 +4,7 @@ class Query:
     function = "function"
     params = "params"
     block_number = "block_number"
+    module = "module"
 
     # query types
     token_balance = 'token_balance'

defi_services/constants/token_constant.py

@@ -10,7 +10,9 @@ class Token:
     wrapped_eth_optimism = "0x4200000000000000000000000000000000000006"
     wrapped_eth_arbitrum = "0x82af49447d8a07e3bd95bd0d56f35241523fbab1"
     wrapped_matic = '0x0000000000000000000000000000000000001010'
+    wrapped_sol = 'So11111111111111111111111111111111111111112'
     wrapped_token = {
+        Chain.solana: wrapped_sol,
         Chain.ethereum: wrapped_ethereum,
         Chain.bsc: wrapped_bsc,
         Chain.fantom: wrapped_ftm,

defi_services/jobs/processors/solana_state_processor.py

@@ -0,0 +1,101 @@
+import logging
+
+from defi_services.constants.entities.lending_constant import Lending
+from defi_services.constants.entities.lending_services import LendingServices
+from defi_services.constants.query_constant import Query
+from defi_services.database.mongodb import MongoDB
+from defi_services.jobs.queriers.solana_state_querier import SolanaStateQuerier
+from defi_services.services.solana_token_services import SolanaTokenServices
+
+logger = logging.getLogger("SolanaStateProcessor")
+
+
+class SolanaStateProcessor:
+    def __init__(self, provider_uri: str, chain_id: str, mongodb: MongoDB = None):
+        self.mongodb = mongodb
+        self.state_querier = SolanaStateQuerier(provider_uri)
+        self.chain_id = chain_id
+        self.token_service = SolanaTokenServices(self.state_querier, chain_id)
+        self.lending_services = LendingServices.mapping.get(chain_id)
+
+    def get_service_info(self):
+        info = self.token_service.get_service_info()
+        return info
+
+    def get_token_prices(self, tokens):
+        return self.mongodb.get_token_prices(tokens, self.chain_id)
+
+    def init_rpc_call_information(
+            self, wallet: str, query_id: str, entity_id: str, query_type: str):
+        queries = {}
+        tokens = []
+        rpc_calls = {}
+        if entity_id not in Lending.all and query_type in [Query.token_balance, Query.nft_balance]:
+            rpc_calls.update(self.token_service.get_function_info(wallet, entity_id))
+            tokens.append(entity_id)
+
+        queries[entity_id] = rpc_calls
+        tokens = list(set(tokens))
+        return {query_id: queries}, tokens
+
+    def execute_rpc_calls(self, queries: dict, batch_size: int = 100, max_workers: int = 8, ignore_error: bool = False):
+        rpc_calls = {}
+        for query, query_info in queries.items():
+            for entity, entity_value in query_info.items():
+                rpc_calls.update(entity_value)
+
+        decoded_data = self.state_querier.query_state_data(
+            rpc_calls, batch_size=batch_size, workers=max_workers, ignore_error=ignore_error)
+        result = {}
+        for query, query_info in queries.items():
+            query_data = {}
+            for entity, entity_value in query_info.items():
+                entity_data = {}
+                for key, value in entity_value.items():
+                    entity_data[key] = decoded_data.get(key)
+                query_data[entity] = entity_data
+            result[query] = query_data
+
+        return result
+
+    def process_decoded_data(
+            self, query_id: str, query_type: str, wallet: str,
+            token_prices: dict, decoded_data: dict):
+        result = {
+            "query_id": query_id,
+            "query_type": query_type
+        }
+        query_value = decoded_data.get(query_id)
+        for entity, entity_value in query_value.items():
+            result["entity_id"] = entity
+            data = None
+            if entity not in Lending.all and query_type in [Query.nft_balance, Query.token_balance]:
+                data = self.token_service.get_data(wallet, entity, entity_value, token_prices)
+            result[query_type] = data
+
+        return result
+
+    def run(self, wallet: str, queries: list,
+            batch_size: int = 100, max_workers: int = 8, ignore_error=False):
+        all_rpc_calls, all_tokens = {}, []
+        for query in queries:
+            query_id = query.get("query_id")
+            entity_id = query.get("entity_id")
+            query_type = query.get("query_type")
+            rpc_calls, tokens = self.init_rpc_call_information(
+                wallet, query_id, entity_id, query_type)
+            all_rpc_calls.update(rpc_calls)
+            all_tokens += tokens
+        result = []
+        decoded_data = self.execute_rpc_calls(all_rpc_calls, batch_size, max_workers, ignore_error=ignore_error)
+        token_prices = {}
+        if self.mongodb:
+            token_prices = self.get_token_prices(all_tokens)
+        for query in queries:
+            query_id = query.get("query_id")
+            query_type = query.get("query_type")
+            processed_data = self.process_decoded_data(
+                query_id, query_type, wallet, token_prices, decoded_data)
+            result.append(processed_data)
+
+        return result

defi_services/jobs/{state_processor.py → processors/state_processor.py}

@@ -1,14 +1,18 @@
+import logging
+
 from web3 import Web3
 
-from defi_services.constants.entities.lending import Lending
+from defi_services.constants.entities.lending_services import LendingServices
 from defi_services.constants.query_constant import Query
 from defi_services.database.mongodb import MongoDB
-from defi_services.jobs.state_querier import StateQuerier
+from defi_services.jobs.queriers.state_querier import StateQuerier
 from defi_services.services.nft_services import NFTServices
 from defi_services.services.protocol_services import ProtocolServices
 from defi_services.services.token_services import TokenServices
 from defi_services.utils.init_services import init_services
 
+logger = logging.getLogger("StateProcessor")
+
 
 class StateProcessor:
     def __init__(self, provider_uri: str, chain_id: str, mongodb: MongoDB = None):
@@ -18,7 +22,7 @@ class StateProcessor:
         self.services = init_services(self.state_querier, chain_id)
         self.token_service = TokenServices(self.state_querier, chain_id)
         self.nft_service = NFTServices(self.state_querier, chain_id)
-        self.lending_services = Lending.mapping.get(chain_id)
+        self.lending_services = LendingServices.mapping.get(chain_id)
 
     def get_service_info(self):
         info = self.nft_service.get_service_info()
@@ -113,7 +117,8 @@ class StateProcessor:
 
         return result
 
-    def run(self, wallet: str, queries: list, block_number: int = 'latest', batch_size: int = 100, max_workers: int = 8, ignore_error=False):
+    def run(self, wallet: str, queries: list, block_number: int = 'latest',
+            batch_size: int = 100, max_workers: int = 8, ignore_error=False):
         all_rpc_calls, all_tokens = {}, []
         for query in queries:
             query_id = query.get("query_id")

defi_services/jobs/processors/substrate_state_processor.py

@@ -0,0 +1,97 @@
+import logging
+
+from defi_services.constants.entities.lending_constant import Lending
+from defi_services.constants.query_constant import Query
+from defi_services.database.mongodb import MongoDB
+from defi_services.jobs.queriers.substrate_state_querier import SubstrateStateQuerier
+from defi_services.services.substrate_token_services import SubstrateTokenServices
+
+logger = logging.getLogger("SubstrateStateProcessor")
+
+
+class SubstrateStateProcessor:
+    def __init__(self, provider_uri: str, chain_id: str, mongodb: MongoDB = None):
+        self.mongodb = mongodb
+        self.state_querier = SubstrateStateQuerier(provider_uri)
+        self.chain_id = chain_id
+        self.token_service = SubstrateTokenServices(self.state_querier, chain_id)
+
+    def get_service_info(self):
+        info = self.token_service.get_service_info()
+        return info
+
+    def get_token_prices(self, tokens):
+        return self.mongodb.get_token_prices(tokens, self.chain_id)
+
+    def init_rpc_call_information(
+            self, wallet: str, query_id: str, entity_id: str, query_type: str, block_number: int = 'latest'):
+        queries = {}
+        tokens = []
+        rpc_calls = {}
+        if entity_id not in Lending.all and query_type in [Query.token_balance, Query.nft_balance]:
+            rpc_calls.update(self.token_service.get_function_info(wallet, entity_id, block_number))
+            tokens.append(entity_id)
+
+        queries[entity_id] = rpc_calls
+        tokens = list(set(tokens))
+        return {query_id: queries}, tokens
+
+    def execute_rpc_calls(self, queries: dict):
+        rpc_calls = {}
+        for query, query_info in queries.items():
+            for entity, entity_value in query_info.items():
+                rpc_calls.update(entity_value)
+
+        decoded_data = self.state_querier.query_state_data(rpc_calls)
+        result = {}
+        for query, query_info in queries.items():
+            query_data = {}
+            for entity, entity_value in query_info.items():
+                entity_data = {}
+                for key, value in entity_value.items():
+                    entity_data[key] = decoded_data.get(key)
+                query_data[entity] = entity_data
+            result[query] = query_data
+
+        return result
+
+    def process_decoded_data(
+            self, query_id: str, query_type: str, wallet: str,
+            token_prices: dict, decoded_data: dict):
+        result = {
+            "query_id": query_id,
+            "query_type": query_type
+        }
+        query_value = decoded_data.get(query_id)
+        for entity, entity_value in query_value.items():
+            result["entity_id"] = entity
+            data = None
+            if entity not in Lending.all and query_type in [Query.nft_balance, Query.token_balance]:
+                data = self.token_service.get_data(wallet, entity, entity_value, token_prices)
+            result[query_type] = data
+
+        return result
+
+    def run(self, wallet: str, queries: list, block_number: int = 'latest'):
+        all_rpc_calls, all_tokens = {}, []
+        for query in queries:
+            query_id = query.get("query_id")
+            entity_id = query.get("entity_id")
+            query_type = query.get("query_type")
+            rpc_calls, tokens = self.init_rpc_call_information(
+                wallet, query_id, entity_id, query_type, block_number)
+            all_rpc_calls.update(rpc_calls)
+            all_tokens += tokens
+        result = []
+        decoded_data = self.execute_rpc_calls(all_rpc_calls)
+        token_prices = {}
+        if self.mongodb:
+            token_prices = self.get_token_prices(all_tokens)
+        for query in queries:
+            query_id = query.get("query_id")
+            query_type = query.get("query_type")
+            processed_data = self.process_decoded_data(
+                query_id, query_type, wallet, token_prices, decoded_data)
+            result.append(processed_data)
+
+        return result

defi_services/jobs/queriers/solana_state_querier.py

@@ -0,0 +1,83 @@
+import logging
+
+from query_state_lib.base.mappers.eth_json_rpc_mapper import EthJsonRpc
+from query_state_lib.client.client_querier import ClientQuerier
+
+from defi_services.constants.query_constant import Query
+
+logger = logging.getLogger("SolanaStateQuerier")
+
+
+class SolanaStateQuerier:
+    def __init__(self, provider_uri):
+        self.provider_uri = provider_uri
+        self.client_querier = ClientQuerier(provider_url=provider_uri)
+
+    @staticmethod
+    def get_function_info(fn_name: str, fn_paras: list = None):
+        if fn_paras is None:
+            fn_paras = []
+        data = {
+            "function": fn_name,
+            "params": fn_paras
+        }
+
+        return data
+
+    def query_state_data(self, queries: dict, batch_size: int = 100, workers: int = 5, ignore_error: bool = False):
+        """
+        Args:
+            queries: dict - defi state queries
+                - key: str - id of query
+                - value: dict - input of query
+                    {
+                        function: str - name of the function,
+                        params: list - list parameters of function
+                    }
+            batch_size: int - number of query in each batch queries
+            workers: int - maximum number of vCPU used in queries
+            ignore_error: bool - ignore error when decode result or not
+
+        Return:
+            + A dictionary result of queries
+                - key: str - id of query
+                - value: result of query
+        """
+        list_rpc_call, list_call_id = [], []
+        for key, value in queries.items():
+            fn_paras = value.get(Query.params)
+            fn_name = value.get(Query.function)
+            eth_call = self.add_rpc_call(fn_name=fn_name, fn_paras=fn_paras, call_id=key)
+            list_call_id.append(key)
+            list_rpc_call.append(eth_call)
+
+        response_data = self.client_querier.sent_batch_to_provider(list_rpc_call, batch_size, workers)
+        decoded_data = self.decode_response_data(response_data, list_call_id, ignore_error=ignore_error)
+        return decoded_data
+
+    @staticmethod
+    def add_rpc_call(fn_name: str, fn_paras: list = None, call_id: str = None):
+        solana_call = EthJsonRpc(method=fn_name, params=fn_paras, id=call_id)
+        return solana_call
+
+    @staticmethod
+    def decode_response_data(response_data: dict, list_call_id: list, ignore_error=False):
+        decoded_data = {}
+        for call_id in list_call_id:
+            try:
+                response_datum = response_data.get(call_id)
+                decoded_datum = response_datum.decode_result()
+            except Exception as e:
+                if not ignore_error:
+                    logger.error(f"An exception when decode data from provider: {e}")
+                    raise
+                else:
+                    logger.error(f"[Ignored] An exception when decode data from provider: {e}")
+                    continue
+            if isinstance(decoded_datum, int):
+                decoded_data[call_id] = decoded_datum
+            elif len(decoded_datum) == 1:
+                decoded_data[call_id] = decoded_datum[0]
+            else:
+                decoded_data[call_id] = decoded_datum
+        return decoded_data

defi_services/jobs/{state_querier.py → queriers/state_querier.py}

@@ -10,7 +10,7 @@ from web3.middleware import geth_poa_middleware
 from defi_services.constants.query_constant import Query
 from defi_services.constants.token_constant import Token
 
-logger = logging.getLogger("StateService")
+logger = logging.getLogger("StateQuerier")
 
 
 class StateQuerier:
@@ -94,8 +94,9 @@ class StateQuerier:
         decoded_data = self.decode_response_data(response_data, list_call_id, ignore_error=ignore_error)
         return decoded_data
 
+    @staticmethod
     def add_native_token_balance_rpc_call(
-            self, fn_paras: str = None, call_id: str = None, block_number: int = "latest"):
+            fn_paras: str = None, call_id: str = None, block_number: int = "latest"):
         eth_call = GetBalance(Web3.toChecksumAddress(fn_paras), block_number, call_id)
         return eth_call
 

defi_services/jobs/queriers/substrate_state_querier.py

@@ -0,0 +1,84 @@
+import logging
+
+from substrateinterface import SubstrateInterface
+from defi_services.constants.query_constant import Query
+
+logger = logging.getLogger("SubstrateStateQuerier")
+
+
+class SubstrateStateQuerier:
+    def __init__(self, provider_uri):
+        self.provider_uri = provider_uri
+        self.client_querier = SubstrateInterface(provider_uri)
+
+    def get_client_querier(self):
+        return self.client_querier
+
+    @staticmethod
+    def get_function_info(module: str, fn_name: str, fn_paras: list = None, block_number: int = "latest"):
+        if fn_paras is None:
+            fn_paras = []
+        data = {
+            "module": module,
+            "function": fn_name,
+            "params": fn_paras,
+            "block_number": block_number
+        }
+
+        return data
+
+    def query_state_data(self, queries: dict):
+        """
+        Args:
+            queries: dict - defi state queries
+                - key: str - id of query
+                - value: dict - input of query
+                    {
+                        function: str - name of the function,
+                        params: list - list parameters of function
+                    }
+            ignore_error: bool - ignore error when decode result or not
+
+        Return:
+            + A dictionary result of queries
+                - key: str - id of query
+                - value: result of query
+        """
+        block_hash, rpc_call, list_call_id = {}, {}, []
+        for key, value in queries.items():
+            module = value.get(Query.module)
+            fn_paras = value.get(Query.params)
+            fn_name = value.get(Query.function)
+            block_number = value.get(Query.block_number)
+            if block_number not in rpc_call:
+                rpc_call[block_number] = []
+            if block_number != "latest" and block_number not in block_hash:
+                block_hash[block_number] = self.client_querier.get_block_hash(block_number)
+            eth_call = self.add_rpc_call(module=module, fn_name=fn_name, fn_paras=fn_paras)
+            list_call_id.append(key)
+            rpc_call[block_number].append(eth_call)
+        decoded_data = {}
+        for block_number, list_rpc_call in rpc_call.items():
+            if block_number != "latest":
+                response_data = self.client_querier.query_multi(list_rpc_call, block_hash.get(block_number))
+            else:
+                response_data = self.client_querier.query_multi(list_rpc_call)
+
+            decoded_data.update(self.decode_response_data(response_data, block_number))
+        return decoded_data
+
+    def add_rpc_call(self, module: str, fn_name: str, fn_paras: list = None):
+        call = self.client_querier.create_storage_key(module, fn_name, fn_paras)
+        return call
+
+    @staticmethod
+    def decode_response_data(response_data: list, block_number: int = "latest"):
+        decoded_data = {}
+        for data in response_data:
+            storage_key = data[0]
+            storage_value = data[1]
+            key = f"{storage_key.pallet}_{storage_key.storage_function}_{storage_key.params}_{block_number}".lower()
+            value = storage_value.value_serialized
+            decoded_data[key] = value
+
+        return decoded_data

defi_services/services/lending/aave_v2_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.avalanche.aave_v2_avalanche import AAVE_V2_AVALANCHE
 from defi_services.services.lending.lending_info.ethereum.aave_v2_eth import AAVE_V2_ETH
 from defi_services.services.lending.lending_info.polygon.aave_v2_polygon import AAVE_V2_POLYGON
@@ -30,7 +31,7 @@ class AaveInfo:
 
 class AaveV2StateService(ProtocolServices):
     def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
-        self.name = f"{chain_id}_aave-v2"
+        self.name = f"{chain_id}_{Lending.aave_v2}"
         self.chain_id = chain_id
         self.pool_info = AaveInfo.mapping.get(chain_id)
         self.lending_abi = LENDING_POOL_ABI
@@ -41,7 +42,7 @@ class AaveV2StateService(ProtocolServices):
     # BASIC FUNCTION
     def get_service_info(self):
         info = {
-            "aave-v2": {
+            Lending.aave_v2: {
                 "chain_id": self.chain_id,
                 "type": "lending",
                 "protocol_info": self.pool_info
@@ -153,7 +154,7 @@ class AaveV2StateService(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()
@@ -253,7 +254,7 @@ class AaveV2StateService(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 = {}, {}, {}, {}, {}, {}
@@ -415,7 +416,7 @@ class AaveV2StateService(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)
 
@@ -424,7 +425,7 @@ class AaveV2StateService(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}