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

defi_services/services/lending/lending_info/polygon/wepiggy_polygon.py

@@ -0,0 +1,52 @@
+WEPIGGY_POLYGON = {
+    "name": "Wepiggy Lending Pool",
+    "rewardToken": "0x6f620ec89b8479e97a6985792d0c64f237566746",
+    "comptrollerAddress": "0xffceacfd39117030314a07b2c86da36e51787948",
+    "lensAddress": "0x82413f75f0da101e0fe7f6ff6cba3461f7e04f29",
+    "distributionAddress": "0x16b321c99ab31a84d565ea484f035693718c3e71",
+    "poolToken": "0x6f620ec89b8479e97a6985792d0c64f237566746",
+    "type": "LENDING_POOL",
+    "forked": "compound",
+    "reservesList": {
+        "0x0000000000000000000000000000000000000000": {
+            "cToken": "0xc1b02e52e9512519edf99671931772e452fb4399",
+            "liquidationThreshold": 0.6
+        },
+        "0x2791bca1f2de4661ed88a30c99a7a9449aa84174": {
+            "cToken": "0x12d803497d1e58dd4d4a4f455d754f1d0f937c8b",
+            "liquidationThreshold": 0.9
+        },
+        "0xc2132d05d31c914a87c6611c10748aeb04b58e8f": {
+            "cToken": "0x0c8c1ab017c3c0c8a48dd9f1db2f59022d190f0b",
+            "liquidationThreshold": 0.9
+        },
+        "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063": {
+            "cToken": "0x5cfad792c4df1323188180778aec58e00eace32a",
+            "liquidationThreshold": 0.9
+        },
+        "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619": {
+            "cToken": "0xf4b6d5d432f1c7a9efc9e0b04acde479f9fd1f72",
+            "liquidationThreshold": 0.8
+        },
+        "0x1bfd67037b42cf73acf2047067bd4f2c47d9bfd6": {
+            "cToken": "0xf19200b30a0416322d58e6b6b1d6b5f832936729",
+            "liquidationThreshold": 0.8
+        },
+        "0x53e0bca35ec356bd5dddfebbd1fc0fd03fabad39": {
+            "cToken": "0x3a9cad689a510a7c410ee1be17929cdf78efac8c",
+            "liquidationThreshold": 0.6
+        },
+        "0x0b3f868e0be5597d5db7feb59e1cadbb0fdda50a": {
+            "cToken": "0x1b1cd0fdb6592fe482026b8e47706eac1ee94a7c",
+            "liquidationThreshold": 0.0
+        },
+        "0x172370d5cd63279efa6d502dab29171933a610af": {
+            "cToken": "0xc28e11040c529a6828c20a641f8f75b7c0ea92e3",
+            "liquidationThreshold": 0.6
+        },
+        "0xf28164a485b0b2c90639e47b0f377b4a438a16b1": {
+            "cToken": "0xd0199ba93031ba37aa4e17c885a47edeeb23ae04",
+            "liquidationThreshold": 0.0
+        }
+    }
+}

defi_services/services/lending/liqee_service.py

@@ -13,6 +13,7 @@ from defi_services.constants.entities.lending_constant import Lending
 from defi_services.constants.query_constant import Query
 from defi_services.constants.token_constant import Token
 from defi_services.jobs.queriers.state_querier import StateQuerier
+from defi_services.services.lending.lending_info.bsc.liqee_bsc import LIQEE_BSC
 from defi_services.services.lending.lending_info.ethereum.liqee_eth import LIQEE_ETH
 from defi_services.services.protocol_services import ProtocolServices
 
@@ -21,7 +22,8 @@ logger = logging.getLogger("Liqee Lending Pool State Service")
 
 class LiqeeInfo:
     mapping = {
-        Chain.ethereum: LIQEE_ETH
+        Chain.ethereum: LIQEE_ETH,
+        Chain.bsc: LIQEE_BSC
     }
 
 
@@ -145,11 +147,11 @@ class LiqeeStateService(ProtocolServices):
     ):
         fn_paras = [Web3.toChecksumAddress(wallet_address)]
         rpc_call = self.get_lending_function_info("getAccountRewardAmount", fn_paras, block_number)
