@lifi/widget 1.0.0

package/components/TokenList/types.d.ts

@@ -0,0 +1,16 @@
+import { TokenAmount } from '@lifinance/sdk';
+import { SwapFormDirection } from '../../providers/SwapFormProvider';
+export interface TokenListProps {
+    formType: SwapFormDirection;
+    height: number;
+    onClick?(): void;
+}
+export interface TokenListItemBaseProps {
+    onClick?(token: string): void;
+    size: number;
+    start: number;
+}
+export interface TokenListItemProps extends TokenListItemBaseProps {
+    showBalance?: boolean;
+    token: TokenAmount;
+}

package/components/TokenList/types.js

@@ -0,0 +1 @@
+export {};

package/components/TokenList/utils.d.ts

@@ -0,0 +1,15 @@
+import { TokenAmount } from '@lifinance/sdk';
+export declare const tokenAmountMock: TokenAmount;
+export declare const skeletonKey = "skeleton";
+export declare const createTokenAmountSkeletons: () => {
+    address: string;
+    name: string;
+    amount: string;
+    blockNumber?: number | undefined;
+    symbol: string;
+    decimals: number;
+    chainId: number;
+    coinKey?: import("@lifinance/sdk").CoinKey | undefined;
+    priceUSD?: string | undefined;
+    logoURI?: string | undefined;
+}[];

package/components/TokenList/utils.js

@@ -0,0 +1,10 @@
+export const tokenAmountMock = {
+    address: '-1x0',
+    amount: '',
+    chainId: -1,
+    decimals: 0,
+    name: '',
+    symbol: '',
+};
+export const skeletonKey = 'skeleton';
+export const createTokenAmountSkeletons = () => Array.from({ length: 3 }).map((_, index) => (Object.assign(Object.assign({}, tokenAmountMock), { address: `${tokenAmountMock.address}-${index}`, name: `${skeletonKey}-${index}` })));

package/config/env.d.ts

@@ -0,0 +1,12 @@
+export declare const env: {
+    LIFI_API_URL: string;
+    LIFI_RPC_URL_MAINNET: string;
+    LIFI_RPC_URL_ROPSTEN: string;
+    LIFI_RPC_URL_RINKEBY: string;
+    LIFI_RPC_URL_GORLI: string;
+    LIFI_RPC_URL_KOVAN: string;
+    LIFI_RPC_URL_ARBITRUM_RINKEBY: string;
+    LIFI_RPC_URL_OPTIMISM_KOVAN: string;
+    LIFI_RPC_URL_POLYGON_MUMBAI: string;
+    LIFI_RPC_URL_BSC_TESTNET: string;
+};

package/config/env.js

@@ -0,0 +1,19 @@
+export const env = {
+    LIFI_API_URL: 'https://li.quest/v1/',
+    // RPC - Mainnet (overwrites)
+    LIFI_RPC_URL_MAINNET: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/eth/mainnet',
+    // LIFI_RPC_URL_POLYGON:
+    // LIFI_RPC_URL_BSC:
+    // LIFI_RPC_URL_XDAI:
+    // LIFI_RPC_URL_FANTOM:
+    // LIFI_RPC_URL_ARBITRUM:
+    // RPC - Testnet (overwrites)
+    LIFI_RPC_URL_ROPSTEN: 'https://ropsten.infura.io/v3/c7fe4abb5bbc466cb56038efbb0b9930',
+    LIFI_RPC_URL_RINKEBY: 'https://rinkeby.infura.io/v3/c7fe4abb5bbc466cb56038efbb0b9930',
+    LIFI_RPC_URL_GORLI: 'https://goerli.infura.io/v3/c7fe4abb5bbc466cb56038efbb0b9930',
+    LIFI_RPC_URL_KOVAN: 'https://kovan.infura.io/v3/c7fe4abb5bbc466cb56038efbb0b9930',
+    LIFI_RPC_URL_ARBITRUM_RINKEBY: 'https://arbitrum-rinkeby.infura.io/v3/c7fe4abb5bbc466cb56038efbb0b9930',
+    LIFI_RPC_URL_OPTIMISM_KOVAN: 'https://optimism-kovan.infura.io/v3/c7fe4abb5bbc466cb56038efbb0b9930',
+    LIFI_RPC_URL_POLYGON_MUMBAI: 'https://rpc-mumbai.maticvigil.com/v1/e4dadaac060844094a667194c20f79cc9bb0bc59',
+    LIFI_RPC_URL_BSC_TESTNET: 'https://data-seed-prebsc-1-s2.binance.org:8545',
+};

