@lifi/widget 2.9.3 → 3.0.0-alpha.0

package/cjs/hooks/useRoutes.js

@@ -1,22 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useRoutes = void 0;
-const address_1 = require("@ethersproject/address");
 const sdk_1 = require("@lifi/sdk");
 const react_query_1 = require("@tanstack/react-query");
-const big_js_1 = require("big.js");
+const core_1 = require("@wagmi/core");
 const react_hook_form_1 = require("react-hook-form");
 const uuid_1 = require("uuid");
+const viem_1 = require("viem");
+const ens_1 = require("viem/ens");
+const wagmi_1 = require("wagmi");
 const _1 = require(".");
 const providers_1 = require("../providers");
 const stores_1 = require("../stores");
+const utils_1 = require("../utils");
+const useAccount_1 = require("./useAccount");
 const useSwapOnly_1 = require("./useSwapOnly");
 const refetchTime = 60000;
 const useRoutes = ({ insurableRoute } = {}) => {
-    const lifi = (0, providers_1.useLiFi)();
     const { subvariant, sdkConfig, insurance, contractTool } = (0, providers_1.useWidgetConfig)();
-    const { account } = (0, providers_1.useWallet)();
+    const { account } = (0, useAccount_1.useAccount)();
     const queryClient = (0, react_query_1.useQueryClient)();
+    const config = (0, wagmi_1.useConfig)();
     const swapOnly = (0, useSwapOnly_1.useSwapOnly)();
     const { slippage, enabledBridges, enabledAutoRefuel, enabledExchanges, routePriority, } = (0, stores_1.useSettings)([
         'slippage',
@@ -41,22 +45,28 @@ const useRoutes = ({ insurableRoute } = {}) => {
     });
     const { token: fromToken } = (0, _1.useToken)(fromChainId, fromTokenAddress);
     const { token: toToken } = (0, _1.useToken)(toChainId, toTokenAddress);
+    const { chain: fromChain } = (0, _1.useChain)(fromChainId);
+    const { chain: toChain } = (0, _1.useChain)(toChainId);
     const { enabled: enabledRefuel, fromAmount: gasRecommendationFromAmount } = (0, _1.useGasRefuel)();
     const hasAmount = (!isNaN(fromTokenAmount) && Number(fromTokenAmount) > 0) ||
         (!isNaN(toTokenAmount) && Number(toTokenAmount) > 0);
     const contractCallQuoteEnabled = subvariant === 'nft'
         ? Boolean(toContractAddress && toContractCallData && toContractGasLimit)
         : true;
+    // When we bridge between ecosystems we need to be sure toAddress is set
+    const isChainTypeSatisfied = fromChain?.chainType !== toChain?.chainType ? Boolean(toAddress) : true;
     const isEnabled = !isNaN(fromChainId) &&
         !isNaN(toChainId) &&
         Boolean(fromToken?.address) &&
         Boolean(toToken?.address) &&
         !Number.isNaN(slippage) &&
         hasAmount &&
+        isChainTypeSatisfied &&
         contractCallQuoteEnabled;
+    const accountAddress = fromChain?.chainType === account.chainType ? account.address : undefined;
     const queryKey = [
         'routes',
-        account.address,
+        accountAddress,
         fromChainId,
         fromToken?.address,
         fromTokenAmount,
@@ -72,126 +82,119 @@ const useRoutes = ({ insurableRoute } = {}) => {
         enabledExchanges,
         routePriority,
         subvariant,
-        sdkConfig?.defaultRouteOptions?.allowSwitchChain,
+        sdkConfig?.routeOptions?.allowSwitchChain,
         enabledRefuel && enabledAutoRefuel,
         gasRecommendationFromAmount,
         insurance,
         insurableRoute?.id,
     ];
-    const { data, isLoading, isFetching, isFetched, dataUpdatedAt, refetch } = (0, react_query_1.useQuery)(queryKey, async ({ queryKey: [_, fromAddress, fromChainId, fromTokenAddress, fromTokenAmount, toAddress, toChainId, toTokenAddress, toTokenAmount, toContractAddress, toContractCallData, toContractGasLimit, slippage, enabledBridges, enabledExchanges, routePriority, subvariant, allowSwitchChain, enabledRefuel, gasRecommendationFromAmount, insurance, insurableRouteId,], signal, }) => {
-        let toWalletAddress;
-        try {
-            toWalletAddress =
-                (await account.signer?.provider?.resolveName(toAddress)) ??
-                    ((0, address_1.isAddress)(toAddress) ? toAddress : fromAddress);
-        }
-        catch {
-            toWalletAddress = (0, address_1.isAddress)(toAddress) ? toAddress : fromAddress;
-        }
-        const fromAmount = (0, big_js_1.default)(fromTokenAmount || 0)
-            .mul(10 ** (fromToken?.decimals ?? 0))
-            .toFixed(0);
-        const formattedSlippage = parseFloat(slippage) / 100;
-        const allowedBridges = insurableRoute
-            ? insurableRoute.steps.flatMap((step) => step.includedSteps
-                .filter((includedStep) => includedStep.type === 'cross')
-                .map((includedStep) => includedStep.toolDetails.key))
-            : enabledBridges;
-        const allowedExchanges = insurableRoute
-            ? insurableRoute.steps.flatMap((step) => step.includedSteps
-                .filter((includedStep) => includedStep.type === 'swap')
-                .map((includedStep) => includedStep.toolDetails.key))
-            : enabledExchanges;
-        if (subvariant === 'nft') {
-            const contractCallQuote = await lifi.getContractCallQuote({
-                fromAddress,
-                fromChain: fromChainId,
-                fromToken: fromTokenAddress,
-                toAmount: toTokenAmount,
-                toChain: toChainId,
-                toToken: toTokenAddress,
-                toContractAddress,
-                toContractCallData,
-                toContractGasLimit,
-                allowBridges: allowedBridges,
-                toFallbackAddress: toWalletAddress,
-                slippage: formattedSlippage,
-            }, { signal });
-            contractCallQuote.action.toToken = toToken;
-            const customStep = subvariant === 'nft'
-                ? contractCallQuote.includedSteps?.find((step) => step.type === 'custom')
-                : undefined;
-            if (customStep && contractTool) {
-                const toolDetails = {
-                    key: contractTool.name,
-                    name: contractTool.name,
-                    logoURI: contractTool.logoURI,
+    const { data, isLoading, isFetching, isFetched, dataUpdatedAt, refetch } = (0, react_query_1.useQuery)({
+        queryKey,
+        queryFn: async ({ queryKey: [_, fromAddress, fromChainId, fromTokenAddress, fromTokenAmount, toAddress, toChainId, toTokenAddress, toTokenAmount, toContractAddress, toContractCallData, toContractGasLimit, slippage, enabledBridges, enabledExchanges, routePriority, subvariant, allowSwitchChain, enabledRefuel, gasRecommendationFromAmount, insurance, insurableRouteId,], signal, }) => {
+            let toWalletAddress = toAddress || fromAddress;
+            const isAddress = (0, viem_1.isAddress)(toAddress) || (0, utils_1.isSVMAddress)(toAddress);
+            try {
+                // FIXME: resolve address in one place
+                toWalletAddress = !isAddress
+                    ? await (0, core_1.getEnsAddress)(config, {
+                        chainId: toChainId,
+                        name: (0, ens_1.normalize)(toAddress),
+                    })
+                    : isAddress
+                        ? toAddress
+                        : fromAddress;
+            }
+            catch {
+                toWalletAddress = isAddress ? toAddress : fromAddress;
+            }
+            const fromAmount = (0, viem_1.parseUnits)(fromTokenAmount, fromToken.decimals).toString();
+            const formattedSlippage = parseFloat(slippage) / 100;
+            const allowedBridges = insurableRoute
+                ? insurableRoute.steps.flatMap((step) => step.includedSteps
+                    .filter((includedStep) => includedStep.type === 'cross')
+                    .map((includedStep) => includedStep.toolDetails.key))
+                : enabledBridges;
+            const allowedExchanges = insurableRoute
+                ? insurableRoute.steps.flatMap((step) => step.includedSteps
+                    .filter((includedStep) => includedStep.type === 'swap')
+                    .map((includedStep) => includedStep.toolDetails.key))
+                : enabledExchanges;
+            if (subvariant === 'nft') {
+                const contractCallQuote = await (0, sdk_1.getContractCallQuote)({
+                    fromAddress,
+                    fromChain: fromChainId,
+                    fromToken: fromTokenAddress,
+                    toAmount: toTokenAmount,
+                    toChain: toChainId,
+                    toToken: toTokenAddress,
+                    toContractAddress,
+                    toContractCallData,
+                    toContractGasLimit,
+                    allowBridges: allowedBridges,
+                    toFallbackAddress: toWalletAddress,
+                    slippage: formattedSlippage,
+                }, { signal });
+                contractCallQuote.action.toToken = toToken;
+                const customStep = subvariant === 'nft'
+                    ? contractCallQuote.includedSteps?.find((step) => step.type === 'custom')
+                    : undefined;
+                if (customStep && contractTool) {
+                    const toolDetails = {
+                        key: contractTool.name,
+                        name: contractTool.name,
+                        logoURI: contractTool.logoURI,
+                    };
+                    customStep.toolDetails = toolDetails;
+                    contractCallQuote.toolDetails = toolDetails;
+                }
+                const route = {
+                    id: (0, uuid_1.v4)(),
+                    fromChainId: contractCallQuote.action.fromChainId,
+                    fromAmountUSD: contractCallQuote.estimate.fromAmountUSD || '',
+                    fromAmount: contractCallQuote.action.fromAmount,
+                    fromToken: contractCallQuote.action.fromToken,
+                    fromAddress: contractCallQuote.action.fromAddress,
+                    toChainId: contractCallQuote.action.toChainId,
+                    toAmountUSD: contractCallQuote.estimate.toAmountUSD || '',
+                    toAmount: toTokenAmount,
+                    toAmountMin: toTokenAmount,
+                    toToken: toToken,
+                    toAddress: toWalletAddress,
+                    gasCostUSD: contractCallQuote.estimate.gasCosts?.[0].amountUSD,
+                    steps: [contractCallQuote],
+                    insurance: { state: 'NOT_INSURABLE', feeAmountUsd: '0' },
                 };
-                customStep.toolDetails = toolDetails;
-                contractCallQuote.toolDetails = toolDetails;
+                return { routes: [route] };
             }
-            const route = {
-                id: (0, uuid_1.v4)(),
-                fromChainId: contractCallQuote.action.fromChainId,
-                fromAmountUSD: contractCallQuote.estimate.fromAmountUSD || '',
-                fromAmount: contractCallQuote.action.fromAmount,
-                fromToken: contractCallQuote.action.fromToken,
-                fromAddress: contractCallQuote.action.fromAddress,
-                toChainId: contractCallQuote.action.toChainId,
-                toAmountUSD: contractCallQuote.estimate.toAmountUSD || '',
-                toAmount: toTokenAmount,
-                toAmountMin: toTokenAmount,
-                toToken: toToken,
+            const data = await (0, sdk_1.getRoutes)({
+                fromChainId,
+                fromAmount,
+                fromTokenAddress,
+                toChainId,
+                toTokenAddress,
+                fromAddress,
                 toAddress: toWalletAddress,
-                gasCostUSD: contractCallQuote.estimate.gasCosts?.[0].amountUSD,
-                steps: [contractCallQuote],
-                insurance: { state: 'NOT_INSURABLE', feeAmountUsd: '0' },
-            };
-            return { routes: [route] };
-        }
-        return lifi.getRoutes({
-            fromChainId,
-            fromAmount,
-            fromTokenAddress,
-            toChainId,
-            toTokenAddress,
-            fromAddress,
-            toAddress: toWalletAddress,
-            fromAmountForGas: enabledRefuel && gasRecommendationFromAmount
-                ? gasRecommendationFromAmount
-                : undefined,
-            options: {
-                slippage: formattedSlippage,
-                bridges: {
-                    allow: allowedBridges,
-                },
-                exchanges: {
-                    allow: allowedExchanges,
+                fromAmountForGas: enabledRefuel && gasRecommendationFromAmount
+                    ? gasRecommendationFromAmount
+                    : undefined,
+                options: {
+                    slippage: formattedSlippage,
+                    bridges: {
+                        allow: allowedBridges,
+                    },
+                    exchanges: {
+                        allow: allowedExchanges,
+                    },
+                    order: routePriority,
+                    allowSwitchChain: subvariant === 'refuel' ? false : allowSwitchChain,
+                    insurance: insurance ? Boolean(insurableRoute) : undefined,
                 },
-                order: routePriority,
-                allowSwitchChain: subvariant === 'refuel' ? false : allowSwitchChain,
-                insurance: insurance ? Boolean(insurableRoute) : undefined,
-            },
-        }, { signal });
-    }, {
-        enabled: isEnabled,
-        staleTime: refetchTime,
-        cacheTime: refetchTime,
-        refetchInterval(data, query) {
-            return Math.min(Math.abs(refetchTime - (Date.now() - query.state.dataUpdatedAt)), refetchTime);
-        },
-        retry(failureCount, error) {
-            if (error?.code === sdk_1.LifiErrorCode.NotFound) {
-                return false;
-            }
-            return true;
-        },
-        onSuccess(data) {
-            if (data.routes[0]) {
+            }, { signal });
+            if (data.routes[0] && fromAddress) {
                 // Update local tokens cache to keep priceUSD in sync
                 const { fromToken, toToken } = data.routes[0];
                 [fromToken, toToken].forEach((token) => {
-                    queryClient.setQueriesData(['token-balances', account.address, token.chainId], (data) => {
+                    queryClient.setQueriesData({ queryKey: ['token-balances', fromAddress, token.chainId] }, (data) => {
                         if (data) {
                             const clonedData = [...data];
                             const index = clonedData.findIndex((dataToken) => dataToken.address === token.address);
@@ -204,6 +207,18 @@ const useRoutes = ({ insurableRoute } = {}) => {
                     });
                 });
             }
+            return data;
+        },
+        enabled: isEnabled,
+        staleTime: refetchTime,
+        refetchInterval(query) {
+            return Math.min(Math.abs(refetchTime - (Date.now() - query.state.dataUpdatedAt)), refetchTime);
+        },
+        retry(_, error) {
+            if (error?.code === sdk_1.LiFiErrorCode.NotFound) {
+                return false;
+            }
+            return true;
         },
     });
     return {

package/cjs/hooks/useSettingMonitor.d.ts

@@ -0,0 +1,11 @@
+export declare const useSettingMonitor: () => {
+    isBridgesChanged: boolean;
+    isExchangesChanged: boolean;
+    isSlippageChanged: boolean;
+    isSlippageOutsideRecommendedLimits: boolean;
+    isRoutePriorityChanged: boolean;
+    isGasPriceChanged: boolean;
+    isCustomRouteSettings: boolean;
+    isRouteSettingsWithWarnings: boolean;
+    reset: () => void;
+};

package/cjs/hooks/useSettingMonitor.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSettingMonitor = void 0;
+const stores_1 = require("../stores");
+const shallow_1 = require("zustand/shallow");
+const useTools_1 = require("./useTools");
+const providers_1 = require("../providers");
+const useSettingMonitor = () => {
+    const [enabledBridges, enabledExchanges, routePriority, slippage, gasPrice] = (0, stores_1.useSettingsStore)((state) => [
+        state.enabledBridges,
+        state.enabledExchanges,
+        state.routePriority,
+        state.slippage,
+        state.gasPrice,
+    ], shallow_1.shallow);
+    const { tools } = (0, useTools_1.useTools)();
+    const resetSettings = (0, stores_1.useSettingsStore)((state) => state.reset);
+    const config = (0, providers_1.useWidgetConfig)();
+    const isSlippageChanged = config.slippage
+        ? Number(slippage) !== config.slippage * 100
+        : slippage !== stores_1.defaultConfigurableSettings.slippage;
+    const isSlippageOutsideRecommendedLimits = isSlippageChanged && Number(slippage) > 1;
+    const isRoutePriorityChanged = config.routePriority
+        ? routePriority !== config.routePriority
+        : routePriority !== stores_1.defaultConfigurableSettings.routePriority;
+    const isGasPriceChanged = gasPrice !== stores_1.defaultConfigurableSettings.gasPrice;
+    const isBridgesChanged = tools?.bridges
+        ? tools?.bridges?.length !== enabledBridges?.length
+        : false;
+    const isExchangesChanged = tools?.exchanges
+        ? tools?.exchanges?.length !== enabledExchanges?.length
+        : false;
+    const isCustomRouteSettings = isBridgesChanged ||
+        isExchangesChanged ||
+        isSlippageChanged ||
+        isRoutePriorityChanged ||
+        isGasPriceChanged;
+    const isRouteSettingsWithWarnings = isSlippageOutsideRecommendedLimits;
+    const reset = () => {
+        if (tools) {
+            resetSettings(config, tools.bridges.map((tool) => tool.key), tools.exchanges.map((tool) => tool.key));
+            (0, stores_1.setDefaultSettings)(config);
+        }
+    };
+    return {
+        isBridgesChanged,
+        isExchangesChanged,
+        isSlippageChanged,
+        isSlippageOutsideRecommendedLimits,
+        isRoutePriorityChanged,
+        isGasPriceChanged,
+        isCustomRouteSettings,
+        isRouteSettingsWithWarnings,
+        reset,
+    };
+};
+exports.useSettingMonitor = useSettingMonitor;

package/cjs/hooks/useTokenAddressBalance.d.ts

@@ -1,5 +1,5 @@
 export declare const useTokenAddressBalance: (chainId?: number, tokenAddress?: string) => {
     token: import("..").TokenAmount | undefined;
     isLoading: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/query-core").RefetchOptions & import("@tanstack/query-core").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/query-core").QueryObserverResult<import("..").TokenAmount[], unknown>>;
+    refetch: (options?: import("@tanstack/query-core/build/legacy/queryClient-IoYjXsnV").Z | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-IoYjXsnV").ac<import("..").TokenAmount[], Error>>;
 };

package/cjs/hooks/useTokenBalance.d.ts

@@ -1,9 +1,11 @@
-import type { Token, TokenAmount } from '@lifi/sdk';
-export declare const useTokenBalance: (token?: Token, accountAddress?: string) => {
+import type { ExtendedChain } from '@lifi/sdk';
+import { type Token, type TokenAmount } from '@lifi/sdk';
+export declare const useTokenBalance: (accountAddress?: string, token?: Token, chain?: ExtendedChain) => {
     token: TokenAmount | undefined;
     isLoading: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<TokenAmount, unknown>>;
+    refetch: (options?: import("@tanstack/query-core/build/legacy/queryClient-IoYjXsnV").Z | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-IoYjXsnV").ac<TokenAmount, Error>>;
     refetchNewBalance: () => void;
     refetchAllBalances: () => void;
     getTokenBalancesWithRetry: (accountAddress: string, tokens: Token[], depth?: number) => Promise<TokenAmount[] | undefined>;
 };
+export declare const getTokenBalancesWithRetry: (accountAddress: string, tokens: Token[], depth?: number) => Promise<TokenAmount[] | undefined>;

package/cjs/hooks/useTokenBalance.js

@@ -1,62 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useTokenBalance = void 0;
+exports.getTokenBalancesWithRetry = exports.useTokenBalance = void 0;
+const sdk_1 = require("@lifi/sdk");
 const react_query_1 = require("@tanstack/react-query");
 const react_1 = require("react");
-const providers_1 = require("../providers");
-const useGetTokenBalancesWithRetry_1 = require("./useGetTokenBalancesWithRetry");
+const useAccount_1 = require("./useAccount");
 const defaultRefetchInterval = 30000;
-const useTokenBalance = (token, accountAddress) => {
-    const { account } = (0, providers_1.useWallet)();
+const useTokenBalance = (accountAddress, token, chain) => {
+    const { account } = (0, useAccount_1.useAccount)();
     const queryClient = (0, react_query_1.useQueryClient)();
-    const walletAddress = accountAddress || account.address;
-    const getTokenBalancesWithRetry = (0, useGetTokenBalancesWithRetry_1.useGetTokenBalancesWithRetry)(account.signer?.provider);
+    const walletAddress = accountAddress ||
+        // When we provide chain we want to be sure that account address used is from the same ecosystem as token
+        !chain
+        ? account.address
+        : chain.chainType === account.chainType
+            ? account.address
+            : undefined;
     const tokenBalanceQueryKey = (0, react_1.useMemo)(() => ['token-balance', walletAddress, token?.chainId, token?.address], [token?.address, token?.chainId, walletAddress]);
-    const { data, isLoading, refetch } = (0, react_query_1.useQuery)(tokenBalanceQueryKey, async ({ queryKey: [, accountAddress] }) => {
-        const cachedToken = queryClient
-            .getQueryData([
-            'token-balances',
-            accountAddress,
-            token.chainId,
-        ])
-            ?.find((t) => t.address === token.address);
-        if (cachedToken) {
-            return cachedToken;
-        }
-        const tokenBalances = await getTokenBalancesWithRetry(accountAddress, [token]);
-        if (!tokenBalances?.length) {
-            throw Error('Could not get tokens balance.');
-        }
-        const cachedTokenAmount = queryClient.getQueryData(tokenBalanceQueryKey);
-        const tokenAmount = tokenBalances[0].amount;
-        if (cachedTokenAmount?.amount !== tokenAmount) {
-            queryClient.setQueryDefaults(tokenBalanceQueryKey, {
-                refetchInterval: defaultRefetchInterval,
-                staleTime: defaultRefetchInterval,
-            });
-        }
-        queryClient.setQueriesData(['token-balances', accountAddress, token.chainId], (data) => {
-            if (data) {
-                const clonedData = [...data];
-                const index = clonedData.findIndex((dataToken) => dataToken.address === token.address);
-                clonedData[index] = {
-                    ...clonedData[index],
-                    amount: tokenAmount,
-                };
-                return clonedData;
+    const { data, isLoading, refetch } = (0, react_query_1.useQuery)({
+        queryKey: tokenBalanceQueryKey,
+        queryFn: async ({ queryKey: [, accountAddress] }) => {
+            const cachedToken = queryClient
+                .getQueryData([
+                'token-balances',
+                accountAddress,
+                token.chainId,
+            ])
+                ?.find((t) => t.address === token.address);
+            if (cachedToken) {
+                return cachedToken;
             }
-        });
-        return {
-            ...tokenBalances[0],
-            amount: tokenAmount,
-        };
-    }, {
+            const tokenBalances = await (0, exports.getTokenBalancesWithRetry)(accountAddress, [token]);
+            if (!tokenBalances?.length) {
+                throw Error('Could not get tokens balance.');
+            }
+            const cachedTokenAmount = queryClient.getQueryData(tokenBalanceQueryKey);
+            const tokenAmount = tokenBalances[0].amount;
+            if (cachedTokenAmount?.amount !== tokenAmount) {
+                queryClient.setQueryDefaults(tokenBalanceQueryKey, {
+                    refetchInterval: defaultRefetchInterval,
+                    staleTime: defaultRefetchInterval,
+                });
+            }
+            queryClient.setQueriesData({ queryKey: ['token-balances', accountAddress, token.chainId] }, (data) => {
+                if (data) {
+                    const clonedData = [...data];
+                    const index = clonedData.findIndex((dataToken) => dataToken.address === token.address);
+                    clonedData[index] = {
+                        ...clonedData[index],
+                        amount: tokenAmount,
+                    };
+                    return clonedData;
+                }
+            });
+            return {
+                ...tokenBalances[0],
+                amount: tokenAmount,
+            };
+        },
         enabled: Boolean(walletAddress && token),
         refetchInterval: defaultRefetchInterval,
         staleTime: defaultRefetchInterval,
     });
     const refetchAllBalances = () => {
-        queryClient.refetchQueries(['token-balances', accountAddress, token?.chainId], { exact: false });
+        queryClient.refetchQueries({
+            queryKey: ['token-balances', accountAddress, token?.chainId],
+            exact: false,
+        });
     };
     const refetchNewBalance = (0, react_1.useCallback)(() => {
         queryClient.setQueryDefaults(tokenBalanceQueryKey, {
@@ -70,7 +80,27 @@ const useTokenBalance = (token, accountAddress) => {
         refetch,
         refetchNewBalance,
         refetchAllBalances,
-        getTokenBalancesWithRetry,
+        getTokenBalancesWithRetry: exports.getTokenBalancesWithRetry,
     };
 };
 exports.useTokenBalance = useTokenBalance;
+const getTokenBalancesWithRetry = async (accountAddress, tokens, depth = 0) => {
+    try {
+        const tokenBalances = await (0, sdk_1.getTokenBalances)(accountAddress, tokens);
+        if (!tokenBalances.every((token) => token.blockNumber)) {
+            if (depth > 10) {
+                console.warn('Token balance backoff depth exceeded.');
+                return undefined;
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, 1.5 ** depth * 100);
+            });
+            return (0, exports.getTokenBalancesWithRetry)(accountAddress, tokens, depth + 1);
+        }
+        return tokenBalances;
+    }
+    catch (error) {
+        //
+    }
+};
+exports.getTokenBalancesWithRetry = getTokenBalancesWithRetry;

package/cjs/hooks/useTokenBalances.d.ts

@@ -1,9 +1,9 @@
 import type { TokenAmount } from '../types';
 export declare const useTokenBalances: (selectedChainId?: number) => {
-    tokens: TokenAmount[];
+    tokens: TokenAmount[] | undefined;
     tokensWithBalance: TokenAmount[] | undefined;
-    featuredTokens: import("@lifi/types").StaticToken[] | undefined;
+    featuredTokens: import("@lifi/sdk").StaticToken[] | undefined;
     isLoading: boolean;
     isBalanceLoading: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<TokenAmount[], unknown>>;
+    refetch: (options?: import("@tanstack/query-core/build/legacy/queryClient-IoYjXsnV").Z | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-IoYjXsnV").ac<TokenAmount[], Error>>;
 };

package/cjs/hooks/useTokenBalances.js

@@ -1,38 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTokenBalances = void 0;
+const sdk_1 = require("@lifi/sdk");
 const react_query_1 = require("@tanstack/react-query");
-const providers_1 = require("../providers");
+const viem_1 = require("viem");
+const useAccount_1 = require("./useAccount");
 const useFeaturedTokens_1 = require("./useFeaturedTokens");
 const useTokens_1 = require("./useTokens");
 const defaultRefetchInterval = 32000;
 const useTokenBalances = (selectedChainId) => {
-    const lifi = (0, providers_1.useLiFi)();
-    const { account } = (0, providers_1.useWallet)();
+    const { accounts } = (0, useAccount_1.useAccount)();
     const featuredTokens = (0, useFeaturedTokens_1.useFeaturedTokens)(selectedChainId);
-    const { tokens, isLoading } = (0, useTokens_1.useTokens)(selectedChainId);
-    const isBalanceLoadingEnabled = Boolean(account.address) &&
+    const { tokens, chain, isLoading } = (0, useTokens_1.useTokens)(selectedChainId);
+    const account = accounts.find((account) => account.chainType === chain?.chainType);
+    const isBalanceLoadingEnabled = Boolean(account?.address) &&
         Boolean(tokens?.length) &&
         Boolean(selectedChainId);
-    const { data: tokensWithBalance, isLoading: isBalanceLoading, refetch, } = (0, react_query_1.useQuery)(['token-balances', account.address, selectedChainId, tokens?.length], async ({ queryKey: [, accountAddress] }) => {
-        const tokenBalances = await lifi.getTokenBalances(accountAddress, tokens);
-        const featuredTokenAddresses = new Set(featuredTokens?.map((token) => token.address));
-        const sortFn = (a, b) => parseFloat(b.amount ?? '0') * parseFloat(b.priceUSD ?? '0') -
-            parseFloat(a.amount ?? '0') * parseFloat(a.priceUSD ?? '0');
-        const formattedTokens = (tokenBalances.length === 0 ? tokens : tokenBalances);
-        const result = [
-            ...formattedTokens
-                .filter((token) => token.amount !== '0' && featuredTokenAddresses.has(token.address))
-                .sort(sortFn),
-            ...formattedTokens.filter((token) => token.amount === '0' && featuredTokenAddresses.has(token.address)),
-            ...formattedTokens
-                .filter((token) => token.amount !== '0' &&
-                !featuredTokenAddresses.has(token.address))
-                .sort(sortFn),
-            ...formattedTokens.filter((token) => token.amount === '0' && !featuredTokenAddresses.has(token.address)),
-        ];
-        return result;
-    }, {
+    const { data: tokensWithBalance, isLoading: isBalanceLoading, refetch, } = (0, react_query_1.useQuery)({
+        queryKey: [
+            'token-balances',
+            account?.address,
+            selectedChainId,
+            tokens?.length,
+        ],
+        queryFn: async ({ queryKey: [, accountAddress] }) => {
+            const tokenBalances = await (0, sdk_1.getTokenBalances)(accountAddress, tokens);
+            const featuredTokenAddresses = new Set(featuredTokens?.map((token) => token.address));
+            const sortFn = (a, b) => parseFloat((0, viem_1.formatUnits)(b.amount ?? 0n, b.decimals)) *
+                parseFloat(b.priceUSD ?? '0') -
+                parseFloat((0, viem_1.formatUnits)(a.amount ?? 0n, a.decimals)) *
+                    parseFloat(a.priceUSD ?? '0');
+            const formattedTokens = (tokenBalances.length === 0 ? tokens : tokenBalances);
+            const result = [
+                ...formattedTokens
+                    .filter((token) => token.amount && featuredTokenAddresses.has(token.address))
+                    .sort(sortFn),
+                ...formattedTokens.filter((token) => !token.amount && featuredTokenAddresses.has(token.address)),
+                ...formattedTokens
+                    .filter((token) => token.amount && !featuredTokenAddresses.has(token.address))
+                    .sort(sortFn),
+                ...formattedTokens.filter((token) => !token.amount && !featuredTokenAddresses.has(token.address)),
+            ];
+            return result;
+        },
         enabled: isBalanceLoadingEnabled,
         refetchInterval: defaultRefetchInterval,
         staleTime: defaultRefetchInterval,