-        get_reward_id = f"getAccountRewardAmount_{wallet_address}_{block_number}".lower()
+        get_reward_id = f"getAccountRewardAmount_{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"getAccountRewardAmount_{wallet_address}_{block_number}".lower()
+        get_reward_id = f"getAccountRewardAmount_{self.name}_{wallet_address}_{block_number}".lower()
         rewards = decoded_data.get(get_reward_id) / 10 ** 18
         reward_token = self.pool_info.get("rewardToken")
         result = {

defi_services/services/lending/morpho_aave_v2_services.py

@@ -13,7 +13,7 @@ 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.aave_v2_services import AaveInfo
 from defi_services.services.lending.lending_info.ethereum.morpho_aave_v2_eth import MORPHO_AAVE_V2_ETH
-from defi_services.services.lending.morpho_compound_services import MorphoCompoundServices
+from defi_services.services.lending.morpho_compound_services import MorphoCompoundStateService
 
 logger = logging.getLogger("Compound Lending Pool State Service")
 
@@ -24,7 +24,7 @@ class MorphoAaveV2Info:
     }
 
 
-class MorphoAaveV2Services(MorphoCompoundServices):
+class MorphoAaveV2StateService(MorphoCompoundStateService):
     def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
         super().__init__(state_service, chain_id)
         self.name = f"{chain_id}_{Lending.morpho_aave_v2}"

defi_services/services/lending/morpho_aave_v3_services.py

@@ -14,7 +14,7 @@ from defi_services.constants.token_constant import Token
 from defi_services.jobs.queriers.state_querier import StateQuerier
 from defi_services.services.lending.aave_v3_services import AaveV3Info
 from defi_services.services.lending.lending_info.ethereum.morpho_aave_v3_eth import MORPHO_AAVE_V3_ETH
-from defi_services.services.lending.morpho_compound_services import MorphoCompoundServices
+from defi_services.services.lending.morpho_compound_services import MorphoCompoundStateService
 
 logger = logging.getLogger("Compound Lending Pool State Service")
 
@@ -25,7 +25,7 @@ class MorphoAaveV3Info:
     }
 
 
-class MorphoAaveV3Services(MorphoCompoundServices):
+class MorphoAaveV3StateService(MorphoCompoundStateService):
     def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
         super().__init__(state_service, chain_id)
         self.name = f"{chain_id}_{Lending.morpho_aave_v3}"

defi_services/services/lending/morpho_compound_services.py

@@ -26,7 +26,7 @@ class MorphoCompoundInfo:
     }
 
 
-class MorphoCompoundServices(ProtocolServices):
+class MorphoCompoundStateService(ProtocolServices):
     def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
         self.name = f"{chain_id}_{Lending.morpho_compound}"
         self.chain_id = chain_id

defi_services/services/lending/spark_services.py

@@ -0,0 +1,32 @@
+import logging
+
+from defi_services.constants.chain_constant import Chain
+from defi_services.constants.entities.lending_constant import Lending
+from defi_services.jobs.queriers.state_querier import StateQuerier
+from defi_services.services.lending.aave_v3_services import AaveV3StateService
+from defi_services.services.lending.lending_info.ethereum.spark_eth import SPARK_ETH
+
+logger = logging.getLogger("Spark Lending Pool State Service")
+
+
+class SparkInfo:
+    mapping = {
+        Chain.ethereum: SPARK_ETH
+    }
+
+
+class SparkStateService(AaveV3StateService):
+    def __init__(self, state_service: StateQuerier, chain_id: str = "0x1"):
+        super().__init__(state_service, chain_id)
+        self.name = f"{chain_id}_{Lending.spark}"
+        self.pool_info = SparkInfo.mapping.get(chain_id)
+
+    def get_service_info(self):
+        info = {
+            Lending.spark: {
+                "chain_id": self.chain_id,
+                "type": "lending",
+                "protocol_info": self.pool_info
+            }
+        }
+        return info

defi_services/services/lending/wepiggy_services.py

