@lifi/widget 2.9.4 → 3.0.0-alpha.1

package/hooks/useRoutes.js

@@ -1,215 +0,0 @@
-import { isAddress } from '@ethersproject/address';
-import { LifiErrorCode } from '@lifi/sdk';
-import { useQuery, useQueryClient } from '@tanstack/react-query';
-import Big from 'big.js';
-import { useWatch } from 'react-hook-form';
-import { v4 as uuidv4 } from 'uuid';
-import { useDebouncedWatch, useGasRefuel, useToken } from '.';
-import { FormKey, useLiFi, useWallet, useWidgetConfig } from '../providers';
-import { useSettings } from '../stores';
-import { useSwapOnly } from './useSwapOnly';
-const refetchTime = 60000;
-export const useRoutes = ({ insurableRoute } = {}) => {
-    const lifi = useLiFi();
-    const { subvariant, sdkConfig, insurance, contractTool } = useWidgetConfig();
-    const { account } = useWallet();
-    const queryClient = useQueryClient();
-    const swapOnly = useSwapOnly();
-    const { slippage, enabledBridges, enabledAutoRefuel, enabledExchanges, routePriority, } = useSettings([
-        'slippage',
-        'routePriority',
-        'enabledAutoRefuel',
-        'enabledBridges',
-        'enabledExchanges',
-    ]);
-    const [fromTokenAmount] = useDebouncedWatch([FormKey.FromAmount], 320);
-    const [fromChainId, fromTokenAddress, toAddress, toTokenAmount, toChainId, toContractAddress, toContractCallData, toContractGasLimit, toTokenAddress,] = useWatch({
-        name: [
-            FormKey.FromChain,
-            FormKey.FromToken,
-            FormKey.ToAddress,
-            FormKey.ToAmount,
-            FormKey.ToChain,
-            FormKey.ToContractAddress,
-            FormKey.ToContractCallData,
-            FormKey.ToContractGasLimit,
-            FormKey.ToToken,
-        ],
-    });
-    const { token: fromToken } = useToken(fromChainId, fromTokenAddress);
-    const { token: toToken } = useToken(toChainId, toTokenAddress);
-    const { enabled: enabledRefuel, fromAmount: gasRecommendationFromAmount } = useGasRefuel();
-    const hasAmount = (!isNaN(fromTokenAmount) && Number(fromTokenAmount) > 0) ||
-        (!isNaN(toTokenAmount) && Number(toTokenAmount) > 0);
-    const contractCallQuoteEnabled = subvariant === 'nft'
-        ? Boolean(toContractAddress && toContractCallData && toContractGasLimit)
-        : true;
-    const isEnabled = !isNaN(fromChainId) &&
-        !isNaN(toChainId) &&
-        Boolean(fromToken?.address) &&
-        Boolean(toToken?.address) &&
-        !Number.isNaN(slippage) &&
-        hasAmount &&
-        contractCallQuoteEnabled;
-    const queryKey = [
-        'routes',
-        account.address,
-        fromChainId,
-        fromToken?.address,
-        fromTokenAmount,
-        toAddress,
-        toChainId,
-        toToken?.address,
-        toTokenAmount,
-        toContractAddress,
-        toContractCallData,
-        toContractGasLimit,
-        slippage,
-        swapOnly ? [] : enabledBridges,
-        enabledExchanges,
-        routePriority,
-        subvariant,
-        sdkConfig?.defaultRouteOptions?.allowSwitchChain,
-        enabledRefuel && enabledAutoRefuel,
-        gasRecommendationFromAmount,
-        insurance,
-        insurableRoute?.id,
-    ];
-    const { data, isLoading, isFetching, isFetched, dataUpdatedAt, refetch } = 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)) ??
-                    (isAddress(toAddress) ? toAddress : fromAddress);
-        }
-        catch {
-            toWalletAddress = isAddress(toAddress) ? toAddress : fromAddress;
-        }
-        const fromAmount = Big(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,
-                };
-                customStep.toolDetails = toolDetails;
-                contractCallQuote.toolDetails = toolDetails;
-            }
-            const route = {
-                id: uuidv4(),
-                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' },
-            };
-            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,
-                },
-                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 === LifiErrorCode.NotFound) {
-                return false;
-            }
-            return true;
-        },
-        onSuccess(data) {
-            if (data.routes[0]) {
-                // 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) => {
-                        if (data) {
-                            const clonedData = [...data];
-                            const index = clonedData.findIndex((dataToken) => dataToken.address === token.address);
-                            clonedData[index] = {
-                                ...clonedData[index],
-                                ...token,
-                            };
-                            return clonedData;
-                        }
-                    });
-                });
-            }
-        },
-    });
-    return {
-        routes: data?.routes,
-        isLoading: isEnabled && isLoading,
-        isFetching,
-        isFetched,
-        dataUpdatedAt,
-        refetchTime,
-        refetch,
-    };
-};