package/config/queryClient.d.ts

@@ -0,0 +1,2 @@
+import { QueryClient } from 'react-query';
+export declare const queryClient: QueryClient;

package/config/queryClient.js

@@ -0,0 +1,25 @@
+import { QueryClient } from 'react-query';
+export const queryClient = new QueryClient({
+    defaultOptions: {
+        queries: {
+            enabled: true,
+            staleTime: 3600000,
+            cacheTime: Infinity,
+            refetchInterval: false,
+            refetchIntervalInBackground: false,
+            refetchOnWindowFocus: true,
+            refetchOnReconnect: true,
+            refetchOnMount: true,
+            retryOnMount: true,
+            // suspense: true,
+            onError: (error) => {
+                //
+            },
+        },
+        mutations: {
+            onError: (error) => {
+                //
+            },
+        },
+    },
+});

package/config/rpcs.d.ts

@@ -0,0 +1 @@
+export declare const getRpcs: () => Record<number, string[]>;

package/config/rpcs.js

@@ -0,0 +1,20 @@
+import { ChainId } from '@lifinance/sdk';
+import { env } from './env';
+const rpcs = {
+    [ChainId.ETH]: [env.LIFI_RPC_URL_MAINNET],
+    // [ChainId.POL]: [env.LIFI_RPC_URL_POLYGON],
+    // [ChainId.BSC]: [env.LIFI_RPC_URL_BSC],
+    // [ChainId.DAI]: [env.LIFI_RPC_URL_XDAI],
+    // [ChainId.FTM]: [env.LIFI_RPC_URL_FANTOM],
+    // [ChainId.ARB]: [env.LIFI_RPC_URL_ARBITRUM],
+    // Testnet
+    [ChainId.ROP]: [env.LIFI_RPC_URL_ROPSTEN],
+    [ChainId.RIN]: [env.LIFI_RPC_URL_RINKEBY],
+    [ChainId.GOR]: [env.LIFI_RPC_URL_GORLI],
+    [ChainId.KOV]: [env.LIFI_RPC_URL_KOVAN],
+    [ChainId.ARBT]: [env.LIFI_RPC_URL_ARBITRUM_RINKEBY],
+    [ChainId.OPTT]: [env.LIFI_RPC_URL_OPTIMISM_KOVAN],
+    [ChainId.MUM]: [env.LIFI_RPC_URL_POLYGON_MUMBAI],
+    [ChainId.BSCT]: [env.LIFI_RPC_URL_BSC_TESTNET],
+};
+export const getRpcs = () => Object.fromEntries(Object.entries(rpcs).filter(([_, value]) => !value));

package/config/theme.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+import { PaletteMode } from '@mui/material';
+import { ThemeConfig } from '../types';
+declare module '@mui/material/styles' {
+    interface TypographyVariants {
+        '@supports (font-variation-settings: normal)': React.CSSProperties;
+    }
+    interface TypographyVariantsOptions {
+        '@supports (font-variation-settings: normal)'?: React.CSSProperties;
+    }
+    interface Shape {
+        borderRadius: number;
+        borderRadiusSecondary: number;
+    }
+    interface Theme {
+        shape: Shape;
+    }
+    interface ThemeOptions {
+        shape?: Partial<Shape>;
+    }
+}
+declare module '@mui/material/Typography' {
+    interface TypographyPropsVariantOverrides {
+        '@supports (font-variation-settings: normal)': true;
+    }
+}
+export declare const createTheme: (mode: PaletteMode, theme?: ThemeConfig) => import("@mui/material").Theme;

package/config/theme.js