@@ -3,18 +3,21 @@ 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.wepiggy.wepiggy_comptroller_abi import WEPIGGY_COMPTROLLER_ABI
 from defi_services.abis.lending.wepiggy.wepiggy_distribution_abi import WEPIGGY_DISTRIBUTION_ABI
+from defi_services.abis.lending.wepiggy.wepiggy_lens_abi import WEPIGGY_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.queriers.state_querier import StateQuerier
+from defi_services.services.lending.lending_info.arbitrum.wepiggy_arbitrum import WEPIGGY_ARB
+from defi_services.services.lending.lending_info.bsc.wepiggy_bsc import WEPIGGY_BSC
 from defi_services.services.lending.lending_info.ethereum.wepiggy_eth import WEPIGGY_ETH
+from defi_services.services.lending.lending_info.optimism.wepiggy_optimism import WEPIGGY_OPTIMISM
+from defi_services.services.lending.lending_info.polygon.wepiggy_polygon import WEPIGGY_POLYGON
 from defi_services.services.protocol_services import ProtocolServices
 
 logger = logging.getLogger("Compound Lending Pool State Service")
@@ -22,7 +25,11 @@ logger = logging.getLogger("Compound Lending Pool State Service")
 
 class WepiggyInfo:
     mapping = {
-        Chain.ethereum: WEPIGGY_ETH
+        Chain.ethereum: WEPIGGY_ETH,
+        Chain.bsc: WEPIGGY_BSC,
+        Chain.arbitrum: WEPIGGY_ARB,
+        Chain.polygon: WEPIGGY_POLYGON,
+        Chain.optimism: WEPIGGY_OPTIMISM
     }
 
 
@@ -32,9 +39,9 @@ class WepiggyStateService(ProtocolServices):
         self.chain_id = chain_id
         self.pool_info = WepiggyInfo.mapping.get(chain_id)
         self.state_service = state_service
-        self.lens_abi = CREAM_LENS_ABI
+        self.lens_abi = WEPIGGY_LENS_ABI
         self.distribution_abi = WEPIGGY_DISTRIBUTION_ABI
-        self.comptroller_abi = CREAM_COMPTROLLER_ABI
+        self.comptroller_abi = WEPIGGY_COMPTROLLER_ABI
 
     def get_service_info(self):
         info = {
@@ -63,10 +70,10 @@ class WepiggyStateService(ProtocolServices):
             address=Web3.toChecksumAddress(self.pool_info.get("lensAddress")), abi=self.lens_abi
         )
         tokens = [Web3.toChecksumAddress(i) for i in ctokens]
-        metadata = lens_contract.functions.cTokenMetadataAll(tokens).call(block_identifier=block_number)
+        metadata = lens_contract.functions.pTokenMetadataAll(tokens).call(block_identifier=block_number)
         reserves_info = {}
         for data in metadata:
-            underlying = data[11].lower()
+            underlying = data[2].lower()
             ctoken = data[0].lower()
             lt = data[10] / 10 ** 18
             reserves_info[underlying] = {
@@ -98,12 +105,10 @@ class WepiggyStateService(ProtocolServices):
         begin = time.time()
         reserves_info = kwargs.get("reserves_info", self.pool_info.get("reservesList"))
         token_prices = kwargs.get("token_prices", {})
-        wrapped_native_token_price = token_prices.get(Token.wrapped_token.get(self.chain_id), 1)
-        pool_decimals = kwargs.get("pool_decimals", 18)
         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, wrapped_native_token_price, block_number
+                wallet, reserves_info, decoded_data, token_prices, block_number
             ))
 
         if Query.protocol_reward in query_types and wallet:
@@ -111,10 +116,6 @@ class WepiggyStateService(ProtocolServices):
                 wallet, decoded_data, block_number
             ))
 
-        if Query.protocol_apy in query_types and wallet:
-            result.update(self.calculate_apy_lending_pool_function_call(
-                reserves_info, decoded_data, token_prices, pool_decimals, block_number
-            ))
         logger.info(f"Process protocol data in {time.time() - begin}")
         return result
 