package/hooks/useScrollableContainer.d.ts

@@ -1,4 +0,0 @@
-export declare const getScrollableContainer: (elementId: string) => HTMLElement | null;
-export declare const useGetScrollableContainer: () => () => HTMLElement | null;
-export declare const useScrollableContainer: (elementId: string) => HTMLElement | null;
-export declare const useScrollableOverflowHidden: () => void;

package/hooks/useScrollableContainer.js

@@ -1,32 +0,0 @@
-import { useCallback, useLayoutEffect, useState } from 'react';
-import { createElementId, ElementId } from '../utils';
-import { useDefaultElementId } from './useDefaultElementId';
-export const getScrollableContainer = (elementId) => document.getElementById(createElementId(ElementId.ScrollableContainer, elementId));
-export const useGetScrollableContainer = () => {
-    const elementId = useDefaultElementId();
-    const getContainer = useCallback(() => getScrollableContainer(elementId), [elementId]);
-    return getContainer;
-};
-export const useScrollableContainer = (elementId) => {
-    const [containerElement, setContainerElement] = useState(() => getScrollableContainer(elementId));
-    useLayoutEffect(() => {
-        if (!containerElement) {
-            setContainerElement(getScrollableContainer(elementId));
-        }
-    }, [containerElement, elementId]);
-    return containerElement;
-};
-export const useScrollableOverflowHidden = () => {
-    const elementId = useDefaultElementId();
-    useLayoutEffect(() => {
-        const element = getScrollableContainer(elementId);
-        if (element) {
-            element.style.overflowY = 'hidden';
-        }
-        return () => {
-            if (element) {
-                element.style.overflowY = 'auto';
-            }
-        };
-    }, [elementId]);
-};

package/hooks/useSwapOnly.d.ts

@@ -1 +0,0 @@
-export declare const useSwapOnly: () => boolean;

package/hooks/useSwapOnly.js

@@ -1,5 +0,0 @@
-import { useSplitSubvariantStore } from '../stores';
-export const useSwapOnly = () => {
-    const state = useSplitSubvariantStore((state) => state.state);
-    return state === 'swap';
-};

package/hooks/useToken.d.ts

@@ -1,4 +0,0 @@
-export declare const useToken: (chainId?: number, tokenAddress?: string) => {
-    token: import("..").TokenAmount | undefined;
-    isLoading: boolean;
-};

package/hooks/useToken.js

@@ -1,16 +0,0 @@
-import { useMemo } from 'react';
-import { useTokens } from './useTokens';
-import { useTokenSearch } from './useTokenSearch';
-export const useToken = (chainId, tokenAddress) => {
-    const { tokens, isLoading } = useTokens(chainId);
-    const token = useMemo(() => {
-        const token = tokens?.find((token) => token.address === tokenAddress && token.chainId === chainId);
-        return token;
-    }, [chainId, tokenAddress, tokens]);
-    const tokenSearchEnabled = !isLoading && !token;
-    const { token: searchedToken, isLoading: isSearchedTokenLoading } = useTokenSearch(chainId, tokenAddress, tokenSearchEnabled);
-    return {
-        token: token ?? searchedToken,
-        isLoading: isLoading || (tokenSearchEnabled && isSearchedTokenLoading),
-    };
-};

package/hooks/useTokenAddressBalance.d.ts

@@ -1,5 +0,0 @@
-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>>;
-};

package/hooks/useTokenAddressBalance.js

@@ -1,16 +0,0 @@
-import { useMemo } from 'react';
-import { useTokenBalances } from './useTokenBalances';
-export const useTokenAddressBalance = (chainId, tokenAddress) => {
-    const { tokens, tokensWithBalance, isBalanceLoading, refetch } = useTokenBalances(chainId);
-    const token = useMemo(() => {
-        if (tokenAddress && chainId) {
-            const token = (tokensWithBalance ?? tokens)?.find((token) => token.address === tokenAddress && token.chainId === chainId);
-            return token;
-        }
-    }, [chainId, tokenAddress, tokens, tokensWithBalance]);
-    return {
-        token,
-        isLoading: isBalanceLoading,
-        refetch,
-    };
-};

package/hooks/useTokenBalance.d.ts

@@ -1,9 +0,0 @@
-import type { Token, TokenAmount } from '@lifi/sdk';
-export declare const useTokenBalance: (token?: Token, accountAddress?: string) => {
-    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>>;
-    refetchNewBalance: () => void;
-    refetchAllBalances: () => void;
-    getTokenBalancesWithRetry: (accountAddress: string, tokens: Token[], depth?: number) => Promise<TokenAmount[] | undefined>;
-};

