defi-state-querier 0.4.23__tar.gz → 0.4.24__tar.gz

{defi-state-querier-0.4.23 → defi-state-querier-0.4.24}/PKG-INFO

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

defi-state-querier-0.4.24/src/defi_services/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.24"

{defi-state-querier-0.4.23 → defi-state-querier-0.4.24}/src/defi_services/services/dex/dex_info/pancakeswap_info.py

@@ -22,14 +22,14 @@ PANCAKESWAP_V2_BSC_INFO = {
 }
 
 PANCAKESWAP_V3_BSC_INFO = {
-    'factory_address': '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+    'factory_address': '0x0bfbcf9fa4f9c56b0f40a671ad40e0805a091865',
     'factory_abi': PANCAKESWAP_V3_FACTORY_ABI,
-    'master_chef_address': '0x556B9306565093C855AEA9AE92A594704c2Cd59e',
+    'master_chef_address': '0x556b9306565093c855aea9ae92a594704c2cd59e',
     'master_chef_abi': PANCAKESWAP_MASTERCHEF_V3_ABI,
-    "reward_token": "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82".lower(),
-    "NFT_manager_address": "0x46A15B0b27311cedF172AB29E4f4766fbE7F4364".lower(),
+    "NFT_manager_address": "0x46a15b0b27311cedf172ab29e4f4766fbe7f4364",
     "NFT_manager_abi": PANCAKE_V3_NON_FUNGIBLE_POSITION_TOKEN_ABI,
     'pool_abi': PANCAKESWAP_V3_POOL_ABI,
-    'forked': 'uniswap-v3'
+    'forked': 'uniswap-v3',
+    "reward_token": "0x0e09fabb73bd3ade0a17ecc321fd13a19e81ce82",
 
 }

{defi-state-querier-0.4.23 → defi-state-querier-0.4.24}/src/defi_services/services/dex/dex_info/quickswap_info.py

@@ -14,9 +14,9 @@ QUICKSWAP_POLYGON_V3_INFO = {
     "NFT_manager_address": "0x8ef88e4c7cfbbac1c163f7eddd4b578792201de6",
     "NFT_manager_abi": QUICKSWAP_V3_NON_FUNGIBLE_POSITION_TOKEN_ABI,
     'pool_abi':QUICKSWAP_V3_POOL_ABI,
-    'finite_farming': '0x9923f42a02A82dA63EE0DbbC5f8E311e3DD8A1f8',
-    'infinite_farming': '0x8a26436e41d0b5fc4C6Ed36C1976fafBe173444E',
-    'farming_center': '0x7F281A8cdF66eF5e9db8434Ec6D97acc1bc01E78',
+    'finite_farming': '0x9923f42a02a82da63ee0dbbc5f8e311e3dd8a1f8',
+    'infinite_farming': '0x8a26436e41d0b5fc4c6ed36c1976fafbe173444e',
+    'farming_center': '0x7f281a8cdf66ef5e9db8434ec6d97acc1bc01e78',
     'forked': 'uniswap-v3'
 
 }

{defi-state-querier-0.4.23 → defi-state-querier-0.4.24}/src/defi_services/services/dex/pancakeswap_v3_service.py

@@ -8,6 +8,7 @@ from defi_services.constants.entities.dex_constant import Dex
 from defi_services.jobs.queriers.state_querier import StateQuerier
 from defi_services.services.dex.dex_info.pancakeswap_info import PANCAKESWAP_V3_BSC_INFO
 from defi_services.services.dex.uniswap_v3_service import UniswapV3Services
+from defi_services.utils.get_fees import get_fees
 from defi_services.utils.sqrt_price_math import get_token_amount_of_pool, get_token_amount_of_user
 
 logger = logging.getLogger("PancakeSwap V3 State Service")
@@ -199,8 +200,7 @@ class PancakeSwapV3Service(UniswapV3Services):
 
     def decode_all_nft_token_of_user_function(
             self, decode_data: dict):