@@ -127,199 +128,32 @@ class WepiggyStateService(ProtocolServices):
     ):
         begin = time.time()
         reserves_info = kwargs.get("reserves_info", {})
-        is_oracle_price = kwargs.get("is_oracle_price", False)  # get price by oracle
         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, is_oracle_price
+                wallet, reserves_info, block_number
             ))
 
-        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))
 
         logger.info(f"Get encoded rpc calls in {time.time() - begin}s")
         return rpc_calls
 
-    # CALCULATE APY LENDING POOL
-    def get_apy_lending_pool_function_info(
-            self,
-            reserves_info: dict,
-            block_number: int = "latest",
-            is_price_oracle: bool = False
-    ):
-        rpc_calls = {}
-        for token, value in reserves_info.items():
-            ctoken = value.get("ctoken")
-            speed_key = f"compSpeeds_{ctoken}_{block_number}".lower()
-            mint_key = f"mintGuardianPaused_{ctoken}_{block_number}".lower()
-            borrow_key = f"borrowGuardianPaused_{token}_{block_number}".lower()
-            metadata_key = f"cTokenMetadata_{ctoken}_{block_number}".lower()
-            if is_price_oracle:
-                price_key = f"cTokenUnderlyingPrice_{ctoken}_{block_number}".lower()
-                rpc_calls[price_key] = self.get_comptroller_function_info('cTokenUnderlyingPrice', [ctoken],
-                                                                          block_number)
-            rpc_calls[speed_key] = self.get_comptroller_function_info('compSpeeds', [ctoken], block_number)
-            rpc_calls[mint_key] = self.get_comptroller_function_info('mintGuardianPaused', [ctoken], block_number)
-            rpc_calls[borrow_key] = self.get_comptroller_function_info('borrowGuardianPaused', [ctoken], block_number)
-            rpc_calls[metadata_key] = self.get_comptroller_function_info('cTokenMetadata', [ctoken], block_number)
-
-        return rpc_calls
-
-    @staticmethod
-    def get_apy_lending_pool(
-            decoded_data: dict,
-            reserves_info: dict,
-            block_number: int = "latest",
-            wrapped_native_token_price: float = 310,
-            underlying_price: dict = None,
-            is_oracle_price: bool = False
-    ):
-        underlying_prices, underlying_decimals, reserve_tokens_info = {}, {}, []
-        ctoken_speeds, borrow_paused_tokens, mint_paused_tokens = {}, {}, {}
-        for token, value in reserves_info.items():
-            ctoken = value.get('cToken')
-            speeds_call_id = f'compSpeeds_{ctoken}_{block_number}'.lower()
-            borrow_guardian_paused_call_id = f'borrowGuardianPaused_{ctoken}_{block_number}'.lower()
-            mint_guardian_paused_call_id = f'mintGuardianPaused_{ctoken}_{block_number}'.lower()
-            ctoken_speeds[ctoken] = decoded_data.get(speeds_call_id)
-            borrow_paused_tokens[ctoken] = decoded_data.get(borrow_guardian_paused_call_id)
-            mint_paused_tokens[ctoken] = decoded_data.get(mint_guardian_paused_call_id)
-            metadata_id = f"cTokenMetadata_{ctoken}_{block_number}".lower()
-            reserve_tokens_info.append(decoded_data.get(metadata_id))
-            if is_oracle_price:
-                underlying_id = f"cTokenUnderlyingPrice_{ctoken}_{block_number}".lower()
-                price_token = decoded_data.get(underlying_id)
-                price_token = price_token[1] * wrapped_native_token_price
-            else:
-                price_token = underlying_price.get(token)
-
-            underlying_decimals[ctoken] = decoded_data.get(metadata_id)[-1]
-            underlying_prices[ctoken] = price_token
-        return {
-            "reserve_tokens_info": reserve_tokens_info,
-            "ctoken_speeds": ctoken_speeds,
-            "borrow_paused_tokens": borrow_paused_tokens,
-            "mint_paused_tokens": mint_paused_tokens,
-            "underlying_prices": underlying_prices,
-            "underlying_decimals": underlying_decimals
-        }
-
-    def calculate_apy_lending_pool_function_call(
-            self,
-            reserves_info: dict,
-            decoded_data: dict,
-            token_prices: dict,
-            pool_decimals: int = 18,
-            block_number: int = "latest",
-            is_oracle_price: bool = False,
-    ):
-        wrapped_native_token_price = token_prices.get(Token.wrapped_token.get(self.chain_id))
-        pool_token_price = token_prices.get(self.pool_info.get("poolToken"))
-        tokens_interest_rates = dict()
-        decode_data = self.get_apy_lending_pool(
-            decoded_data, reserves_info, block_number,
-            wrapped_native_token_price, token_prices, is_oracle_price)
-
-        mint_paused_tokens = decode_data["mint_paused_tokens"]
-        borrow_paused_tokens = decode_data["borrow_paused_tokens"]
-        reserve_tokens_info = decode_data["reserve_tokens_info"]
-        ctoken_speeds = decode_data["ctoken_speeds"]
-        for data in reserve_tokens_info:
-            address = data[0].lower()
-            underlying_token_price = float(decode_data["underlying_prices"][address])
-            if is_oracle_price:
-                underlying_token_price = underlying_token_price / 10 ** int(data[13])
-
-            token_info = {
-                "token": address,
-                "token_decimals": data[12],
-                "borrow_rate": data[3],
-                "supply_rate": data[2],
-                "supply": data[7],
-                "borrow": data[5],
-                "exchange_rate": data[1],
-                "underlying": data[11].lower(),
-                "underlying_price": underlying_token_price,
-                "underlying_decimals": data[13],
-                "speed": ctoken_speeds[address]
-            }
-            underlying_token = token_info['underlying']
-            token_info["mint_paused"] = mint_paused_tokens[address]
-            token_info["borrow_paused"] = borrow_paused_tokens[address]
-            tokens_interest_rates[underlying_token] = self._calculate_interest_rates(
-                token_info, pool_decimals, pool_token_price)
-
-        return tokens_interest_rates
-
-    @staticmethod
-    def _calculate_interest_rates(token_info: dict, pool_decimals: int, pool_price: float,
-                                  is_oracle_price: bool = False):
-        apx_block_speed_in_seconds = 3
-        exchange_rate = float(token_info["exchange_rate"]) / 10 ** (18 - 8 + token_info["underlying_decimals"])
-        block_per_day = int(60 * 60 * 24 / apx_block_speed_in_seconds)
-        venus_per_day = token_info["speed"] * block_per_day / 10 ** pool_decimals
-        underlying_price = float(token_info["underlying_price"])
-        if is_oracle_price:
-            underlying_price /= 10 ** (36 - int(token_info["underlying_decimals"]))
-        total_borrow = float(token_info["borrow"]) / 10 ** int(token_info["underlying_decimals"])
-        total_supply = float(token_info["supply"]) * exchange_rate / 10 ** int(token_info["underlying_decimals"])
-        total_borrow_usd = total_borrow * underlying_price
-        total_supply_usd = total_supply * underlying_price
-
-        if total_borrow_usd == 0:
-            borrow_apr = 0
-        else:
-            borrow_apr = (1 + (pool_price * venus_per_day / total_borrow_usd)) ** 365 - 1
-
-        if total_supply_usd == 0:
-            supply_apr = 0
-        else:
-            supply_apr = (1 + (pool_price * venus_per_day / total_supply_usd)) ** 365 - 1
-
-        supply_apy = ((token_info["supply_rate"] / 10 ** pool_decimals) * block_per_day + 1) ** 365 - 1
-        borrow_apy = ((token_info["borrow_rate"] / 10 ** pool_decimals) * block_per_day + 1) ** 365 - 1
-
-        liquidity_log = {
-            DBConst.total_borrow: {
-                DBConst.amount: total_borrow,
-                DBConst.value_in_usd: total_borrow_usd
-            },
-            DBConst.total_deposit: {
-                DBConst.amount: total_supply,
-                DBConst.value_in_usd: total_supply_usd
-            }
-        }
-        return {
-            DBConst.reward_borrow_apy: borrow_apr,
-            DBConst.reward_deposit_apy: supply_apr,
-            DBConst.deposit_apy: supply_apy,
-            DBConst.borrow_apy: borrow_apy,
-            DBConst.liquidity_change_logs: liquidity_log,
-            DBConst.mint_paused: token_info[DBConst.mint_paused],
-            DBConst.borrow_paused: token_info[DBConst.borrow_paused]
-        }
-
     # REWARDS BALANCE
     def get_rewards_balance_function_info(
             self,
             wallet_address: str,
             block_number: int = "latest",
     ):