@@ -0,0 +1,126 @@
+import { alpha, createTheme as createMuiTheme, darken, lighten, } from '@mui/material/styles';
+const palette = {
+    primary: {
+        main: '#3F49E1',
+        light: lighten('#3F49E1', 0.5),
+        dark: darken('#3F49E1', 0.2),
+    },
+    secondary: {
+        main: '#F5B5FF',
+        light: lighten('#F5B5FF', 0.5),
+        dark: darken('#F5B5FF', 0.2),
+    },
+    success: {
+        main: '#0AA65B',
+    },
+};
+export const createTheme = (mode, theme = {}) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    return createMuiTheme({
+        typography: Object.assign({ fontFamily: 'Inter var, Inter, sans-serif' }, theme.typography),
+        palette: Object.assign(Object.assign(Object.assign({ mode }, palette), { primary: {
+                main: (_c = (_b = (_a = theme.palette) === null || _a === void 0 ? void 0 : _a.primary) === null || _b === void 0 ? void 0 : _b.main) !== null && _c !== void 0 ? _c : palette.primary.main,
+                light: lighten((_f = (_e = (_d = theme.palette) === null || _d === void 0 ? void 0 : _d.primary) === null || _e === void 0 ? void 0 : _e.main) !== null && _f !== void 0 ? _f : palette.primary.main, 0.5),
+                dark: darken((_j = (_h = (_g = theme.palette) === null || _g === void 0 ? void 0 : _g.primary) === null || _h === void 0 ? void 0 : _h.main) !== null && _j !== void 0 ? _j : palette.primary.main, 0.2),
+            }, secondary: {
+                main: (_m = (_l = (_k = theme.palette) === null || _k === void 0 ? void 0 : _k.secondary) === null || _l === void 0 ? void 0 : _l.main) !== null && _m !== void 0 ? _m : palette.secondary.main,
+                light: lighten((_q = (_p = (_o = theme.palette) === null || _o === void 0 ? void 0 : _o.secondary) === null || _p === void 0 ? void 0 : _p.main) !== null && _q !== void 0 ? _q : palette.secondary.main, 0.5),
+                dark: darken((_t = (_s = (_r = theme.palette) === null || _r === void 0 ? void 0 : _r.secondary) === null || _s === void 0 ? void 0 : _s.main) !== null && _t !== void 0 ? _t : palette.secondary.main, 0.2),
+            } }), (mode === 'light'
+            ? {
+                text: {
+                    primary: '#000',
+                    secondary: '#52575b',
+                },
+                grey: {
+                    100: '#F4F5F6',
+                    200: '#EFF1F2',
+                    300: '#E3E7E9',
+                    400: '#C6C9CD',
+                    500: '#AEB3B7',
+                    600: '#798086',
+                    700: '#57595C',
+                },
+            }
+            : {
+                background: {
+                    paper: '#212121',
+                },
+            })),
+        shape: Object.assign({ borderRadius: 12, borderRadiusSecondary: 6 }, theme.shape),
+        breakpoints: {
+            values: {
+                xs: 0,
+                sm: 392,
+                md: 900,
+                lg: 1200,
+                xl: 1536,
+            },
+        },
+        components: {
+            MuiScopedCssBaseline: {
+                styleOverrides: {
+                    root: Object.assign(Object.assign({ fontFamily: 'Inter, sans-serif' }, theme.typography), { '@supports (font-variation-settings: normal)': Object.assign({ fontFamily: 'Inter var, sans-serif' }, theme.typography) }),
+                },
+            },
+            MuiButton: {
+                styleOverrides: mode === 'dark'
+                    ? {
+                        outlined: {
+                            color: palette.primary.light,
+                            borderColor: palette.primary.light,
+                            '&:hover': {
+                                backgroundColor: alpha(palette.primary.light, 0.08),
+                                borderColor: palette.primary.light,
+                            },
+                        },
+                        text: {
+                            color: palette.primary.light,
+                            '&:hover': {
+                                backgroundColor: alpha(palette.primary.light, 0.08),
+                                borderColor: palette.primary.light,
+                            },
+                        },
+                    }
+                    : undefined,
+            },
+            MuiIconButton: {
+                styleOverrides: {
+                    root: {
+                        color: 'inherit',
+                    },
+                },
+            },
+            MuiAvatar: {
+                styleOverrides: {
+                    root: {
+                        height: 32,
+                        width: 32,
+                    },
+                },
+            },
+            MuiListItemAvatar: {
+                styleOverrides: {
+                    root: {
+                        minWidth: 48,
+                    },
+                },
+            },
+            MuiListItemText: {
+                styleOverrides: {
+                    primary: ({ theme }) => ({
+                        fontWeight: '500',
+                        fontSize: '1.125rem',
+                        lineHeight: '1.2778',
+                        color: theme.palette.text.primary,
+                    }),
+                    secondary: ({ theme }) => ({
+                        fontWeight: '400',
+                        fontSize: '0.75rem',
+                        color: theme.palette.text.secondary,
+                    }),
+                },
+            },
+        },
+    });
+};

