User assets migration

src/__swaps__/screens/Swap/providers/SyncSwapStateAndSharedValues.tsx

@@ -15,7 +15,6 @@ import {
 import { ExtendedAnimatedAssetWithColors } from '@/__swaps__/types/assets';
 import { ChainId } from '@/chains/types';
 import { ParsedAddressAsset } from '@/entities';
-import { useUserNativeNetworkAsset } from '@/resources/assets/useUserAsset';
 import { CrosschainQuote, Quote, QuoteError } from '@rainbow-me/swaps';
 import { deepEqualWorklet } from '@/worklets/comparisons';
 import { debounce } from 'lodash';
@@ -26,6 +25,9 @@ import { GasSettings } from '../hooks/useCustomGas';
 import { useSelectedGas } from '../hooks/useSelectedGas';
 import { useSwapEstimatedGasLimit } from '../hooks/useSwapEstimatedGasLimit';
 import { useSwapContext } from './swap-provider';
+import { useUserAssetsStore } from '@/state/assets/userAssets';
+import { getUniqueId } from '@/utils/ethereumUtils';
+import { chainsNativeAsset } from '@/chains';
 
 const BUFFER_RATIO = 0.5;
 
@@ -143,7 +145,12 @@ export function SyncGasStateToSharedValues() {
   const { assetToSell, chainId = initialChainId, quote } = useSyncedSwapQuoteStore();
 
   const gasSettings = useSelectedGas(chainId);
-  const { data: userNativeNetworkAsset, isLoading: isLoadingNativeNetworkAsset } = useUserNativeNetworkAsset(chainId);
+
+  const { userNativeNetworkAsset, isLoadingNativeNetworkAsset } = useUserAssetsStore(state => {
+    const { address: nativeCurrencyAddress } = chainsNativeAsset[chainId];
+    const uniqueId = getUniqueId(nativeCurrencyAddress, chainId);
+    return { userNativeNetworkAsset: state.getLegacyUserAsset(uniqueId), isLoadingNativeNetworkAsset: state.isLoadingUserAssets };
+  });
   const { data: estimatedGasLimit } = useSwapEstimatedGasLimit({ chainId, assetToSell, quote });
 
   const gasFeeRange = useSharedValue<[string, string] | null>(null);

src/__swaps__/screens/Swap/providers/swap-provider.tsx

@@ -22,7 +22,7 @@ import { NavigationSteps, useSwapNavigation } from '@/__swaps__/screens/Swap/hoo
 import { useSwapSettings } from '@/__swaps__/screens/Swap/hooks/useSwapSettings';
 import { useSwapTextStyles } from '@/__swaps__/screens/Swap/hooks/useSwapTextStyles';
 import { SwapWarningType, useSwapWarning } from '@/__swaps__/screens/Swap/hooks/useSwapWarning';
-import { userAssetsQueryKey as swapsUserAssetsQueryKey } from '@/__swaps__/screens/Swap/resources/assets/userAssets';
+import { userAssetsQueryKey } from '@/__swaps__/screens/Swap/resources/assets/userAssets';
 import { AddressOrEth, ExtendedAnimatedAssetWithColors, ParsedSearchAsset } from '@/__swaps__/types/assets';
 import { ChainId } from '@/chains/types';
 import { SwapAssetType, inputKeys } from '@/__swaps__/types/swap';
@@ -41,7 +41,6 @@ import Routes from '@/navigation/routesNames';
 import { walletExecuteRap } from '@/raps/execute';
 import { QuoteTypeMap, RapSwapActionParameters } from '@/raps/references';
 import { queryClient } from '@/react-query';
-import { userAssetsQueryKey } from '@/resources/assets/UserAssetsQuery';
 import { userAssetsStore } from '@/state/assets/userAssets';
 import { swapsStore } from '@/state/swaps/swapsStore';
 import { haptics } from '@/utils';
@@ -308,14 +307,7 @@ export const SwapProvider = ({ children }: SwapProviderProps) => {
         userAssetsQueryKey({
           address: parameters.quote.from,
           currency: nativeCurrency,
-          connectedToHardhat,
-        })
-      );
-      queryClient.invalidateQueries(
-        swapsUserAssetsQueryKey({
-          address: parameters.quote.from as Address,
-          currency: nativeCurrency,
-          testnetMode: !!connectedToHardhat,
+          testnetMode: connectedToHardhat,
         })
       );
 

src/__swaps__/screens/Swap/resources/assets/userAssets.ts

@@ -17,6 +17,8 @@ import { fetchUserAssetsByChain } from './userAssetsByChain';
 import { fetchHardhatBalancesByChainId } from '@/resources/assets/hardhatAssets';
 import { SUPPORTED_CHAIN_IDS } from '@/chains';
 import { useConnectedToHardhatStore } from '@/state/connectedToHardhat';
+import { staleBalancesStore } from '@/state/staleBalances';
+import { IS_TEST } from '@/env';
 
 const addysHttp = new RainbowFetchClient({
   baseURL: 'https://addys.p.rainbow.me/v3',
@@ -27,7 +29,7 @@ const addysHttp = new RainbowFetchClient({
 
 const USER_ASSETS_REFETCH_INTERVAL = 60000;
 const USER_ASSETS_TIMEOUT_DURATION = 20000;
-export const USER_ASSETS_STALE_INTERVAL = 30000;
+const USER_ASSETS_STALE_INTERVAL = 30000;
 
 // ///////////////////////////////////////////////
 // Query Types
@@ -70,7 +72,7 @@ type UserAssetsQueryKey = ReturnType<typeof userAssetsQueryKey>;
 // Query Function
 
 export const userAssetsFetchQuery = ({ address, currency, testnetMode }: FetchUserAssetsArgs) => {
-  queryClient.fetchQuery(userAssetsQueryKey({ address, currency, testnetMode }), userAssetsQueryFunction);
+  return queryClient.fetchQuery(userAssetsQueryKey({ address, currency, testnetMode }), userAssetsQueryFunction);
 };
 
 export const userAssetsSetQueryDefaults = ({ address, currency, staleTime, testnetMode }: SetUserDefaultsArgs) => {
@@ -109,26 +111,28 @@ async function userAssetsQueryFunction({
 
     return parsedAssetsDict;
   }
+
   const cache = queryClient.getQueryCache();
   const cachedUserAssets = (cache.find(userAssetsQueryKey({ address, currency, testnetMode }))?.state?.data ||
     {}) as ParsedAssetsDictByChain;
   try {
-    const url = `/${SUPPORTED_CHAIN_IDS.join(',')}/${address}/assets`;
+    staleBalancesStore.getState().clearExpiredData(address);
+    const staleBalanceParam = staleBalancesStore.getState().getStaleBalancesQueryParam(address);
+    let url = `/${SUPPORTED_CHAIN_IDS.join(',')}/${address}/assets?currency=${currency.toLowerCase()}`;
+    if (staleBalanceParam) {
+      url += staleBalanceParam;
+    }
     const res = await addysHttp.get<AddressAssetsReceivedMessage>(url, {
-      params: {
-        currency: currency.toLowerCase(),
-      },
       timeout: USER_ASSETS_TIMEOUT_DURATION,
     });
     const chainIdsInResponse = res?.data?.meta?.chain_ids || [];
     const chainIdsWithErrorsInResponse = res?.data?.meta?.chain_ids_with_errors || [];
-    const assets = res?.data?.payload?.assets || [];
+    const assets = res?.data?.payload?.assets?.filter(asset => asset.asset.defi_position === false) || [];
     if (address) {
       userAssetsQueryFunctionRetryByChain({
         address,
         chainIds: chainIdsWithErrorsInResponse,
         currency,
-        testnetMode,
       });
       if (assets.length && chainIdsInResponse.length) {
         const parsedAssetsDict = await parseUserAssets({
@@ -160,17 +164,15 @@ async function userAssetsQueryFunctionRetryByChain({
   address,
   chainIds,
   currency,
-  testnetMode,
 }: {
   address: Address | string;
   chainIds: ChainId[];
   currency: SupportedCurrencyKey;
-  testnetMode?: boolean;
 }) {
   try {
     const cache = queryClient.getQueryCache();
     const cachedUserAssets =
-      (cache.find(userAssetsQueryKey({ address, currency, testnetMode }))?.state?.data as ParsedAssetsDictByChain) || {};
+      (cache.find(userAssetsQueryKey({ address, currency, testnetMode: false }))?.state?.data as ParsedAssetsDictByChain) || {};
     const retries = [];
     for (const chainIdWithError of chainIds) {
       retries.push(
@@ -191,7 +193,7 @@ async function userAssetsQueryFunctionRetryByChain({
         cachedUserAssets[values[0].chainId] = parsedAssets;
       }
     }
-    queryClient.setQueryData(userAssetsQueryKey({ address, currency, testnetMode }), cachedUserAssets);
+    queryClient.setQueryData(userAssetsQueryKey({ address, currency, testnetMode: false }), cachedUserAssets);
   } catch (e) {
     logger.error(new RainbowError('[userAssetsQueryFunctionRetryByChain]: Failed to retry fetching user assets'), {
       message: (e as Error)?.message,
@@ -240,6 +242,6 @@ export function useUserAssets<TSelectResult = UserAssetsResult>(
   return useQuery(userAssetsQueryKey({ address, currency, testnetMode: connectedToHardhat }), userAssetsQueryFunction, {
     ...config,
     refetchInterval: USER_ASSETS_REFETCH_INTERVAL,
-    staleTime: process.env.IS_TESTING === 'true' ? 0 : 1000,
+    staleTime: IS_TEST ? 0 : USER_ASSETS_STALE_INTERVAL,
   });
 }

src/__swaps__/screens/Swap/resources/assets/userAssetsByChain.ts

@@ -11,6 +11,7 @@ import { RainbowError, logger } from '@/logger';
 import { parseUserAssets, userAssetsQueryKey } from './userAssets';
 import { RainbowFetchClient } from '@/rainbow-fetch';
 import { ADDYS_API_KEY } from 'react-native-dotenv';
+import { staleBalancesStore } from '@/state/staleBalances';
 
 const USER_ASSETS_REFETCH_INTERVAL = 60000;
 
@@ -66,10 +67,15 @@ export async function userAssetsByChainQueryFunction({
   const cachedUserAssets = (cache.find(userAssetsQueryKey({ address, currency }))?.state?.data || {}) as ParsedAssetsDictByChain;
   const cachedDataForChain = cachedUserAssets?.[chainId];
   try {
-    const url = `/${chainId}/${address}/assets/?currency=${currency.toLowerCase()}`;
+    staleBalancesStore.getState().clearExpiredData(address);
+    const staleBalanceParam = staleBalancesStore.getState().getStaleBalancesQueryParam(address);
+    let url = `/${chainId}/${address}/assets/?currency=${currency.toLowerCase()}`;
+    if (staleBalanceParam) {
+      url += staleBalanceParam;
+    }
     const res = await addysHttp.get<AddressAssetsReceivedMessage>(url);
     const chainIdsInResponse = res?.data?.meta?.chain_ids || [];
-    const assets = res?.data?.payload?.assets || [];
+    const assets = res?.data?.payload?.assets?.filter(asset => asset.asset.defi_position === false) || [];
     if (assets.length && chainIdsInResponse.length) {
       const parsedAssetsDict = await parseUserAssets({
         assets,

src/__swaps__/types/assets.ts

@@ -140,6 +140,7 @@ export interface ZerionAsset {
     bridgeable: boolean;
     networks: { [id in ChainId]?: { bridgeable: boolean } };
   };
+  defi_position?: boolean;
 }
 
 // protocols https://github.com/rainbow-me/go-utils-lib/blob/master/pkg/enums/token_type.go#L44

src/__swaps__/utils/assets.ts

@@ -246,37 +246,6 @@ export function parseUserAssetBalances({
   };
 }
 
-export function parseParsedUserAsset({
-  parsedAsset,
-  currency,
-  quantity,
-}: {
-  parsedAsset: ParsedUserAsset;
-  currency: SupportedCurrencyKey;
-  quantity: string;
-}): ParsedUserAsset {
-  const amount = convertRawAmountToDecimalFormat(quantity, parsedAsset?.decimals);
-  return {
-    ...parsedAsset,
-    balance: {
-      amount,
-      display: convertAmountToBalanceDisplay(amount, {
-        decimals: parsedAsset?.decimals,
-        symbol: parsedAsset?.symbol,
-      }),
-    },
-    native: {
-      ...parsedAsset.native,
-      balance: getNativeAssetBalance({
-        currency,
-        decimals: parsedAsset?.decimals,
-        priceUnit: parsedAsset?.price?.value || 0,
-        value: amount,
-      }),
-    },
-  };
-}
-
 export const parseSearchAsset = ({
   assetWithPrice,
   searchAsset,

src/components/asset-list/AssetListHeader.js

@@ -12,11 +12,11 @@ import { StickyHeader } from './RecyclerAssetList2/core/StickyHeaders';
 import { useAccountProfile, useDimensions } from '@/hooks';
 import { useNavigation } from '@/navigation';
 import Routes from '@/navigation/routesNames';
-import { useUserAssetCount } from '@/resources/assets/useUserAssetCount';
 import styled from '@/styled-thing';
 import { fonts, position } from '@/styles';
 import { useTheme } from '@/theme';
 import * as lang from '@/languages';
+import { useUserAssetsStore } from '@/state/assets/userAssets';
 
 export const AssetListHeaderHeight = ListHeaderHeight;
 
@@ -104,7 +104,7 @@ const AssetListHeader = ({ contextMenuOptions, isCoinListEdited, title, totalVal
   const { width: deviceWidth } = useDimensions();
   const { accountName } = useAccountProfile();
   const { navigate } = useNavigation();
-  const { isLoading: isLoadingUserAssets } = useUserAssetCount();
+  const { isLoadingUserAssets } = useUserAssetsStore(state => state.isLoadingUserAssets);
 
   const onChangeWallet = useCallback(() => {
     navigate(Routes.CHANGE_WALLET_SHEET);

src/components/list/NoResults.tsx

@@ -4,7 +4,7 @@ import { neverRerender } from '@/utils';
 import { Inset, Stack, Text } from '@/design-system';
 import { useTheme } from '@/theme';
 import { logger } from '@/logger';
-import { useUserAssetCount } from '@/resources/assets/useUserAssetCount';
+import { useUserAssetsStore } from '@/state/assets/userAssets';
 
 export enum NoResultsType {
   Discover = 'discover',
@@ -14,7 +14,7 @@ export enum NoResultsType {
 
 export const NoResults = ({ onL2, type }: { onL2?: boolean; type: NoResultsType }) => {
   const { colors } = useTheme();
-  const { data: assetCount } = useUserAssetCount();
+  const assetCount = useUserAssetsStore(state => state.legacyUserAssets.length);
 
   let title;
   let description;

src/components/remote-promo-sheet/check-fns/hasNonZeroTotalBalance.ts

@@ -1,16 +1,20 @@
+import { selectorFilterByUserChains, selectUserAssetsList } from '@/__swaps__/screens/Swap/resources/_selectors/assets';
+import { userAssetsFetchQuery } from '@/__swaps__/screens/Swap/resources/assets/userAssets';
 import store from '@/redux/store';
-import { fetchUserAssets } from '@/resources/assets/UserAssetsQuery';
+import { useConnectedToHardhatStore } from '@/state/connectedToHardhat';
 
 export const hasNonZeroTotalBalance = async (): Promise<boolean> => {
   const { accountAddress, nativeCurrency } = store.getState().settings;
 
-  const assets = await fetchUserAssets({
+  const userAssetsDictByChain = await userAssetsFetchQuery({
     address: accountAddress,
     currency: nativeCurrency,
-    connectedToHardhat: false,
+    testnetMode: useConnectedToHardhatStore.getState().connectedToHardhat,
   });
 
-  if (!assets || Object.keys(assets).length === 0) return false;
+  const assets = selectorFilterByUserChains({ data: userAssetsDictByChain, selector: selectUserAssetsList });
 
-  return Object.values(assets).some(asset => Number(asset.balance?.amount) > 0);
+  if (!assets?.length) return false;
+
+  return assets.some(asset => Number(asset.balance?.amount) > 0);
 };

src/entities/tokens.ts

@@ -1,6 +1,6 @@
 import { EthereumAddress } from '.';
 import { Chain } from '@wagmi/chains';
-import { Network, ChainId } from '@/chains/types';
+import { ChainId } from '@/chains/types';
 import { TokenColors } from '@/graphql/__generated__/metadata';
 
 export interface ZerionAssetPrice {

src/helpers/buildWalletSections.tsx

@@ -201,7 +201,7 @@ const withBriefBalanceSection = (
       type: 'PROFILE_NAME_ROW_SPACE_AFTER',
       uid: 'profile-name-space-after',
     },
-    ...(!hasTokens && !isLoadingUserAssets && !isLoadingBalance
+    ...(!hasTokens && !isLoadingBalance
       ? []
       : [
           {

src/hooks/useAccountAsset.ts

@@ -1,11 +1,11 @@
 import { NativeCurrencyKey } from '@/entities';
 import useAccountSettings from './useAccountSettings';
 import { parseAssetNative } from '@/parsers';
-import { useUserAsset } from '@/resources/assets/useUserAsset';
+import { useUserAssetsStore } from '@/state/assets/userAssets';
 
 // this is meant to be used for assets contained in the current wallet
 export default function useAccountAsset(uniqueId: string, nativeCurrency: NativeCurrencyKey | undefined = undefined) {
-  const { data: accountAsset } = useUserAsset(uniqueId);
+  const accountAsset = useUserAssetsStore(state => state.getLegacyUserAsset(uniqueId));
 
   // this is temporary for FastBalanceCoinRow to make a tiny bit faster
   // we pass nativeCurrency only in that case

src/hooks/useRefreshAccountData.ts

@@ -7,8 +7,7 @@ import useAccountSettings from './useAccountSettings';
 import { PROFILES, useExperimentalFlag } from '@/config';
 import { logger, RainbowError } from '@/logger';
 import { queryClient } from '@/react-query';
-import { userAssetsQueryKey } from '@/resources/assets/UserAssetsQuery';
-import { userAssetsQueryKey as swapsUserAssetsQueryKey } from '@/__swaps__/screens/Swap/resources/assets/userAssets';
+import { userAssetsQueryKey } from '@/__swaps__/screens/Swap/resources/assets/userAssets';
 import { nftsQueryKey } from '@/resources/nfts';
 import { positionsQueryKey } from '@/resources/defi/PositionsQuery';
 import useNftSort from './useNFTsSortBy';
@@ -38,9 +37,8 @@ export default function useRefreshAccountData() {
     queryClient.invalidateQueries(positionsQueryKey({ address: accountAddress as Address, currency: nativeCurrency }));
     queryClient.invalidateQueries(claimablesQueryKey({ address: accountAddress, currency: nativeCurrency }));
     queryClient.invalidateQueries(addysSummaryQueryKey({ addresses: allAddresses, currency: nativeCurrency }));
-    queryClient.invalidateQueries(userAssetsQueryKey({ address: accountAddress, currency: nativeCurrency, connectedToHardhat }));
     queryClient.invalidateQueries(
-      swapsUserAssetsQueryKey({ address: accountAddress as Address, currency: nativeCurrency, testnetMode: !!connectedToHardhat })
+      userAssetsQueryKey({ address: accountAddress, currency: nativeCurrency, testnetMode: connectedToHardhat })
     );
 
     try {

src/hooks/useSwappableUserAssets.ts

@@ -2,17 +2,17 @@ import { SwappableAsset } from '@/entities';
 import { walletFilter } from '@/handlers/tokenSearch';
 import { useCoinListEditOptions } from '@/hooks';
 import { ETH_ADDRESS } from '@/references';
-import { useSortedUserAssets } from '@/resources/assets/useSortedUserAssets';
 import { EthereumAddress, ETH_ADDRESS as ETH_ADDRESS_AGGREGATORS } from '@rainbow-me/swaps';
 import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useUserAssetsStore } from '@/state/assets/userAssets';
 import { ChainId } from '@/chains/types';
 import { supportedSwapChainIds } from '@/chains';
 
 type SwappableAddresses = Record<ChainId, EthereumAddress[]>;
 
 export const useSwappableUserAssets = (params: { outputCurrency: SwappableAsset }) => {
   const { outputCurrency } = params;
-  const { data: sortedAssets } = useSortedUserAssets();
+  const sortedAssets = useUserAssetsStore(state => state.legacyUserAssets);
   const assetsInWallet = sortedAssets as SwappableAsset[];
   const { hiddenCoinsObj } = useCoinListEditOptions();