-        token = self.pool_info.get("poolToken")
-        fn_paras = [Web3.toChecksumAddress(wallet_address),
-                    False,
-                    True]
-        rpc_call = self.get_distribution_function_info("pendingWpcAccrued", fn_paras, block_number)
-        get_reward_id = f"pendingWpcAccrued_{self.name}_{wallet_address}_{block_number}".lower()
+        rpc_call = self.get_distribution_function_info("wpcAccrued", [wallet_address], block_number)
+        get_reward_id = f"wpcAccrued_{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"pendingWpcAccrued_{self.name}_{wallet_address}_{block_number}".lower()
+        get_reward_id = f"wpcAccrued_{self.name}_{wallet_address}_{block_number}".lower()
         rewards = decoded_data.get(get_reward_id) / 10 ** 18
         reward_token = self.pool_info.get("rewardToken")
         result = {
@@ -332,8 +166,7 @@ class WepiggyStateService(ProtocolServices):
             self,
             wallet_address: str,
             reserves_info: dict,
-            block_number: int = "latest",
-            is_oracle_price: bool = False
+            block_number: int = "latest"
     ):
 
         rpc_calls = {}
@@ -342,13 +175,9 @@ class WepiggyStateService(ProtocolServices):
             ctoken = value.get('cToken')
             if token == Token.native_token:
                 underlying = Token.wrapped_token.get(self.chain_id)