package/hooks/useTokenBalance.js

@@ -1,72 +0,0 @@
-import { useQuery, useQueryClient } from '@tanstack/react-query';
-import { useCallback, useMemo } from 'react';
-import { useWallet } from '../providers';
-import { useGetTokenBalancesWithRetry } from './useGetTokenBalancesWithRetry';
-const defaultRefetchInterval = 30000;
-export const useTokenBalance = (token, accountAddress) => {
-    const { account } = useWallet();
-    const queryClient = useQueryClient();
-    const walletAddress = accountAddress || account.address;
-    const getTokenBalancesWithRetry = useGetTokenBalancesWithRetry(account.signer?.provider);
-    const tokenBalanceQueryKey = useMemo(() => ['token-balance', walletAddress, token?.chainId, token?.address], [token?.address, token?.chainId, walletAddress]);
-    const { data, isLoading, refetch } = 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;
-            }
-        });
-        return {
-            ...tokenBalances[0],
-            amount: tokenAmount,
-        };
-    }, {
-        enabled: Boolean(walletAddress && token),
-        refetchInterval: defaultRefetchInterval,
-        staleTime: defaultRefetchInterval,
-    });
-    const refetchAllBalances = () => {
-        queryClient.refetchQueries(['token-balances', accountAddress, token?.chainId], { exact: false });
-    };
-    const refetchNewBalance = useCallback(() => {
-        queryClient.setQueryDefaults(tokenBalanceQueryKey, {
-            refetchInterval: 250,
-            staleTime: 250,
-        });
-    }, [queryClient, tokenBalanceQueryKey]);
-    return {
-        token: data,
-        isLoading,
-        refetch,
-        refetchNewBalance,
-        refetchAllBalances,
-        getTokenBalancesWithRetry,
-    };
-};

package/hooks/useTokenBalances.d.ts

@@ -1,9 +0,0 @@
-import type { TokenAmount } from '../types';
-export declare const useTokenBalances: (selectedChainId?: number) => {
-    tokens: TokenAmount[];
-    tokensWithBalance: TokenAmount[] | undefined;
-    featuredTokens: import("@lifi/types").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>>;
-};

package/hooks/useTokenBalances.js

@@ -1,45 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { useLiFi, useWallet } from '../providers';
-import { useFeaturedTokens } from './useFeaturedTokens';
-import { useTokens } from './useTokens';
-const defaultRefetchInterval = 32000;
-export const useTokenBalances = (selectedChainId) => {
-    const lifi = useLiFi();
-    const { account } = useWallet();
-    const featuredTokens = useFeaturedTokens(selectedChainId);
-    const { tokens, isLoading } = useTokens(selectedChainId);
-    const isBalanceLoadingEnabled = Boolean(account.address) &&
-        Boolean(tokens?.length) &&
-        Boolean(selectedChainId);
-    const { data: tokensWithBalance, isLoading: isBalanceLoading, refetch, } = 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;
-    }, {
-        enabled: isBalanceLoadingEnabled,
-        refetchInterval: defaultRefetchInterval,
-        staleTime: defaultRefetchInterval,
-    });
-    return {
-        tokens,
-        tokensWithBalance,
-        featuredTokens,
-        isLoading,
-        isBalanceLoading: isBalanceLoading && isBalanceLoadingEnabled,
-        refetch,
-    };
-};

package/hooks/useTokenSearch.d.ts

@@ -1,5 +0,0 @@
-import type { TokenAmount } from '../types';
-export declare const useTokenSearch: (chainId?: number, tokenQuery?: string, enabled?: boolean) => {
-    token: TokenAmount | undefined;
-    isLoading: boolean;
-};

package/hooks/useTokenSearch.js

@@ -1,29 +0,0 @@
-import { useQuery, useQueryClient } from '@tanstack/react-query';
-import { useLiFi } from '../providers';
-export const useTokenSearch = (chainId, tokenQuery, enabled) => {
-    const lifi = useLiFi();
-    const queryClient = useQueryClient();
-    const { data, isLoading } = useQuery(['token-search', chainId, tokenQuery], async ({ queryKey: [, chainId, tokenQuery], signal }) => {
-        const token = await lifi.getToken(chainId, tokenQuery, {
-            signal,
-        });
-        if (token) {
-            queryClient.setQueriesData(['tokens'], (data) => {
-                if (data &&
-                    !data.tokens[chainId]?.some((t) => t.address === token.address)) {
-                    const clonedData = { ...data };
-                    clonedData.tokens[chainId]?.push(token);
-                    return clonedData;
-                }
-            });
-        }
-        return token;
-    }, {
-        enabled: Boolean(chainId && tokenQuery && enabled),
-        retry: false,
-    });
-    return {
-        token: data,
-        isLoading,
-    };
-};