-        result = {'all_token': {}, 'stake_token': {}}
-        result['all_token'] = super().decode_all_nft_token_of_user_function(decode_data)
+        result = {'all_token': super().decode_all_nft_token_of_user_function(decode_data), 'stake_token': {}}
 
         for query_id, token_id in decode_data.items():
             contract_addr = query_id.split("_")[1]
@@ -235,33 +235,31 @@ class PancakeSwapV3Service(UniswapV3Services):
     def decode_user_info_function(self, user: str, supplied_data: dict, decoded_data: dict = None,
                                   stake: bool = True,
                                   block_number: int = "latest"):
-        user_data = supplied_data['user_data']
-        supplied_param = {'user_data': user_data['all_token']}
-        user_data['all_token'] = super().decode_user_info_function(user, supplied_param, decoded_data, stake,
-                                                                   block_number)
+        supplied_param = {'user_data': supplied_data['user_data'].get('all_token')}
+        user_data_with_liquidity = {
+            'all_token': super().decode_user_info_function(user, supplied_param, decoded_data, stake,
+                                                           block_number), 'stake_token': {}}
 
-        for token_id, value in user_data['stake_token'].items():
+        for token_id, value in supplied_data['user_data'].get('stake_token').items():
             master_chef_position = decoded_data.get(
                 f'userPositionInfos_{self.masterchef_addr}_{token_id}_{block_number}'.lower())
-            pending_cake = decoded_data.get(f'pendingCake_{self.masterchef_addr}_{token_id}_{block_number}'.lower())
-            nft_position = decoded_data.get(
-                f'positions_{self.nft_token_manager_addr}_{token_id}_{block_number}'.lower())
-
-            user_data['stake_token'][token_id].update({
-                'liquidity': master_chef_position[0],
-                'tick_lower': master_chef_position[2],
-                'tick_upper': master_chef_position[3],
-                'reward': master_chef_position[5] / 10 ** 18,
-                'farming_pid': master_chef_position[7],
-                'pending_cake': pending_cake / 10 ** 18,
-                'fee_growth_inside0': nft_position[8],
-                'fee_growth_inside1': nft_position[9],
-                'tokens_owed0': nft_position[10],
-                'tokens_owed1': nft_position[11]
-
-            })
-
-        return user_data
+            liquidity = master_chef_position[0]
+            if liquidity > 0:
+                nft_position = decoded_data.get(
+                    f'positions_{self.nft_token_manager_addr}_{token_id}_{block_number}'.lower())
+                user_data_with_liquidity['stake_token'][token_id] = {
+                    'liquidity': master_chef_position[0],
+                    'tick_lower': master_chef_position[2],
+                    'tick_upper': master_chef_position[3],
+                    'reward': master_chef_position[5] / 10 ** 18,
+                    'farming_pid': master_chef_position[7],
+                    'pending_cake': decoded_data.get(
+                        f'pendingCake_{self.masterchef_addr}_{token_id}_{block_number}'.lower()) / 10 ** 18,
+                    'fee_growth_inside0_x128': nft_position[8],
+                    'fee_growth_inside1_x128': nft_position[9],
+                }
+
+        return user_data_with_liquidity
 
     def get_user_token_amount_function(self, user: str, supplied_data: dict, block_number: int = "latest"):
         user_data = supplied_data['user_data']
@@ -280,7 +278,6 @@ class PancakeSwapV3Service(UniswapV3Services):
                                           block_number: int = "latest"):
         user_data = supplied_data['user_data']
         lp_token_info = supplied_data['lp_token_info']
-
         supplied_param = {'user_data': user_data['all_token'],
                           'lp_token_info': lp_token_info}
         user_data['all_token'] = super().decode_user_token_amount_function(user, supplied_param, decoded_data,
@@ -292,28 +289,24 @@ class PancakeSwapV3Service(UniswapV3Services):
                 'pool_address': lp_token_address
             })
             liquidity = value.get('liquidity')