-            underlying_price_key = f"cTokenUnderlyingPrice_{ctoken}_{block_number}".lower()
             underlying_borrow_key = f"borrowBalanceCurrent_{ctoken}_{wallet_address}_{block_number}".lower()
             underlying_balance_key = f"balanceOfUnderlying_{ctoken}_{wallet_address}_{block_number}".lower()
             underlying_decimals_key = f"decimals_{underlying}_{block_number}".lower()
-            if is_oracle_price:
-                rpc_calls[underlying_price_key] = self.get_lens_function_info(
-                    "cTokenUnderlyingPrice", [ctoken], block_number)
             rpc_calls[underlying_borrow_key] = self.get_ctoken_function_info(
                 ctoken, "borrowBalanceCurrent", [wallet_address], block_number)
             rpc_calls[underlying_balance_key] = self.get_ctoken_function_info(
@@ -361,7 +190,7 @@ class WepiggyStateService(ProtocolServices):
 
     def calculate_wallet_deposit_borrow_balance(
             self, wallet_address: str, reserves_info: dict, decoded_data: dict, token_prices: dict = None,
-            wrapped_native_token_price: int = 310, block_number: int = "latest", is_oracle_price: bool = False):
+            block_number: int = "latest"):
         if token_prices is None:
             token_prices = {}
         result = {}
@@ -380,11 +209,7 @@ class WepiggyStateService(ProtocolServices):
                 "borrow_amount": borrow_amount,
                 "deposit_amount": deposit_amount,
             }
-            if is_oracle_price:
-                get_underlying_token_price = f"cTokenUnderlyingPrice_{ctoken}_{block_number}".lower()
-                token_price = decoded_data.get(get_underlying_token_price)[
-                                  1] * wrapped_native_token_price / 10 ** decimals
-            elif token_prices:
+            if token_prices:
                 token_price = token_prices.get(underlying)
             else:
                 token_price = None
@@ -399,8 +224,7 @@ class WepiggyStateService(ProtocolServices):
     def get_token_deposit_borrow_balance_function_info(
             self,
             reserves_info: dict,
-            block_number: int = "latest",
-            is_oracle_price: bool = False
+            block_number: int = "latest"
     ):
         rpc_calls = {}
         for token, value in reserves_info.items():