package/hooks/index.d.ts

@@ -0,0 +1,15 @@
+export * from './useBridges';
+export * from './useChain';
+export * from './useChains';
+export * from './useContentHeight';
+export * from './useDebouncedWatch';
+export * from './useExchanges';
+export * from './useHasSufficientBalance';
+export * from './useRouteExecution';
+export * from './useScrollableContainer';
+export * from './useSettings';
+export * from './useSwapRoutes';
+export * from './useToken';
+export * from './useTokenBalance';
+export * from './useTokenBalances';
+export * from './useTokens';

package/hooks/index.js

@@ -0,0 +1,15 @@
+export * from './useBridges';
+export * from './useChain';
+export * from './useChains';
+export * from './useContentHeight';
+export * from './useDebouncedWatch';
+export * from './useExchanges';
+export * from './useHasSufficientBalance';
+export * from './useRouteExecution';
+export * from './useScrollableContainer';
+export * from './useSettings';
+export * from './useSwapRoutes';
+export * from './useToken';
+export * from './useTokenBalance';
+export * from './useTokenBalances';
+export * from './useTokens';

package/hooks/useBridges.d.ts

@@ -0,0 +1 @@
+export declare const useBridges: () => string[];

package/hooks/useBridges.js

@@ -0,0 +1,12 @@
+import { useMemo } from 'react';
+import { useQuery } from 'react-query';
+import { LiFi } from '../lifi';
+export const useBridges = () => {
+    const { data } = useQuery(['bridges'], ({ signal }) => LiFi.getPossibilities({ include: ['bridges'] }, { signal }));
+    const bridges = useMemo(() => {
+        var _a;
+        const bridges = (_a = data === null || data === void 0 ? void 0 : data.bridges) === null || _a === void 0 ? void 0 : _a.map((bridge) => bridge.tool).map((bridegTool) => bridegTool.split('-')[0]);
+        return Array.from(new Set(bridges));
+    }, [data === null || data === void 0 ? void 0 : data.bridges]);
+    return bridges;
+};

package/hooks/useChain.d.ts

@@ -0,0 +1,4 @@
+export declare const useChain: (chainId: number) => {
+    chain: import("@lifinance/types").EVMChain | undefined;
+    isLoading: boolean;
+};

package/hooks/useChain.js

@@ -0,0 +1,13 @@
+import { useMemo } from 'react';
+import { useChains } from './useChains';
+export const useChain = (chainId) => {
+    const { chains, isLoading } = useChains();
+    const chain = useMemo(() => {
+        const chain = chains === null || chains === void 0 ? void 0 : chains.find((chain) => chain.id === chainId);
+        return chain;
+    }, [chainId, chains]);
+    return {
+        chain,
+        isLoading,
+    };
+};

package/hooks/useChains.d.ts

@@ -0,0 +1,101 @@
+export declare const useChains: () => {
+    error: unknown;
+    isError: true;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("@lifinance/types").EVMChain[], unknown>>;
+    remove: () => void;
+    fetchStatus: import("react-query").FetchStatus;
+    chains: import("@lifinance/types").EVMChain[] | undefined;
+    getChainById: (chainId: number) => import("@lifinance/types").EVMChain | undefined;
+} | {
+    error: null;
+    isError: false;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "loading";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("@lifinance/types").EVMChain[], unknown>>;
+    remove: () => void;
+    fetchStatus: import("react-query").FetchStatus;
+    chains: import("@lifinance/types").EVMChain[] | undefined;
+    getChainById: (chainId: number) => import("@lifinance/types").EVMChain | undefined;
+} | {
+    error: unknown;
+    isError: true;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("@lifinance/types").EVMChain[], unknown>>;
+    remove: () => void;
+    fetchStatus: import("react-query").FetchStatus;
+    chains: import("@lifinance/types").EVMChain[] | undefined;
+    getChainById: (chainId: number) => import("@lifinance/types").EVMChain | undefined;
+} | {
+    error: null;
+    isError: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("@lifinance/types").EVMChain[], unknown>>;
+    remove: () => void;
+    fetchStatus: import("react-query").FetchStatus;
+    chains: import("@lifinance/types").EVMChain[] | undefined;
+    getChainById: (chainId: number) => import("@lifinance/types").EVMChain | undefined;
+};