-            if liquidity > 0:
-                token0_decimals = lp_token_info.get(lp_token_address, {}).get("token0_decimals")
-                token1_decimals = lp_token_info.get(lp_token_address, {}).get("token1_decimals")
-                price = lp_token_info.get(lp_token_address, {}).get("price")
-
-                tick = lp_token_info.get(lp_token_address, {}).get('tick')
-                tick_lower = value.get('tick_lower')
-                tick_upper = value.get('tick_upper')
-                if price and tick:
-                    sqrt_price_x96 = math.sqrt(price) * 2 ** 96
-
-                    token0_amount, token1_amount = get_token_amount_of_user(liquidity=liquidity,
-                                                                            sqrt_price_x96=sqrt_price_x96,
-                                                                            tick=tick, tick_upper=tick_upper,
-                                                                            tick_lower=tick_lower)
-
-                    user_data['stake_token'][token_id].update(
-                        {
-                            'token0_amount': token0_amount / 10 ** token0_decimals,
-                            'token1_amount': token1_amount / 10 ** token1_decimals,
-                        }
-                    )
+            token0_decimals = lp_token_info.get(lp_token_address, {}).get("token0_decimals")
+            token1_decimals = lp_token_info.get(lp_token_address, {}).get("token1_decimals")
+            price = lp_token_info.get(lp_token_address, {}).get("price")
+            tick = lp_token_info.get(lp_token_address, {}).get('tick')
+            tick_lower = value.get('tick_lower')
+            tick_upper = value.get('tick_upper')
+            if price and tick:
+                sqrt_price_x96 = math.sqrt(price) * 2 ** 96
+                token0_amount, token1_amount = get_token_amount_of_user(liquidity=liquidity,
+                                                                        sqrt_price_x96=sqrt_price_x96,
+                                                                        tick=tick, tick_upper=tick_upper,
+                                                                        tick_lower=tick_lower)
+                user_data['stake_token'][token_id].update(
+                    {
+                        'token0_amount': token0_amount / 10 ** token0_decimals,
+                        'token1_amount': token1_amount / 10 ** token1_decimals,
+                    }
+                )
         return user_data
 
     def get_rewards_balance_function_info(self, user, supplied_data, block_number: int = "latest"):
@@ -324,11 +317,15 @@ class PancakeSwapV3Service(UniswapV3Services):
             lp_token_address = value.get('pool_address')
             tick_lower = value.get('tick_lower')
             tick_upper = value.get('tick_upper')