@@ -408,15 +232,11 @@ class WepiggyStateService(ProtocolServices):
             if token == Token.native_token:
                 underlying = Token.wrapped_token.get(self.chain_id)
             ctoken = value.get('cToken')
-            underlying_price_key = f"cTokenUnderlyingPrice_{ctoken}_{block_number}".lower()
             underlying_borrow_key = f"totalBorrows_{ctoken}_{block_number}".lower()
             underlying_balance_key = f"totalSupply_{ctoken}_{block_number}".lower()
             underlying_decimals_key = f"decimals_{underlying}_{block_number}".lower()
             ctoken_decimals_key = f"decimals_{ctoken}_{block_number}".lower()
             exchange_rate_key = f"exchangeRateCurrent_{ctoken}_{block_number}".lower()
-            if is_oracle_price:
-                rpc_calls[underlying_price_key] = self.get_lens_function_info(
-                    "cTokenUnderlyingPrice", [ctoken], block_number)
             rpc_calls[underlying_borrow_key] = self.get_ctoken_function_info(
                 ctoken, "totalBorrows", [], block_number)
             rpc_calls[underlying_balance_key] = self.get_ctoken_function_info(
@@ -434,7 +254,7 @@ class WepiggyStateService(ProtocolServices):
 
     def calculate_token_deposit_borrow_balance(
             self, decoded_data: dict, reserves_info: dict, token_prices: dict = None,
-            block_number: int = "latest", is_oracle_price: bool = False, wrapped_native_token_price: int = 310
+            block_number: int = "latest"
     ):
         result = {}
         for token, value in reserves_info.items():
@@ -456,12 +276,7 @@ class WepiggyStateService(ProtocolServices):
                 "borrow_amount": borrow_amount,
                 "deposit_amount": deposit_amount
             }
-            if is_oracle_price:
-                get_underlying_token_price = f"cTokenUnderlyingPrice_{ctoken}_{block_number}".lower()
-                token_price = decoded_data.get(get_underlying_token_price)[1] / 10 ** (36 - decimals)
-                if wrapped_native_token_price:
-                    token_price *= wrapped_native_token_price
-            elif token_prices:
+            if token_prices:
                 token_price = token_prices.get(underlying)
             else:
                 token_price = None
@@ -491,29 +306,3 @@ class WepiggyStateService(ProtocolServices):
         return self.state_service.get_function_info(
             ctoken, CTOKEN_ABI, fn_name, fn_paras, block_number
         )
-
-    def get_ctoken_metadata_all(
-            self,
-            reserves_info: dict = None,
-            block_number: int = "latest"
-    ):
-        tokens = [Web3.toChecksumAddress(value['cToken']) for key, value in reserves_info.items()]
-        key = f"cTokenMetadataAll_{self.pool_info.get('lensAddress')}_{block_number}".lower()
-        return {
-            key: self.get_lens_function_info("cTokenMetadataAll", tokens, block_number)
-        }
-
-    def ctoken_underlying_price_all(
-            self, reserves_info, block_number: int = 'latest'):
-        tokens = [Web3.toChecksumAddress(value['cToken']) for key, value in reserves_info.items()]
-        key = f"cTokenUnderlyingPriceAll_{self.pool_info.get('lensAddress')}_{block_number}".lower()
-        return {
-            key: self.get_lens_function_info("cTokenUnderlyingPriceAll", tokens, block_number)
-        }
-
-    def get_all_markets(
-            self, block_number: int = 'latest'):
-        key = f"getAllMarkets_{self.pool_info.get('comptrollerAddress')}_{block_number}".lower()
-        return {
-            key: self.get_comptroller_function_info("getAllMarkets", [], block_number)
-        }

{defi_state_querier-0.0.9.dist-info → defi_state_querier-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: defi-state-querier
-Version: 0.0.9
+Version: 0.1.1
 Summary: Calculate apy, apr, and wallet information,... in decentralized applications.
 Home-page: https://github.com/Centic-io/defi-state-querier
 Author: Viet-Bang Pham