defi-state-querier 0.5.28__py3-none-any.whl → 0.5.30__py3-none-any.whl

defi_services/services/multicall/multicall_v2.py

@@ -1,17 +1,10 @@
-import csv
-import json
-import time
 from collections import defaultdict
 from typing import Tuple, List, Union, Any, Optional, Dict
 
 from query_state_lib.base.utils.decoder import decode_eth_call_data
-from query_state_lib.client.client_querier import ClientQuerier
 from web3 import Web3, contract
 
-from defi_services.abis.dex.pancakeswap.pancakeswap_lp_token_abi import LP_TOKEN_ABI
 from defi_services.abis.multicall_v3_abi import MULTICALL_V3_ABI
-from defi_services.abis.token.erc20_abi import ERC20_ABI
-from defi_services.constants.network_constants import MulticallContract, Chains, Networks
 from defi_services.services.multicall.batch_queries_service import add_rpc_call, decode_data_response, \
     decode_data_response_ignore_error
 from defi_services.utils.dict_utils import all_equal
@@ -184,313 +177,3 @@ def decode_multical_response(w3_multicall: W3Multicall, data_responses, list_cal
         batch_idx += 1
 
     return results
-
-
-def _test_multicall(_w3: Web3, multicall_contract, wallets, tokens):
-    start_time = time.time()
-    encode_time = 0
-
-    rpc_call_id = {}
-
-    n_calls = 0
-    data = {}
-    for wallet in wallets:
-        start_encode_time = time.time()
-        data[wallet] = {}
-
-        w3_multicall = W3Multicall(_w3, address=MulticallContract.get_multicall_contract(Chains.arbitrum))
-        for token in tokens:
-            # if token['address'] == '0x0000000000000000000000000000000000000000':
-            #     continue
-
-            w3_multicall.add(W3Multicall.Call(
-                Web3.to_checksum_address(token['address']),  # contract address
-                ERC20_ABI,  # method signature to call
-                'balanceOf',
-                wallet
-            ))
-
-            decimals_call = W3Multicall.Call(
-                Web3.to_checksum_address(token['address']),  # contract address
-                ERC20_ABI,  # method signature to call
-                'decimals'
-            )
-            if decimals_call not in rpc_call_id:
-                w3_multicall.add(decimals_call)
-                rpc_call_id[decimals_call] = None
-
-        encode_time += time.time() - start_encode_time
-        n_calls += len(w3_multicall.calls)
-
-        # For single call
-        inputs = w3_multicall.get_params()
-        response = multicall_contract.functions.tryAggregate(*inputs).call()
-        results = w3_multicall.decode(response)
-
-        for token in tokens:
-            # if token['address'] == '0x0000000000000000000000000000000000000000':
-            #     continue
-
-            decimals_call_id = f'decimals_{token["address"]}_latest'.lower()
-            balance_call_id = f'balanceOf_{token["address"]}_{wallet}_latest'.lower()
-
-            decimals = results.get(decimals_call_id)
-            if decimals is None:
-                decimals = rpc_call_id.get(decimals_call_id) or 18
-            else:
-                rpc_call_id[decimals_call_id] = decimals
-
-            balance = results.get(balance_call_id)
-            if balance is None:
-                balance = rpc_call_id.get(balance_call_id) or 0
-            else:
-                rpc_call_id[balance_call_id] = balance
-            balance /= 10 ** decimals
-
-            data[wallet][token['address']] = {
-                'name': token['name'],
-                'symbol': token['symbol'],
-                'balance': balance,
-                'decimals': decimals
-            }
-
-    with open('results_multicall.json', 'w') as f:
-        json.dump(data, f, indent=2)
-    duration = time.time() - start_time
-
-    print(f'There are {n_calls} calls')
-    print(f'Encode took {round(encode_time, 3)}s')
-    print(f'Done after {round(duration, 3)}s')
-
-    return duration, encode_time, n_calls
-
-
-def _test_state_querier(client_querier: ClientQuerier, wallets, tokens):
-    start_time = time.time()
-
-    list_call_id = []
-    list_rpc_call = []
-
-    for wallet in wallets:
-        for token in tokens:
-            if token['address'] == '0x0000000000000000000000000000000000000000':
-                continue
-
-            add_rpc_call(
-                abi=ERC20_ABI, contract_address=Web3.to_checksum_address(token['address']),
-                fn_name="balanceOf", fn_paras=wallet, block_number='latest',
-                list_call_id=list_call_id, list_rpc_call=list_rpc_call
-            )
-            add_rpc_call(
-                abi=ERC20_ABI, contract_address=Web3.to_checksum_address(token['address']),
-                fn_name="decimals", block_number='latest',
-                list_call_id=list_call_id, list_rpc_call=list_rpc_call
-            )
-
-    encode_time = time.time() - start_time
-    print(f'There are {len(list_rpc_call)} calls')
-    print(f'Encode took {round(encode_time, 3)}s')
-
-    responses = client_querier.sent_batch_to_provider(list_rpc_call, batch_size=2000)
-    decoded_data = decode_data_response_ignore_error(data_responses=responses, list_call_id=list_call_id)
-
-    data = {}
-    for wallet in wallets:
-        data[wallet] = {}
-        for token in tokens:
-            if token['address'] == '0x0000000000000000000000000000000000000000':
-                continue
-
-            decimals = decoded_data.get(f'decimals_{token["address"]}_latest'.lower())
-            balance = decoded_data.get(f'balanceOf_{token["address"]}_{wallet}_latest'.lower()) / 10 ** decimals
-
-            data[wallet][token['address']] = {
-                'name': token['name'],
-                'symbol': token['symbol'],
-                'balance': balance,
-                'decimals': decimals
-            }
-
-    with open('results_querier.json', 'w') as f:
-        json.dump(data, f, indent=2)
-    duration = time.time() - start_time
-    print(f'Done after {round(duration, 3)}s')
-
-    return duration, encode_time, len(list_rpc_call)
-
-
-def _test_multicall_with_multiprocessing(_w3: Web3, client_querier: ClientQuerier, wallets, tokens):
-    start_time = time.time()
-
-    w3_multicall = W3Multicall(_w3, address=MulticallContract.get_multicall_contract(Chains.arbitrum))
-    for wallet in wallets:
-        for token in tokens:
-            # if token['address'] == '0x0000000000000000000000000000000000000000':
-            #     continue
-
-            w3_multicall.add(W3Multicall.Call(
-                Web3.to_checksum_address(token['address']),  # contract address
-                ERC20_ABI,  # method signature to call
-                'balanceOf',
-                wallet
-            ))
-
-            w3_multicall.add(W3Multicall.Call(
-                Web3.to_checksum_address(token['address']),  # contract address
-                ERC20_ABI,  # method signature to call
-                'decimals'
-            ))
-
-            w3_multicall.add(W3Multicall.Call(
-                Web3.to_checksum_address(token['address']),  # contract address
-                LP_TOKEN_ABI,  # method signature to call
-                'token0'
-            ))
-
-    list_call_id, list_rpc_call = [], []
-    add_rpc_multicall(w3_multicall, list_rpc_call=list_rpc_call, list_call_id=list_call_id)
-
-    encode_time = time.time() - start_time
-
-    responses = client_querier.sent_batch_to_provider(list_rpc_call, batch_size=1)
-    decoded_data = decode_multical_response(
-        w3_multicall=w3_multicall, data_responses=responses,
-        list_call_id=list_call_id, ignore_error=True
-    )
-
-    data = {}
-    for wallet in wallets:
-        data[wallet] = {}
-        for token in tokens:
-            # if token['address'] == '0x0000000000000000000000000000000000000000':
-            #     continue
-
-            decimals_call_id = f'decimals_{token["address"]}_latest'.lower()
-            balance_call_id = f'balanceOf_{token["address"]}_{wallet}_latest'.lower()
-
-            decimals = decoded_data.get(decimals_call_id) or 18
-            balance = decoded_data.get(balance_call_id, 0) / 10 ** decimals
-
-            data[wallet][token['address']] = {
-                'name': token['name'],
-                'symbol': token['symbol'],
-                'balance': balance,
-                'decimals': decimals
-            }
-
-    with open('results_multicall_with_multiprocessing.json', 'w') as f:
-        json.dump(data, f, indent=2)
-    duration = time.time() - start_time
-
-    print(f'There are {len(w3_multicall.calls)} calls')
-    print(f'Encode took {round(encode_time, 3)}s')
-    print(f'Done after {round(duration, 3)}s')
-
-    return duration, encode_time, len(w3_multicall.calls)
-
-
-def query_multi_contracts(n_times=20, wallets_batch_size=5, wallets_distribute_similar=True):
-    with open('../../../.data/wallets.json') as f:
-        wallets = json.load(f)
-    wallets = ['0x6FfA563915CB3186b9Dd206D0E08bdeDcd2EA2ED']
-
-    with open('../../../.data/tokens.json') as f:
-        tokens_ = json.load(f)
-    tokens_ = [
-        {
-            "address": "0xE2035f04040A135c4dA2f96AcA742143c57c79F9",
-            "name": "UXUY",
-            "symbol": "uxuy"
-        },
-        {
-            "address": "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
-            "name": "Tether",
-            "symbol": "usdt"
-        },
-        {
-            "address": "0x0000000000000000000000000000000000000000",
-            "name": "ETH",
-            "symbol": "ETH"
-        }
-    ]
-
-    print(f'There are maximum {len(wallets)} wallets')
-    print(f'There are {len(tokens_)} tokens')
-
-    if wallets_distribute_similar:
-        wallets_batch = [wallets[:300], wallets[:300], wallets[:300]]
-    else:
-        wallets_batch = [wallets[:300], wallets[300:600], wallets[600:900]]
-
-    # Methodology 1: Query State Lib
-    start_time = time.time()
-    client_querier = ClientQuerier(provider_url=Networks.providers['arbitrum'])
-    starting_time_1 = time.time() - start_time
-    logger.info(f'Starting state querier: {round(starting_time_1, 3)}s')
-
-    _multiple(
-        n_times=n_times, starting_time=starting_time_1, filename='query_state_lib',
-        wallets=wallets_batch[0], wallets_batch_size=wallets_batch_size, tokens=tokens_, func=_test_state_querier,
-        client_querier=client_querier
-    )
-
-    # Methodology 2: Multicall
-    start_time = time.time()
-    _w3 = Web3(Web3.HTTPProvider(Networks.providers['arbitrum']))
-    starting_time_2_1 = time.time() - start_time
-    multicall_address = MulticallContract.get_multicall_contract(Chains.arbitrum)
-    multicall_contract = _w3.eth.contract(Web3.to_checksum_address(multicall_address), abi=MULTICALL_V3_ABI)
-    starting_time_2 = time.time() - start_time
-    logger.info(f'Starting multicall: {round(starting_time_2, 3)}s')
-
-    _multiple(
-        n_times=n_times, starting_time=starting_time_2, filename='multicall',
-        wallets=wallets_batch[1], wallets_batch_size=wallets_batch_size, tokens=tokens_, func=_test_multicall,
-        _w3=_w3, multicall_contract=multicall_contract
-    )
-
-    # Methodology 3: Combine Multicall with multiprocessing
-    starting_time_3 = starting_time_1 + starting_time_2_1
-    logger.info(f'Starting combined: {round(starting_time_3, 3)}s')
-
-    _multiple(
-        n_times=n_times, starting_time=starting_time_3, filename='combined',
-        wallets=wallets_batch[2], wallets_batch_size=wallets_batch_size, tokens=tokens_,
-        func=_test_multicall_with_multiprocessing, _w3=_w3, client_querier=client_querier
-    )
-
-
-def _multiple(n_times, starting_time, filename, wallets, wallets_batch_size, tokens, func, *args, **kwargs):
-    data = [['Total Time', 'Encode Time']]
-    overview = {
-        'avg_total_time': 0, 'avg_encode_time': 0,
-        'times': 0, 'errors': 0,
-        'queries': 0, 'start_time': starting_time
-    }
-    for i in range(n_times):
-        idx = i * wallets_batch_size
-        sub_wallets = wallets[idx:idx + wallets_batch_size]
-        try:
-            total_time, encode_time, n_calls = func(wallets=sub_wallets, tokens=tokens, *args, **kwargs)
-
-            overview['queries'] = n_calls
-            data.append([total_time, encode_time])
-            overview['times'] += 1
-        except Exception as ex:
-            logger.exception(ex)
-            overview['errors'] += 1
-        finally:
-            time.sleep(13)
-
-    with open(f'results_{filename}.csv', 'w') as f:
-        writer = csv.writer(f)
-        writer.writerows(data)
-
-    overview['avg_total_time'] = sum([t[0] for t in data[1:]]) / overview['times']
-    overview['avg_encode_time'] = sum([t[1] for t in data[1:]]) / overview['times']
-    with open(f'overview_results_{filename}.json', 'w') as f:
-        json.dump(overview, f, indent=2)
-
-
-if __name__ == '__main__':
-    query_multi_contracts(n_times=1, wallets_batch_size=1, wallets_distribute_similar=True)

defi_services/services/vault/tcv_vault_services.py

@@ -0,0 +1,108 @@
+import logging
+
+from defi_services.abis.vault.tcv_abi import TCV_ABI
+from defi_services.constants.chain_constant import Chain
+from defi_services.constants.entities.vault_constant import Vault
+from defi_services.constants.token_constant import Token
+from defi_services.jobs.queriers.state_querier import StateQuerier
+from defi_services.services.protocol_services import ProtocolServices
+from defi_services.services.vault.vault_info.arbitrum.tcv_arb import TCV_VAULT_ARBITRUM
+
+logger = logging.getLogger("Trava Vault State Service")
+
+
+class TCVVaultInfo:
+    mapping = {
+        Chain.arbitrum: TCV_VAULT_ARBITRUM
+    }
+
+
+class TCVVaultStateService(ProtocolServices):
+    def __init__(self, state_service: StateQuerier, chain_id: str = "0xa4b1"):
+        super().__init__()
+        self.name = f"{chain_id}_{Vault.tcv_vault}"
+        self.chain_id = chain_id
+        self.pool_info = TCVVaultInfo.mapping.get(chain_id)
+        self.vault_abi = TCV_ABI
+        self.state_service = state_service
+
+    # BASIC FUNCTION
+    def get_service_info(self):
+        info = {
+            Vault.tcv_vault: {
+                "chain_id": self.chain_id,
+                "type": "vault",
+                "protocol_info": self.pool_info
+            }
+        }
+        return info
+
+    def get_token_list(self):
+        reward_token = self.pool_info.get('rewardToken')
+
+        tokens = []
+        if isinstance(reward_token, list):
+            tokens += reward_token
+        elif isinstance(reward_token, str):
+            tokens.append(reward_token)
+
+        for token, info in self.pool_info.get("reservesList", {}).items():
+            asset_address = info['tokenIn']
+            if asset_address == Token.native_token:
+                tokens.append(Token.wrapped_token.get(self.chain_id))
+            else:
+                tokens.append(asset_address)
+
+        tokens = list(set(tokens))
+        return tokens
+
+    # WALLET STAKING BALANCE
+    def get_wallet_staking_balance_function_info(
+            self,
+            wallet: str,
+            reserves_info: dict,
+            block_number: int = "latest",
+            return_reward: bool = False
+    ):
+        rpc_calls = {}
+        for token in reserves_info:
+            rpc_calls[f'currentNow_{token}_{wallet}_{block_number}'.lower()] = self.state_service.get_function_info(
+                token, TCV_ABI, "currentNow", [wallet], block_number=block_number)
+            rpc_calls[f'totalLiquidityNFT_{token}_{wallet}_{block_number}'.lower()] = self.state_service.get_function_info(
+                token, TCV_ABI, "totalLiquidityNFT", block_number=block_number)
+
+        return rpc_calls
+
+    def calculate_wallet_staking_balance(
+            self,
+            wallet: str,
+            reserves_info: dict,
+            decoded_data: dict,
+            token_prices: dict,
+            block_number: int = 'latest',
+            return_reward: bool = False
+    ):
+        result = {}
+        for token, information in reserves_info.items():
+            liquidity_user_key = f'currentNow_{token}_{wallet}_{block_number}'.lower()
+            liquidity_of_vault_key = f'totalLiquidityNFT_{token}_{wallet}_{block_number}'.lower()
+            liquidity_user = decoded_data[liquidity_user_key]
+            liquidity_of_vault = decoded_data[liquidity_of_vault_key]
+            result[token] = {
+                "liquidity_user": liquidity_user,
+                "liquidity_of_vault": liquidity_of_vault
+            }
+        return result
+
+    # REWARDS BALANCE
+    def get_rewards_balance_function_info(
+            self,
+            wallet,
+            reserves_info: dict = None,
+            block_number: int = "latest"
+    ):
+        pass
+
+    def calculate_rewards_balance(
+            self, wallet: str, reserves_info: dict, decoded_data: dict, block_number: int = "latest"):
+        pass

defi_services/services/vault/vault_info/arbitrum/tcv_arb.py

@@ -0,0 +1,58 @@
+TCV_VAULT_ARBITRUM = {
+    "name": "TCV Vault",
+    "rewardToken": "0x3cd16d9372fc938ac84444d1f47701bb4faa97ec",
+    "airdropAddress": "0x9094264783f48880c12e703cdd1f11c4dff7f1ac",
+    "reservesList": {
+        "0xe467db55710cf35e2dc0402104e23221f0e12e66": {
+            "vaultName": "eth/usdc",
+            "tokenIn": "0xe467db55710cf35e2dc0402104e23221f0e12e66",
+            "pool": '0xc6962004f452be9203591991d15f6b388e09e8d0',
+            "poolInfo": {
+                "token0": "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+                "token1": "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+                "fee": 500
+            }
+        },
+        "0x9403be93fddedf88a3ed7d11bfb643b13e5cbc27": {
+            "vaultName": "eth/usdt",
+            "tokenIn": "0x9403be93fddedf88a3ed7d11bfb643b13e5cbc27",
+            "pool": '0x641c00a822e8b671738d32a431a4fb6074e5c79d',
+            "poolInfo": {
+                "token0": "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+                "token1": "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+                "fee": 500
+            }
+
+        },
+        "0xae83866e6b48e29b225a10bc236f2665cc4f081e": {
+            "vaultName": "eth/arb",
+            "tokenIn": "0xae83866e6b48e29b225a10bc236f2665cc4f081e",
+            "pool": '0xc6f780497a95e246eb9449f5e4770916dcd6396a',
+            "poolInfo": {
+                "token0": "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+                "token1": "0x912ce59144191c1204e64559fe8253a0e49e6548",
+                "fee": 500
+            }
+        },
+        "0xaae3866f0233aec20580c21a3c10791afd38c8c1": {
+            "vaultName": "eth/usdc(bridgeusdc)",
+            "tokenIn": "0xaae3866f0233aec20580c21a3c10791afd38c8c1",
+            "pool": '0xc31e54c7a869b9fcbecc14363cf510d1c41fa443',
+            "poolInfo": {
+                "token0": "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+                "token1": "0xff970a61a04b1ca14834a43f5de4533ebddb5cc8",
+                "fee": 500
+            }
+        },
+        "0xa02d1ecbe8eefaf7d64871ee0ae6404318df9702": {
+            "vaultName": "eth/usdc",
+            "tokenIn": "0xa02d1ecbe8eefaf7d64871ee0ae6404318df9702",
+            "pool": '0xc473e2aee3441bf9240be85eb122abb059a3b57c',
+            "poolInfo": {
+                "token0": "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+                "token1": "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+                "fee": 3000
+            }
+        }
+    }
+}

{defi_state_querier-0.5.28.dist-info → defi_state_querier-0.5.30.dist-info}/METADATA

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