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

defi_services/abis/lending/morpho/morpho_compound_reward_manager_abi.py

@@ -0,0 +1,307 @@
+import json
+
+MORPHO_COMPOUND_REWARD_MANAGER_ABI = json.loads('''
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidCToken",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "OnlyMorpho",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_user",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_poolToken",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_userBalance",
+        "type": "uint256"
+      }
+    ],
+    "name": "accrueUserBorrowUnclaimedRewards",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_user",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_poolToken",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_userBalance",
+        "type": "uint256"
+      }
+    ],
+    "name": "accrueUserSupplyUnclaimedRewards",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address[]",
+        "name": "_poolTokens",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "_user",
+        "type": "address"
+      }
+    ],
+    "name": "claimRewards",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "totalUnclaimedRewards",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "compBorrowerIndex",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "compSupplierIndex",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "comptroller",
+    "outputs": [
+      {
+        "internalType": "contract IComptroller",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_poolToken",
+        "type": "address"
+      }
+    ],
+    "name": "getLocalCompBorrowState",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "uint224",
+            "name": "index",
+            "type": "uint224"
+          },
+          {
+            "internalType": "uint32",
+            "name": "block",
+            "type": "uint32"
+          }
+        ],
+        "internalType": "struct IComptroller.CompMarketState",
+        "name": "",
+        "type": "tuple"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_poolToken",
+        "type": "address"
+      }
+    ],
+    "name": "getLocalCompSupplyState",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "uint224",
+            "name": "index",
+            "type": "uint224"
+          },
+          {
+            "internalType": "uint32",
+            "name": "block",
+            "type": "uint32"
+          }
+        ],
+        "internalType": "struct IComptroller.CompMarketState",
+        "name": "",
+        "type": "tuple"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_morpho",
+        "type": "address"
+      }
+    ],
+    "name": "initialize",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "localCompBorrowState",
+    "outputs": [
+      {
+        "internalType": "uint224",
+        "name": "index",
+        "type": "uint224"
+      },
+      {
+        "internalType": "uint32",
+        "name": "block",
+        "type": "uint32"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "localCompSupplyState",
+    "outputs": [
+      {
+        "internalType": "uint224",
+        "name": "index",
+        "type": "uint224"
+      },
+      {
+        "internalType": "uint32",
+        "name": "block",
+        "type": "uint32"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "morpho",
+    "outputs": [
+      {
+        "internalType": "contract IMorpho",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "userUnclaimedCompRewards",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]
+''')

defi_services/constants/entities/lending_constant.py

@@ -17,5 +17,10 @@ class Lending:
     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]
+           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

@@ -2,6 +2,9 @@ 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
@@ -33,7 +36,10 @@ class LendingServices:
         Lending.strike: StrikeStateService,
         Lending.onyx: OnyxStateService,
         Lending.granary: GranaryV1StateService,
-        Lending.wepiggy: WepiggyStateService
+        Lending.wepiggy: WepiggyStateService,
+        Lending.morpho_aave_v3: MorphoAaveV3Services,
+        Lending.morpho_aave_v2: MorphoAaveV2Services,
+        Lending.morpho_compound: MorphoCompoundServices
     }
     fantom = {
         Lending.trava: TravaStateService,

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/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/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_v3_services.py

@@ -5,6 +5,7 @@ from web3 import Web3
 from defi_services.abis.lending.aave_v3.aave_v3_incentives_abi import AAVE_V3_INCENTIVES_ABI
 from defi_services.abis.lending.aave_v3.aave_v3_lending_pool_abi import AAVE_V3_LENDING_POOL_ABI
 from defi_services.abis.lending.aave_v3.aave_v3_oracle_abi import AAVE_V3_ORACLE_ABI
+from defi_services.abis.lending.morpho.morpho_aave_v3_comptroller_abi import MORPHO_AAVE_V3_COMPTROLLER_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
@@ -22,7 +23,7 @@ from defi_services.services.lending.lending_info.polygon.aave_v3_polygon import
 logger = logging.getLogger("Aave V3 Lending Pool State Service")
 
 
-class AaveInfo:
+class AaveV3Info:
     mapping = {
         Chain.ethereum: AAVE_V3_ETH,
         Chain.polygon: AAVE_V3_POLYGON,
@@ -38,10 +39,11 @@ class AaveV3StateService(AaveV2StateService):
         super().__init__(state_service, chain_id)
         self.name = f"{chain_id}_{Lending.aave_v3}"
         self.chain_id = chain_id
-        self.pool_info = AaveInfo.mapping.get(chain_id)
+        self.pool_info = AaveV3Info.mapping.get(chain_id)
         self.lending_abi = AAVE_V3_LENDING_POOL_ABI
         self.incentive_abi = AAVE_V3_INCENTIVES_ABI
         self.oracle_abi = AAVE_V3_ORACLE_ABI
+        self.comptroller_abi = MORPHO_AAVE_V3_COMPTROLLER_ABI
         self.state_service = state_service
 
     def get_service_info(self):

defi_services/services/lending/compound_service.py

@@ -106,7 +106,7 @@ class CompoundStateService(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
             ))
 
@@ -139,7 +139,7 @@ class CompoundStateService(ProtocolServices):
             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
@@ -304,6 +304,24 @@ class CompoundStateService(ProtocolServices):
         }
 
     # REWARDS BALANCE
+    def get_claimable_rewards_balance_function_info(
+            self,
+            wallet_address: str,
+            block_number: int = "latest",
+    ):
+        rpc_call = self.get_comptroller_function_info("compAccrued", [wallet_address], block_number)
+        get_reward_id = f"compAccrued_{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"compAccrued_{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,