package/hooks/useChains.js

@@ -0,0 +1,39 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { useCallback } from 'react';
+import { useQuery } from 'react-query';
+import { LiFi } from '../lifi';
+import { useWidgetConfig } from '../providers/WidgetProvider';
+export const useChains = () => {
+    const { enabledChains } = useWidgetConfig();
+    const _a = useQuery(['chains'], () => __awaiter(void 0, void 0, void 0, function* () {
+        const chains = yield LiFi.getChains();
+        return chains.filter((chain) => enabledChains.includes(chain.id));
+    })), { data } = _a, other = __rest(_a, ["data"]);
+    const getChainById = useCallback((chainId) => {
+        const chain = data === null || data === void 0 ? void 0 : data.find((chain) => chain.id === chainId);
+        // if (!chain) {
+        //   throw new Error('Chain not found or chainId is invalid.');
+        // }
+        return chain;
+    }, [data]);
+    return Object.assign({ chains: data, getChainById }, other);
+};

package/hooks/useContentHeight.d.ts

@@ -0,0 +1 @@
+export declare const useContentHeight: () => number;

package/hooks/useContentHeight.js

@@ -0,0 +1,15 @@
+import { useState } from 'react';
+import { ElementId } from '../utils/elements';
+export const useContentHeight = () => {
+    const [contentHeight] = useState(() => {
+        const headerElement = document.getElementById(ElementId.Header);
+        const containerElement = document.getElementById(ElementId.ScrollableContainer);
+        if (!containerElement || !headerElement) {
+            throw Error(`Can't find ${ElementId.ScrollableContainer} or ${ElementId.Header} id.`);
+        }
+        const { height: containerHeight } = containerElement.getBoundingClientRect();
+        const { height: headerHeight } = headerElement.getBoundingClientRect();
+        return containerHeight - headerHeight;
+    });
+    return contentHeight;
+};

package/hooks/useDebouncedWatch.d.ts

@@ -0,0 +1 @@
+export declare const useDebouncedWatch: (name: any, delay: number) => any;

package/hooks/useDebouncedWatch.js

@@ -0,0 +1,27 @@
+import { useEffect, useRef, useState } from 'react';
+import { useWatch } from 'react-hook-form';
+export const useDebouncedWatch = (name, delay) => {
+    const watchedValue = useWatch({
+        name,
+    });
+    const [debouncedValue, setDebouncedValue] = useState(watchedValue);
+    const isMounted = useRef(false);
+    useEffect(() => {
+        if (isMounted.current) {
+            const hasWatchedValue = Array.isArray(watchedValue)
+                ? watchedValue.some((value) => value)
+                : watchedValue;
+            if (hasWatchedValue) {
+                const handler = setTimeout(() => {
+                    setDebouncedValue(watchedValue);
+                }, delay);
+                return () => clearTimeout(handler);
+            }
+            setDebouncedValue(watchedValue);
+            return undefined;
+        }
+        isMounted.current = true;
+        return undefined;
+    }, [delay, watchedValue]);
+    return debouncedValue;
+};

package/hooks/useExchanges.d.ts

@@ -0,0 +1 @@
+export declare const useExchanges: () => string[];

package/hooks/useExchanges.js

@@ -0,0 +1,12 @@
+import { useMemo } from 'react';
+import { useQuery } from 'react-query';
+import { LiFi } from '../lifi';
+export const useExchanges = () => {
+    const { data } = useQuery(['exchanges'], ({ signal }) => LiFi.getPossibilities({ include: ['exchanges'] }, { signal }));
+    const exchanges = useMemo(() => {
+        var _a;
+        const exchanges = (_a = data === null || data === void 0 ? void 0 : data.exchanges) === null || _a === void 0 ? void 0 : _a.map((exchange) => exchange.tool).map((exchangeTool) => exchangeTool.split('-')[0]);
+        return Array.from(new Set(exchanges));
+    }, [data === null || data === void 0 ? void 0 : data.exchanges]);
+    return exchanges;
+};

package/hooks/useHasSufficientBalance.d.ts

@@ -0,0 +1,5 @@
+export declare const useHasSufficientBalance: () => {
+    hasGasBalanceOnStartChain: boolean;
+    hasGasOnCrossChain: boolean;
+    hasSufficientBalance: boolean;
+};

package/hooks/useHasSufficientBalance.js

