defi-state-querier 0.5.29__py3-none-any.whl → 0.5.31__py3-none-any.whl

defi_services/services/lending/lending_info/optimism/xlend_optimism.py

@@ -0,0 +1,112 @@
+XLEND_OPTIMISM = {
+    "address": "0x345d2827f36621b02b783f7d5004b4a2fec00186",
+    "name": "Xlend Lending Pool",
+    "addressProvider": "0xa98cc6031ba6908d73dc5615ca82b607096d721d",
+    "dataProvider": "0xcc61e9470b5f0ce21a3f6255c73032b47aaea9c0",
+    "stakedIncentiveAddress": '0x3bbf68f18a792d34a288407f34734d16829b457e',
+    "rewardTokensList": ["0x2dad3a13ef0c6366220f989157009e501e7938f8"],
+    "oracleAddress": "0x1bc889345c912d5462b71e019f9dccba33d83db4",
+    "type": "LENDING_POOL",
+    "poolToken": "0x2dad3a13ef0c6366220f989157009e501e7938f8",
+    "forked": "aave-v3",
+    "reservesList": {
+         "0xda10009cbd5d07dd0cecc66161fc93d7c9000da1": {
+          "tToken": "0x82e64f49ed5ec1bc6e43dad4fc8af9bb3a2312ee",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0x8619d80fb0141ba7f184cbf22fd724116d9f7ffc",
+          "loanToValue": 0.63,
+          "liquidationThreshold": 0.77
+         },
+         "0x350a791bfc2c21f9ed5d10980dad2e2638ffa7f6": {
+          "tToken": "0x191c10aa4af7c30e871e70c95db0e4eb77237530",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0x953a573793604af8d41f306feb8274190db4ae0e",
+          "loanToValue": 0.66,
+          "liquidationThreshold": 0.71
+         },
+         "0x7f5c764cbc14f9669b88837ca1490cca17c31607": {
+          "tToken": "0x625e7708f30ca75bfd92586e17077590c60eb4cd",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0xfccf3cabbe80101232d343252614b6a3ee81c989",
+          "loanToValue": 0.75,
+          "liquidationThreshold": 0.785
+         },
+         "0x68f180fcce6836688e9084f035309e29bf0a2095": {
+          "tToken": "0x078f358208685046a11c85e8ad32895ded33a249",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0x92b42c66840c7ad907b4bf74879ff3ef7c529473",
+          "loanToValue": 0.73,
+          "liquidationThreshold": 0.78
+         },
+         "0x4200000000000000000000000000000000000006": {
+          "tToken": "0xe50fa9b3c56ffb159cb0fca61f5c9d750e8128c8",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0x0c84331e39d6658cd6e6b9ba04736cc4c4734351",
+          "loanToValue": 0.8,
+          "liquidationThreshold": 0.83
+         },
+         "0x94b008aa00579c1307b0ef2c499ad98a8ce58e58": {
+          "tToken": "0x6ab707aca953edaefbc4fd23ba73294241490620",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0xfb00ac187a8eb5afae4eace434f493eb62672df7",
+          "loanToValue": 0.75,
+          "liquidationThreshold": 0.78
+         },
+         "0x76fb31fb4af56892a25e32cfc43de717950c9278": {
+          "tToken": "0xf329e36c7bf6e5e86ce2150875a84ce77f477375",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0xe80761ea617f66f96274ea5e8c37f03960ecc679",
+          "loanToValue": 0.63,
+          "liquidationThreshold": 0.7
+         },
+         "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9": {
+          "tToken": "0x6d80113e533a2c0fe82eabd35f1875dcea89ea97",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0x4a1c3ad6ed28a636ee1751c69071f6be75deb8b8",
+          "loanToValue": 0.0,
+          "liquidationThreshold": 0.7
+         },
+         "0x4200000000000000000000000000000000000042": {
+          "tToken": "0x513c7e3a9c69ca3e22550ef58ac1c0088e918fff",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0x77ca01483f379e58174739308945f044e1a764dc",
+          "loanToValue": 0.58,
+          "liquidationThreshold": 0.63
+         },
+         "0x1f32b1c2345538c0c6f582fcb022739c4a194ebb": {
+          "tToken": "0xc45a479877e1e9dfe9fcd4056c699575a1045daa",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0x34e2ed44ef7466d5f9e0b782b5c08b57475e7907",
+          "loanToValue": 0.75,
+          "liquidationThreshold": 0.79
+         },
+         "0xc40f949f8a4e094d1b49a23ea9241d289b7b2819": {
+          "tToken": "0x8eb270e296023e9d92081fdf967ddd7878724424",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0xce186f6cccb0c955445bb9d10c59cae488fea559",
+          "loanToValue": 0.0,
+          "liquidationThreshold": 0.0
+         },
+         "0xdfa46478f9e5ea86d57387849598dbfb2e964b02": {
+          "tToken": "0x8ffdf2de812095b1d19cb146e4c004587c0a0692",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0xa8669021776bc142dfca87c21b4a52595bcbb40a",
+          "loanToValue": 0.0,
+          "liquidationThreshold": 0.01
+         },
+         "0x9bcef72be871e61ed4fbbc7630889bee758eb81d": {
+          "tToken": "0x724dc807b04555b71ed48a6896b6f41593b8c637",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0xf611aeb5013fd2c0511c9cd55c7dc5c1140741a6",
+          "loanToValue": 0.69,
+          "liquidationThreshold": 0.74
+         },
+         "0x0b2c639c533813f4aa9d7837caf62653d097ff85": {
+          "tToken": "0x38d693ce1df5aadf7bc62595a37d667ad57922e5",
+          "sdToken": "0xd94112b5b62d53c9402e7a60289c6810def1dc9b",
+          "dToken": "0x5d557b07776d12967914379c71a1310e917c7555",
+          "loanToValue": 0.75,
+          "liquidationThreshold": 0.78
+         }
+}
+}