-            position_key = self.get_position_key(tick_lower, tick_upper)
-            query_id = f'positions_{lp_token_address}_{[tick_upper, tick_lower]}_{block_number}'.lower()
-            rpc_calls[query_id] = self.state_service.get_function_info(
-                address=lp_token_address, abi=self.pool_info['pool_abi'], fn_name="positions", fn_paras=[position_key]
-            )
+            for fnc in ['feeGrowthGlobal0X128', 'feeGrowthGlobal1X128']:
+                query_id = f'{fnc}_{lp_token_address}_{block_number}'.lower()
+                rpc_calls[query_id] = self.state_service.get_function_info(
+                    address=lp_token_address, abi=self.pool_info['pool_abi'], fn_name=fnc)
+
+            for param in [tick_lower, tick_upper]:
+                query_id = f'ticks_{lp_token_address}_{param}_{block_number}'.lower()
+                rpc_calls[query_id] = self.state_service.get_function_info(
+                    address=lp_token_address, abi=self.pool_info['pool_abi'], fn_name="ticks", fn_paras=[param])
         return rpc_calls
 
     def calculate_rewards_balance(
@@ -338,39 +335,40 @@ class PancakeSwapV3Service(UniswapV3Services):
 
         supplied_param = {'user_data': user_data['all_token'],
                           'lp_token_info': lp_token_info}
-        user_data['all_token'] = super().calculate_rewards_balance(user, supplied_param, decoded_data,
-                                                                   block_number)
+        user_data['all_token'] = super().calculate_rewards_balance(user, supplied_param, decoded_data, block_number)
         for token_id, value in user_data['stake_token'].items():
+            lp_token_address = value.get('pool_address')
+            tick_lower = value.get('tick_lower')
+            tick_upper = value.get('tick_upper')
+            fee_growth_inside_0_x128 = value.get('fee_growth_inside0_x128')
+            fee_growth_inside_1_x128 = value.get('fee_growth_inside1_x128')
+            fee_growth_global_0 = decoded_data.get(f'feeGrowthGlobal0X128_{lp_token_address}_{block_number}'.lower())
+            fee_growth_global_1 = decoded_data.get(f'feeGrowthGlobal1X128_{lp_token_address}_{block_number}'.lower())
+            fee_growth_0_low_x128 = decoded_data.get(f'ticks_{lp_token_address}_{tick_lower}_{block_number}'.lower())[2]
+            fee_growth_1_low_x128 = decoded_data.get(f'ticks_{lp_token_address}_{tick_lower}_{block_number}'.lower())[3]
+            fee_growth_0_hi_x128 = decoded_data.get(f'ticks_{lp_token_address}_{tick_upper}_{block_number}'.lower())[2]
+            fee_growth_1_hi_x128 = decoded_data.get(f'ticks_{lp_token_address}_{tick_upper}_{block_number}'.lower())[3]
             liquidity = value.get('liquidity')
-            if liquidity > 0:
-                try:
-                    lp_token_address = value.get('pool_address')
-                    tick_lower = value.get('tick_lower')
-                    tick_upper = value.get('tick_upper')
-                    pool_position = decoded_data.get(
-                        f'positions_{lp_token_address}_{[tick_upper, tick_lower]}_{block_number}'.lower())
-
-                    pool_fee_growth_inside0 = pool_position[1]
-                    pool_fee_growth_inside1 = pool_position[2]
-                    fee_growth_inside0 = value.get('fee_growth_inside0')
-                    fee_growth_inside1 = value.get('fee_growth_inside1')
-                    liquidity = value.get('liquidity')
-                    token0_decimals = lp_token_info.get(lp_token_address, {}).get("token0_decimals")
-                    token1_decimals = lp_token_info.get(lp_token_address, {}).get("token1_decimals")
-                    token0_reward = ((pool_fee_growth_inside0 - fee_growth_inside0) / 2 ** 128 * liquidity + value.get(
-                        'tokens_owed0')) / 10 ** token0_decimals
-                    token1_reward = ((pool_fee_growth_inside1 - fee_growth_inside1) / 2 ** 128 * liquidity + value.get(
-                        'tokens_owed1')) / 10 ** token1_decimals
-                except Exception:
-                    continue
-
-            else:
-                token0_reward = 0
-                token1_reward = 0
-
-            user_data['stake_token'][token_id].update({
-                'token0_reward': token0_reward,
-                'token1_reward': token1_reward
-            })
+            token0_decimals = lp_token_info.get(lp_token_address, {}).get("token0_decimals")
+            token1_decimals = lp_token_info.get(lp_token_address, {}).get("token1_decimals")
+            tick = lp_token_info.get(lp_token_address, {}).get('tick')
+            if tick and token0_decimals and token1_decimals:
+                token0_reward, token1_reward = get_fees(
+                    fee_growth_global_0=fee_growth_global_0,
+                    fee_growth_global_1=fee_growth_global_1,
+                    fee_growth_0_low=fee_growth_0_low_x128,
+                    fee_growth_1_low=fee_growth_1_low_x128,
+                    fee_growth_0_hi=fee_growth_0_hi_x128,
+                    fee_growth_1_hi=fee_growth_1_hi_x128,
+                    fee_growth_inside_0=fee_growth_inside_0_x128,
+                    fee_growth_inside_1=fee_growth_inside_1_x128,
+                    liquidity=liquidity, tick_lower=tick_lower,
+                    tick_upper=tick_upper, tick_current=tick,
+                    decimals0=token0_decimals, decimals1=token1_decimals)
+
+                user_data['stake_token'][token_id].update({
+                    'token0_reward': token0_reward,
+                    'token1_reward': token1_reward
+                })
 
         return user_data

{defi-state-querier-0.4.23 → defi-state-querier-0.4.24}/src/defi_services/services/dex/quickswap_v3_service.py

@@ -5,6 +5,7 @@ from defi_services.constants.entities.dex_constant import Dex
 from defi_services.jobs.queriers.state_querier import StateQuerier
 from defi_services.services.dex.dex_info.quickswap_info import QUICKSWAP_POLYGON_V3_INFO
 from defi_services.services.dex.uniswap_v3_service import UniswapV3Services
+from defi_services.utils.get_fees import get_fees
 
 logger = logging.getLogger("QuickSwap V3 State Service")
 
@@ -116,21 +117,21 @@ class QuickSwapV3Services(UniswapV3Services):
     def decode_user_info_function(self, user: str, supplied_data: dict, decoded_data: dict = None, stake: bool = False,
                                   block_number: int = "latest"):
         user_data = supplied_data['user_data']
+        user_data_with_liquidity = {}
         for token_id, value in user_data.items():
             position = decoded_data.get(f'positions_{self.nft_token_manager_addr}_{token_id}_{block_number}'.lower())
-            user_data[token_id].update({
-                'token0': position[2],
-                'token1': position[3],
-                'tick_lower': position[4],
-                'tick_upper': position[5],
-                'liquidity': position[6],
-                'fee_growth_inside0': position[7],
-                'fee_growth_inside1': position[8],
-                'tokens_owed0': position[9],
-                'tokens_owed1': position[10]
-
-            })
-        return user_data
+            liquidity = position[6]
+            if liquidity > 0:
+                user_data_with_liquidity[token_id] = {
+                    'token0': position[2],
+                    'token1': position[3],
+                    'tick_lower': position[4],
+                    'tick_upper': position[5],
+                    'liquidity': liquidity,
+                    'fee_growth_inside0_x128': position[7],
+                    'fee_growth_inside1_x128': position[8],
+                }
+        return user_data_with_liquidity
 
     def get_user_token_amount_function(self, user: str, supplied_data: dict, block_number: int = "latest"):
         user_data = supplied_data['user_data']
@@ -138,7 +139,7 @@ class QuickSwapV3Services(UniswapV3Services):
         for token_id, value in user_data.items():
             token0 = value.get('token0')
             token1 = value.get('token1')
-            query_id = f'allPool_{self.factory_addr}_{token_id}_{block_number}'.lower()
+            query_id = f'getPool_{self.factory_addr}_{token_id}_{block_number}'.lower()
             rpc_calls[query_id] = self.state_service.get_function_info(
                 self.factory_addr, self.factory_abi, fn_name="poolByPair", fn_paras=[token0, token1]
             )
@@ -151,44 +152,65 @@ class QuickSwapV3Services(UniswapV3Services):
 
         return rpc_calls
 
+    def get_rewards_balance_function_info(self, user, supplied_data, block_number: int = "latest"):
+        user_data = supplied_data['user_data']
+        rpc_calls = {}
+        for token_id, value in user_data.items():
+            lp_token_address = value.get('pool_address')
+            tick_lower = value.get('tick_lower')
+            tick_upper = value.get('tick_upper')
+            for fnc in ['totalFeeGrowth0Token', 'totalFeeGrowth1Token']:
+                query_id = f'{fnc}_{lp_token_address}_{block_number}'.lower()
+                rpc_calls[query_id] = self.state_service.get_function_info(
+                    address=lp_token_address, abi=self.pool_info['pool_abi'], fn_name=fnc)
+
+            for param in [tick_lower, tick_upper]:
+                query_id = f'ticks_{lp_token_address}_{param}_{block_number}'.lower()
+                rpc_calls[query_id] = self.state_service.get_function_info(
+                    address=lp_token_address, abi=self.pool_info['pool_abi'], fn_name="ticks", fn_paras=[param])
+
+        return rpc_calls
+
     def calculate_rewards_balance(
             self, user: str, supplied_data: dict, decoded_data: dict, block_number: int = "latest"):
         lp_token_info = supplied_data['lp_token_info']
         user_data = supplied_data['user_data']
 
         for token_id, value in user_data.items():
+            lp_token_address = value.get('pool_address')
+            tick_lower = value.get('tick_lower')
+            tick_upper = value.get('tick_upper')
+            fee_growth_inside_0_x128 = value.get('fee_growth_inside0_x128')
+            fee_growth_inside_1_x128 = value.get('fee_growth_inside1_x128')
+            fee_growth_global_0 = decoded_data.get(
+                f'totalFeeGrowth0Token_{lp_token_address}_{block_number}'.lower())
+            fee_growth_global_1 = decoded_data.get(
+                f'totalFeeGrowth1Token_{lp_token_address}_{block_number}'.lower())
+            fee_growth_0_low_x128 = decoded_data.get(f'ticks_{lp_token_address}_{tick_lower}_{block_number}'.lower())[2]
+            fee_growth_1_low_x128 = decoded_data.get(f'ticks_{lp_token_address}_{tick_lower}_{block_number}'.lower())[3]
+            fee_growth_0_hi_x128 = decoded_data.get(f'ticks_{lp_token_address}_{tick_upper}_{block_number}'.lower())[2]
+            fee_growth_1_hi_x128 = decoded_data.get(f'ticks_{lp_token_address}_{tick_upper}_{block_number}'.lower())[3]
             liquidity = value.get('liquidity')
-            if liquidity > 0:
-                lp_token_address = value.get('pool_address')
-                tick_lower = value.get('tick_lower')
-                tick_upper = value.get('tick_upper')
-                pool_position = decoded_data.get(
-                    f'positions_{lp_token_address}_{[tick_upper, tick_lower]}_{block_number}'.lower())
-
-                pool_fee_growth_inside0 = pool_position[2]
-                pool_fee_growth_inside1 = pool_position[3]
-                fee_growth_inside0 = value.get('fee_growth_inside0')
-                fee_growth_inside1 = value.get('fee_growth_inside1')
-                liquidity = value.get('liquidity')
-                token0_decimals = lp_token_info.get(lp_token_address, {}).get("token0_decimals")
-                token1_decimals = lp_token_info.get(lp_token_address, {}).get("token1_decimals")
-                token0_reward = ((pool_fee_growth_inside0 - fee_growth_inside0) / 2 ** 128 * liquidity + value.get(
-                    'tokens_owed0')) / 10 ** token0_decimals
-                token1_reward = ((pool_fee_growth_inside1 - fee_growth_inside1) / 2 ** 128 * liquidity + value.get(
-                    'tokens_owed1')) / 10 ** token1_decimals
-
-            else:
-                token0_reward = 0
-                token1_reward = 0
-
-            user_data[token_id].update({
-                'token0_reward': token0_reward,
-                'token1_reward': token1_reward
-            })
-
-        return user_data
-
-    def get_position_key(self, tick_lower, tick_upper):
-        owner = int(self.nft_token_manager_addr, 16)
-        key = (((owner << 24) | (tick_lower & 0xFFFFFF)) << 24) | (tick_upper & 0xFFFFFF)
-        return '0x' + format(key, '064x')
+            tick = lp_token_info.get(lp_token_address, {}).get('tick')
+            token0_decimals = lp_token_info.get(lp_token_address, {}).get("token0_decimals")
+            token1_decimals = lp_token_info.get(lp_token_address, {}).get("token1_decimals")
+            if tick and token0_decimals and token1_decimals:
+                token0_reward, token1_reward = get_fees(
+                    fee_growth_global_0=fee_growth_global_0,
+                    fee_growth_global_1=fee_growth_global_1,
+                    fee_growth_0_low=fee_growth_0_low_x128,
+                    fee_growth_1_low=fee_growth_1_low_x128,
+                    fee_growth_0_hi=fee_growth_0_hi_x128,
+                    fee_growth_1_hi=fee_growth_1_hi_x128,
+                    fee_growth_inside_0=fee_growth_inside_0_x128,
+                    fee_growth_inside_1=fee_growth_inside_1_x128,
+                    liquidity=liquidity, tick_lower=tick_lower,
+                    tick_upper=tick_upper, tick_current=tick,
+                    decimals0=token0_decimals, decimals1=token1_decimals)
+
+                user_data[token_id].update({
+                    'token0_reward': token0_reward,
+                    'token1_reward': token1_reward
+                })
+
+        return user_data