@@ -0,0 +1,59 @@
+import { isSwapStep } from '@lifinance/sdk';
+import Big from 'big.js';
+import { useMemo } from 'react';
+import { useWatch } from 'react-hook-form';
+import { SwapFormKeyHelper } from '../providers/SwapFormProvider';
+import { useCurrentRoute } from './useRouteExecution';
+import { useTokenBalances } from './useTokenBalances';
+export const useHasSufficientBalance = () => {
+    var _a;
+    const [route] = useCurrentRoute();
+    const [fromChainId, toChainId] = useWatch({
+        name: [
+            SwapFormKeyHelper.getChainKey('from'),
+            SwapFormKeyHelper.getChainKey('to'),
+        ],
+    });
+    const lastStep = route === null || route === void 0 ? void 0 : route.steps.at(-1);
+    const { tokens: fromChainTokenBalances } = useTokenBalances(fromChainId);
+    const { tokens: toChainTokenBalances } = useTokenBalances((_a = lastStep === null || lastStep === void 0 ? void 0 : lastStep.action.fromChainId) !== null && _a !== void 0 ? _a : toChainId);
+    const hasGasBalanceOnStartChain = useMemo(() => {
+        var _a, _b, _c;
+        const token = (_a = route === null || route === void 0 ? void 0 : route.steps[0].estimate.gasCosts) === null || _a === void 0 ? void 0 : _a[0].token;
+        if (!token) {
+            return true;
+        }
+        const balance = Big((_c = (_b = fromChainTokenBalances === null || fromChainTokenBalances === void 0 ? void 0 : fromChainTokenBalances.find((t) => t.address === token.address)) === null || _b === void 0 ? void 0 : _b.amount) !== null && _c !== void 0 ? _c : 0);
+        const requiredAmount = route.steps
+            .filter((step) => step.action.fromChainId === route.fromChainId)
+            .reduce((big, step) => { var _a; return big.plus(Big(((_a = step.estimate.gasCosts) === null || _a === void 0 ? void 0 : _a[0].amount) || 0)); }, Big(0))
+            .div(Math.pow(10, token.decimals));
+        return balance.gt(0) && balance.gte(requiredAmount);
+    }, [fromChainTokenBalances, route]);
+    const hasGasOnCrossChain = useMemo(() => {
+        var _a, _b, _c, _d, _e, _f;
+        const token = (_a = lastStep === null || lastStep === void 0 ? void 0 : lastStep.estimate.gasCosts) === null || _a === void 0 ? void 0 : _a[0].token;
+        if (!token || !isSwapStep(lastStep)) {
+            return true;
+        }
+        const balance = Big((_c = (_b = toChainTokenBalances === null || toChainTokenBalances === void 0 ? void 0 : toChainTokenBalances.find((t) => t.address === token.address)) === null || _b === void 0 ? void 0 : _b.amount) !== null && _c !== void 0 ? _c : 0);
+        const gasEstimate = (_d = lastStep.estimate.gasCosts) === null || _d === void 0 ? void 0 : _d[0].amount;
+        const requiredAmount = Big(gasEstimate || 0).div(Math.pow(10, ((_f = (_e = lastStep.estimate.gasCosts) === null || _e === void 0 ? void 0 : _e[0].token.decimals) !== null && _f !== void 0 ? _f : 0)));
+        return balance.gt(0) && balance.gte(requiredAmount);
+    }, [lastStep, toChainTokenBalances]);
+    const hasSufficientBalance = useMemo(() => {
+        var _a, _b, _c;
+        if (!route) {
+            return true;
+        }
+        const balance = Big((_b = (_a = fromChainTokenBalances === null || fromChainTokenBalances === void 0 ? void 0 : fromChainTokenBalances.find((t) => t.address === route.fromToken.address)) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : 0);
+        return Big(route.fromAmount)
+            .div(Math.pow(10, ((_c = route.fromToken.decimals) !== null && _c !== void 0 ? _c : 0)))
+            .lte(balance);
+    }, [fromChainTokenBalances, route]);
+    return {
+        hasGasBalanceOnStartChain,
+        hasGasOnCrossChain,
+        hasSufficientBalance,
+    };
+};

package/hooks/useRouteExecution/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './useRouteExecution';
+export * from './useRouteStore';

package/hooks/useRouteExecution/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './useRouteExecution';
+export * from './useRouteStore';