defi_services/services/lending/liqee_service.py

@@ -35,7 +35,7 @@ class LiqeeStateService(CompoundStateService):
         self.state_service = state_service
         self.lending_data_abi = LIQEE_LENDING_DATA_ABI
         self.controller_abi = LIQEE_CONTROLLER_ABI
-        self.lquee_token_abi = LIQEE_TOKEN_ABI
+        self.liqee_token_abi = LIQEE_TOKEN_ABI
 
     # BASIC FUNCTIONS
     def get_service_info(self):
@@ -60,7 +60,7 @@ class LiqeeStateService(CompoundStateService):
         reserves_info = {}
         for token in ctokens:
             address = _w3.to_checksum_address(token)
-            contract = _w3.eth.contract(address=address, abi=self.lquee_token_abi)
+            contract = _w3.eth.contract(address=address, abi=self.liqee_token_abi)
             underlying = contract.functions.underlying().call(block_identifier=block_number)
             liquidation_threshold = comptroller_contract.functions.markets(address).call(block_identifier=block_number)
             liquidation_threshold = liquidation_threshold[0] / 10 ** 18

defi_services/services/lending/onyx_service.py

@@ -55,6 +55,8 @@ class OnyxStateService(CompoundStateService):
             # if token in [ContractAddresses.LUNA.lower(), ContractAddresses.UST.lower(), ContractAddresses.LUNA,
             #              ContractAddresses.UST]:
             #     continue
+            if token == '0x1933f1183c421d44d531ed40a5d2445f6a91646d':
+                continue
             ctokens.append(token)
 
         lens_contract = _w3.eth.contract(
@@ -78,7 +80,6 @@ class OnyxStateService(CompoundStateService):
                 "liquidationThreshold": lt,
                 "loanToValue": ltv
             }
-
         return reserves_info
 
     # PROTOCOL APY