package/hooks/useTokens.d.ts

@@ -1,5 +0,0 @@
-import type { TokenAmount } from '../types';
-export declare const useTokens: (selectedChainId?: number) => {
-    tokens: TokenAmount[];
-    isLoading: boolean;
-};

package/hooks/useTokens.js

@@ -1,69 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { useMemo } from 'react';
-import { isItemAllowed, useLiFi, useWidgetConfig } from '../providers';
-import { useChains } from './useChains';
-import { useFeaturedTokens } from './useFeaturedTokens';
-export const useTokens = (selectedChainId) => {
-    const lifi = useLiFi();
-    const { data, isLoading } = useQuery(['tokens'], () => lifi.getTokens(), {
-        refetchInterval: 3600000,
-    });
-    const { getChainById, isLoading: isSupportedChainsLoading } = useChains();
-    const featuredTokens = useFeaturedTokens(selectedChainId);
-    const { tokens: configTokens, chains: configChains } = useWidgetConfig();
-    const tokens = useMemo(() => {
-        if (isSupportedChainsLoading) {
-            return [];
-        }
-        const chainAllowed = selectedChainId &&
-            getChainById(selectedChainId) &&
-            isItemAllowed(selectedChainId, configChains);
-        if (!chainAllowed) {
-            return [];
-        }
-        let filteredTokens = data?.tokens[selectedChainId];
-        const includedTokens = configTokens?.include?.filter((token) => token.chainId === selectedChainId);
-        if (includedTokens?.length) {
-            filteredTokens = filteredTokens
-                ? [...includedTokens, ...filteredTokens]
-                : includedTokens;
-        }
-        const allowedTokens = configTokens?.allow
-            ?.filter((token) => token.chainId === selectedChainId)
-            .map((token) => token.address);
-        if (allowedTokens?.length) {
-            filteredTokens = filteredTokens?.filter((token) => allowedTokens.includes(token.address));
-        }
-        const deniedTokenAddresses = configTokens?.deny
-            ?.filter((token) => token.chainId === selectedChainId)
-            .map((token) => token.address);
-        if (deniedTokenAddresses?.length) {
-            filteredTokens = filteredTokens?.filter((token) => !deniedTokenAddresses.includes(token.address));
-        }
-        const featuredTokenAddresses = new Set(featuredTokens?.map((token) => token.address));
-        const tokens = [
-            ...(featuredTokens?.map((token) => {
-                token.featured = true;
-                return token;
-            }) ?? []),
-            ...(filteredTokens?.filter((token) => !featuredTokenAddresses.has(token.address)) ?? []),
-        ];
-        return tokens;
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [
-        configChains,
-        configTokens?.allow,
-        configTokens?.deny,
-        configTokens?.include,
-        data?.tokens,
-        data,
-        featuredTokens,
-        getChainById,
-        isSupportedChainsLoading,
-        selectedChainId,
-    ]);
-    return {
-        tokens,
-        isLoading,
-    };
-};

package/hooks/useTools.d.ts

@@ -1,4 +0,0 @@
-import type { ToolsResponse } from '@lifi/sdk';
-export declare const useTools: () => {
-    tools: ToolsResponse | undefined;
-};

package/hooks/useTools.js

@@ -1,23 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { isItemAllowed, useLiFi, useWidgetConfig } from '../providers';
-import { useSettingsStore } from '../stores';
-export const useTools = () => {
-    const lifi = useLiFi();
-    const { bridges, exchanges } = useWidgetConfig();
-    const { data } = useQuery(['tools'], async () => {
-        const tools = await lifi.getTools();
-        return {
-            bridges: tools.bridges.filter((bridge) => isItemAllowed(bridge.key, bridges)),
-            exchanges: tools.exchanges.filter((exchange) => isItemAllowed(exchange.key, exchanges)),
-        };
-    }, {
-        onSuccess(data) {
-            const { initializeTools } = useSettingsStore.getState();
-            initializeTools('Bridges', data.bridges.map((bridge) => bridge.key));
-            initializeTools('Exchanges', data.exchanges.map((exchange) => exchange.key));
-        },
-        refetchInterval: 180000,
-        staleTime: 180000,
-    });
-    return { tools: data };
-};

package/hooks/useWidgetEvents.d.ts

@@ -1,3 +0,0 @@
-import type { WidgetEvents } from '../types';
-export declare const widgetEvents: import("mitt").Emitter<WidgetEvents>;
-export declare const useWidgetEvents: () => import("mitt").Emitter<WidgetEvents>;

package/hooks/useWidgetEvents.js

@@ -1,5 +0,0 @@
-import mitt from 'mitt';
-export const widgetEvents = mitt();
-export const useWidgetEvents = () => {
-    return widgetEvents;
-};