defi_services/services/lending/seamless_services.py

@@ -0,0 +1,313 @@
+import logging
+
+from web3 import Web3
+
+from defi_services.abis.lending.seamless.seamless_incentive import SEAMLESS_INCENTIVE_ABI
+from defi_services.abis.lending.seamless.seamless_lending_pool import SEAMLESS_LENDING_POOL_ABI
+from defi_services.abis.lending.seamless.seamless_oracle import SEAMLESS_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.network_constants import NATIVE_TOKEN
+from defi_services.constants.time_constant import TimeConstants
+from defi_services.jobs.queriers.state_querier import StateQuerier
+from defi_services.services.lending.aave_v2_services import AaveV2StateService
+from defi_services.services.lending.lending_info.base.seamless_base import SEAMLESS_BASE
+
+logger = logging.getLogger("Seamless Lending Pool State Service")
+
+
+class SeamlessInfo:
+    mapping = {
+        Chain.base: SEAMLESS_BASE
+    }
+
+
+class SeamlessStateService(AaveV2StateService):
+    def __init__(self, state_service: StateQuerier, chain_id: str = Chain.base):
+        super().__init__(state_service, chain_id)
+        self.name = f"{chain_id}_{Lending.seamless}"
+        self.chain_id = chain_id
+        self.pool_info = SeamlessInfo.mapping.get(chain_id)
+        self.lending_abi = SEAMLESS_LENDING_POOL_ABI
+        self.incentive_abi = SEAMLESS_INCENTIVE_ABI
+        self.oracle_abi = SEAMLESS_ORACLE_ABI
+        self.state_service = state_service
+
+    def get_service_info(self):
+        info = {
+            Lending.seamless: {
+                "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()
+        pool_address = self.pool_info.get("address")
+        pool_contract = _w3.eth.contract(address=_w3.to_checksum_address(pool_address), abi=self.lending_abi)
+        reserve_list = pool_contract.functions.getReservesList().call(block_identifier=block_number)
+        reserves_info = {}
+        for token in reserve_list:
+            token = token.lower()
+            reserve_data = pool_contract.functions.getReserveData(
+                _w3.to_checksum_address(token)).call(block_identifier=block_number)
+            reserves_info[token] = {}
+            reserves_info[token]["tToken"] = reserve_data[8].lower()
+            reserves_info[token]["sdToken"] = reserve_data[9].lower()
+            reserves_info[token]["dToken"] = reserve_data[10].lower()
+
+            risk_param = bin(reserve_data[0][0])[2:]
+            reserves_info[token]["loanToValue"] = int(risk_param[-15:], 2) / 10 ** 4
+            reserves_info[token]["liquidationThreshold"] = int(risk_param[-31:-16], 2) / 10 ** 4
+
+        return reserves_info
+
+    # CALCULATE APY LENDING POOL
+    def get_reserve_tokens_metadata(
+            self,
+            decoded_data: dict,
+            reserves_info: dict,
+            block_number: int = "latest"
+    ):
+        reserve_tokens_info = []
+        for token_address, reserve_info in reserves_info.items():
+            get_reserve_data_call_id = f'getReserveData_{self.name}_{token_address}_{block_number}'.lower()
+            reserve_data = decoded_data.get(get_reserve_data_call_id)
+            atoken = reserve_data[8].lower()
+            debt_token = reserve_data[10].lower()
+            decimals_call_id = f"decimals_{token_address}_{block_number}".lower()
+            atoken_total_supply_key = f'totalSupply_{atoken}_{block_number}'.lower()
+            debt_token_total_supply_key = f'totalSupply_{debt_token}_{block_number}'.lower()
+            sdebt_token = reserve_data[9].lower()
+
+
+            data = {
+                'underlying': token_address,
+                'underlying_decimals': decoded_data.get(decimals_call_id),
+                'a_token_supply': decoded_data.get(atoken_total_supply_key),
+                'd_token_supply': decoded_data.get(debt_token_total_supply_key),
+
+                'supply_apy': reserve_data[2],
+                'borrow_apy': reserve_data[4],
+
+            }
+            if sdebt_token != NATIVE_TOKEN:
+                sdebt_token_total_supply_key = f'totalSupply_{sdebt_token}_{block_number}'.lower()
+                data['sd_token_supply'] = decoded_data.get(sdebt_token_total_supply_key)
+                data['stable_borrow_apy'] = reserve_data[5]
+            else:
+                data['sd_token_supply'] = 0
+                data['stable_borrow_apy'] = 0
+
+            reserve_tokens_info.append(data)
+
+        return reserve_tokens_info
+
+    def get_apy_lending_pool_function_info_deprecated(
+            self,
+            reserves_info: dict,
+            block_number: int = "latest",
+    ):
+        rpc_calls = {}
+        reward_tokens = self.pool_info.get("rewardTokensList")
+        for token_address, value in reserves_info.items():
+            reserve_key = f"getReserveData_{self.name}_{token_address}_{block_number}".lower()
+            atoken_total_supply_key = f'totalSupply_{value["tToken"]}_{block_number}'.lower()
+            debt_token_total_supply_key = f'totalSupply_{value["dToken"]}_{block_number}'.lower()
+            decimals_key = f"decimals_{token_address}_{block_number}".lower()
+            for reward_token in reward_tokens:
+                atoken_assets_key = f"getRewardsData_{value['tToken']}_{reward_token}_{block_number}".lower()
+                debt_token_assets_key = f"getRewardsData_{value['dToken']}_{reward_token}_{block_number}".lower()
+                rpc_calls[atoken_assets_key] = self.get_function_incentive_info(
+                    "getRewardsData", [value['tToken'], reward_token], block_number)
+                rpc_calls[debt_token_assets_key] = self.get_function_incentive_info(
+                    "getRewardsData", [value['dToken'], reward_token], block_number)
+                if value['sdToken'] != NATIVE_TOKEN:
+                    sdebt_token_assets_key = f"getRewardsData_{value['sdToken']}_{reward_token}_{block_number}".lower()
+                    rpc_calls[sdebt_token_assets_key] = self.get_function_incentive_info(
+                    "getRewardsData", [value['sdToken'], reward_token], block_number)
+
+            rpc_calls[reserve_key] = self.get_function_lending_pool_info("getReserveData", [token_address])
+            rpc_calls[atoken_total_supply_key] = self.state_service.get_function_info(
+                value["tToken"], ERC20_ABI, "totalSupply", block_number=block_number)
+            rpc_calls[debt_token_total_supply_key] = self.state_service.get_function_info(
+                value["dToken"], ERC20_ABI, "totalSupply", block_number=block_number)
+            rpc_calls[decimals_key] = self.state_service.get_function_info(
+                token_address, ERC20_ABI, "decimals", block_number=block_number)
+
+            if value['sdToken'] != NATIVE_TOKEN:
+                sdebt_token_total_supply_key = f'totalSupply_{value["sdToken"]}_{block_number}'.lower()
+                rpc_calls[sdebt_token_total_supply_key] = self.state_service.get_function_info(
+                    value["sdToken"], ERC20_ABI, "totalSupply", block_number=block_number)
+
+        return rpc_calls
+
+    def get_apy_lending_pool_deprecated(
+            self,
+            atokens: dict,
+            debt_tokens: dict,
+            decimals: dict,
+            reserves_info: dict,
+            asset_data_tokens: dict,
+            total_supply_tokens: dict,
+            interest_rate: dict,
+            token_prices: dict,
+            pool_token_price: float,
+            pool_decimals: int = 18,
+    ):
+        reward_tokens = self.pool_info.get("rewardTokensList")
+        for token_address in reserves_info:
+            atoken = atokens.get(token_address)
+            debt_token = debt_tokens.get(token_address)
+            decimal = decimals.get(token_address)
+            total_supply_t = total_supply_tokens.get(atoken, 0)
+            total_supply_d = total_supply_tokens.get(debt_token, 0)
+            # update deposit, borrow apy
+            total_supply_t = total_supply_t / 10 ** decimal
+            total_supply_d = total_supply_d / 10 ** decimal
+            token_price = token_prices.get(token_address)
+            interest_rate[token_address].update({
+                "utilization": total_supply_d / total_supply_t,
+            })
+            total_supply_t_in_usd = total_supply_t * token_price
+            total_supply_d_in_usd = total_supply_d * token_price
+            if reward_tokens:
+                interest_rate[token_address][DBConst.reward_deposit_apy] = {}
+                interest_rate[token_address][DBConst.reward_borrow_apy] = {}
+                asset_data_t = asset_data_tokens.get(atoken)
+                asset_data_d = asset_data_tokens.get(debt_token)
+                # update deposit, borrow apy
+                for reward_address in reward_tokens:
+                    eps_t = asset_data_t[reward_address][1] / 10 ** 18
+                    eps_d = asset_data_d[reward_address][1] / 10 ** 18
+                    if total_supply_t:
+                        deposit_apr = eps_t * TimeConstants.A_YEAR * pool_token_price / (
+                                total_supply_t * token_price)
+                    else:
+                        deposit_apr = 0
+                    if total_supply_d:
+                        borrow_apr = eps_d * TimeConstants.A_YEAR * pool_token_price / (
+                                total_supply_d * token_price)
+                    else:
+                        borrow_apr = 0
+                    interest_rate[token_address][DBConst.reward_deposit_apy].update({
+                        DBConst.reward_borrow_apy: deposit_apr}
+                    )
+                    interest_rate[token_address][DBConst.reward_borrow_apy].update({
+                        reward_address: borrow_apr}
+                    )
+            # update liquidity
+            liquidity_log = {
+                'total_borrow': {
+                    DBConst.amount: total_supply_d,
+                    DBConst.value_in_usd: total_supply_d_in_usd},
+                'total_deposit': {
+                    DBConst.amount: total_supply_t,
+                    DBConst.value_in_usd: total_supply_t_in_usd}
+            }
+            interest_rate[token_address].update({DBConst.liquidity_change_logs: liquidity_log})
+
+        return interest_rate
+
+    def calculate_apy_lending_pool_function_call_deprecated(
+            self,
+            reserves_info: dict,
+            decoded_data: dict,
+            token_prices: dict,
+            pool_token_price: float,
+            pool_decimals: int = 18,
+            block_number: int = 'latest',
+    ):
+        reserves_data = {}
+        for token in reserves_info:
+            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)
+        reward_tokens = self.pool_info.get("rewardTokensList")
+        interest_rate, atokens, debt_tokens, sdebt_tokens, decimals, asset_data_tokens = {}, {}, {}, {}, {}, {}
+        total_supply_tokens = {}
+        for token_address in reserves_info:
+            lower_address = token_address.lower()
+            reserve_data = reserves_data[lower_address]
+            interest_rate[lower_address] = {
+                'deposit_apy': float(reserve_data[3]) / 10 ** 27,
+                'borrow_apy': float(reserve_data[4]) / 10 ** 27,
+                'stable_borrow_apy': float(reserve_data[5]) / 10 ** 27}
+            atoken = reserve_data[7].lower()
+            sdebt_token = reserve_data[8].lower()
+            debt_token = reserve_data[9].lower()
+            decimals_call_id = f"decimals_{token_address}_{block_number}".lower()
+            atoken_total_supply_key = f'totalSupply_{atoken}_{block_number}'.lower()
+            debt_token_total_supply_key = f'totalSupply_{debt_token}_{block_number}'.lower()
+            asset_data_tokens[atoken] = {}
+            asset_data_tokens[debt_token] = {}
+            if sdebt_token != NATIVE_TOKEN:
+                asset_data_tokens[sdebt_token] = {}
+
+            total_supply_tokens[atoken] = {}
+            for reward_token in reward_tokens:
+                atoken_assets_key = f"getRewardsData_{atoken}_{reward_token}_{block_number}".lower()
+                debt_token_assets_key = f"getRewardsData_{debt_token}_{reward_token}_{block_number}".lower()
+                asset_data_tokens[atoken][reward_token] = decoded_data.get(atoken_assets_key)
+                asset_data_tokens[debt_token][reward_token] = decoded_data.get(debt_token_assets_key)
+                total_supply_tokens[atoken][reward_token] = decoded_data.get(atoken_total_supply_key)
+                if sdebt_token != NATIVE_TOKEN:
+                    sdebt_token_assets_key = f"getRewardsData_{sdebt_tokens}_{reward_token}_{block_number}".lower()
+                    asset_data_tokens[sdebt_token][reward_token] = decoded_data.get(sdebt_token_assets_key)
+
+            atokens[lower_address] = atoken
+            debt_tokens[lower_address] = debt_token
+            sdebt_tokens[lower_address] = sdebt_token
+            decimals[lower_address] = decoded_data.get(decimals_call_id)
+            total_supply_tokens[debt_token] = decoded_data.get(debt_token_total_supply_key)
+            if sdebt_token != NATIVE_TOKEN:
+                sdebt_token_total_supply_key = f'totalSupply_{sdebt_token}_{block_number}'.lower()
+                total_supply_tokens[sdebt_token] = decoded_data.get(sdebt_token_total_supply_key)
+
+        asset_price_key = f"getAssetsPrices_{self.name}_{block_number}".lower()
+        if not token_prices and asset_price_key in decoded_data:
+            token_prices = {}
+            prices = decoded_data.get(asset_price_key)
+            for pos in range(len(reserves_info.keys())):
+                token_prices[reserves_info[pos].lower()] = prices[pos] / 10 ** pool_decimals
+
+        data = self.get_apy_lending_pool_deprecated(
+            atokens, debt_tokens, decimals, reserves_info, asset_data_tokens, total_supply_tokens, interest_rate,
+            token_prices, pool_token_price, pool_decimals
+        )
+
+        return data
+
+    # REWARDS BALANCE
+    def get_rewards_balance_function_info(
+            self,
+            wallet,
+            reserves_info: dict = None,
+            block_number: int = "latest"
+    ):
+        rpc_calls = {}
+        reward_tokens = self.pool_info.get("rewardTokensList")
+        for reward_token in reward_tokens:
+            decimals_call_id = f"decimals_{reward_token}_{block_number}".lower()
+            rpc_calls[decimals_call_id] = self.state_service.get_function_info(
+                reward_token, ERC20_ABI, "decimals", block_number=block_number)
+        tokens = []
+        for key, value in reserves_info.items():
+            tokens += [Web3.to_checksum_address(value["tToken"]), Web3.to_checksum_address(value["dToken"])]
+        key = f"getAllUserRewards_{self.name}_{wallet}_{block_number}".lower()
+        rpc_calls[key] = self.get_function_incentive_info("getAllUserRewards", [tokens, Web3.to_checksum_address(wallet)], block_number)
+        return rpc_calls
+
+    def calculate_rewards_balance(
+            self, wallet: str, reserves_info: dict, decoded_data: dict, block_number: int = "latest"):
+        key = f"getAllUserRewards_{self.name}_{wallet}_{block_number}".lower()
+        rewards = decoded_data.get(key)
+        result = dict(zip(*rewards))
+        for key, value in result.items():
+            decimals_call_id = f"decimals_{key}_{block_number}".lower()
+            value /= 10 ** decoded_data.get(decimals_call_id, 18)
+            result[key] = {"amount": value}
+        return result