@layerswap/widget 0.1.20 → 1.0.0-alpha1.1

package/dist/esm/hooks/useFormRoutes.js

@@ -0,0 +1,332 @@
+import useSWR from "swr";
+import { useEffect, useMemo, useState } from "react";
+import { useInitialSettings, useSettingsState } from "../context/settings";
+import useAllWithdrawalBalances from "./useAllWithdrawalBalances";
+import { resolveExchangesURLForSelectedToken, resolveNetworkRoutesURL } from "../helpers/routes";
+import LayerSwapApiClient from "../lib/apiClients/layerSwapApiClient";
+import useExchangeNetworks from "./useExchangeNetworks";
+import { useRecentNetworksStore } from "../stores/recentRoutesStore";
+import { useRouteTokenSwitchStore } from "../stores/routeTokenSwitchStore";
+import { getTotalBalanceInUSD } from "../helpers/balanceHelper";
+export default function useFormRoutes({ direction, values }, search) {
+    const { routes, isLoading: routesLoading } = useRoutes({ direction, values });
+    const { exchangesRoutes, isLoading: exchangesRoutesLoading } = useExchangeRoutes({ direction, values });
+    const { networks: withdrawalNetworks, isLoading: exchangeSourceNetworksLoading } = useExchangeNetworks({
+        fromExchange: values.fromExchange?.name,
+        to: values.to?.name,
+        toAsset: values.toAsset?.symbol
+    });
+    const { lockFrom, from, lockTo, to, lockFromAsset, fromAsset, lockToAsset, toAsset } = useInitialSettings();
+    const groupByToken = useRouteTokenSwitchStore((s) => s.showTokens);
+    const { balances, isLoading: balancesLoading } = useAllWithdrawalBalances();
+    const routesHistory = useRecentNetworksStore(state => state.recentRoutes);
+    // Apply query-based filtering
+    const filteredRoutes = useMemo(() => {
+        const filtered = filterRoutesByQuery(routes, direction, { lockFrom, from, lockTo, to, lockFromAsset, fromAsset, lockToAsset, toAsset });
+        return filtered;
+    }, [routes, direction, lockFrom, from, lockTo, to, lockFromAsset, fromAsset, lockToAsset, toAsset]);
+    const routeElements = useMemo(() => groupRoutes(filteredRoutes, direction, balances, groupByToken ? "token" : "network", routesHistory, balancesLoading, search), [balancesLoading, filteredRoutes, balances, direction, search, groupByToken, routesHistory]);
+    const exchanges = useMemo(() => {
+        return groupExchanges(exchangesRoutes, search, direction, { lockFrom, from, lockTo, to });
+    }, [exchangesRoutes, search, direction, lockFrom, from, lockTo, to]);
+    const selectedRoute = useMemo(() => resolveSelectedRoute(values, direction), [values, direction]);
+    const selectedToken = useMemo(() => resolveSelectedToken(values, direction), [values, direction]);
+    return useMemo(() => ({
+        allRoutes: filteredRoutes,
+        isLoading: routesLoading,
+        routeElements,
+        exchanges,
+        exchangesRoutesLoading,
+        exchangeNetworks: withdrawalNetworks,
+        exchangeSourceNetworksLoading,
+        selectedRoute,
+        selectedToken,
+        allbalancesLoaded: !balancesLoading,
+    }), [
+        filteredRoutes,
+        routesLoading,
+        routeElements,
+        exchanges,
+        exchangesRoutesLoading,
+        withdrawalNetworks,
+        exchangeSourceNetworksLoading,
+        selectedRoute,
+        selectedToken,
+        balancesLoading,
+    ]);
+}
+function useRoutesData(url, defaultData, fetcher) {
+    const { data, isLoading } = useSWR(url, fetcher, {
+        keepPreviousData: true,
+        dedupingInterval: 10000,
+    });
+    const [routes, setRoutes] = useState(defaultData);
+    useEffect(() => {
+        if (!isLoading && data?.data)
+            setRoutes(data.data);
+    }, [isLoading, data]);
+    return { routes, isLoading };
+}
+function filterRoutesByQuery(routes, direction, queryParams) {
+    const { lockFrom, from, lockTo, to, lockFromAsset, fromAsset, lockToAsset, toAsset } = queryParams;
+    const hasNetworkLock = direction === 'from' ? !!lockFrom : !!lockTo;
+    const hasAssetLock = direction === 'from' ? !!lockFromAsset : !!lockToAsset;
+    if (!hasNetworkLock && !hasAssetLock)
+        return routes;
+    // Resolve locked network (case-insensitive) and asset symbol (case-sensitive as before)
+    const lockedNetworkName = direction === 'from'
+        ? (lockFrom && from ? normalize(from) : undefined)
+        : (lockTo && to ? normalize(to) : undefined);
+    const lockedAssetSymbol = direction === 'from'
+        ? (lockFromAsset ? fromAsset : undefined)
+        : (lockToAsset ? toAsset : undefined);
+    if (lockedNetworkName) {
+        const filteredRoutes = routes.filter(r => normalize(r.name) === lockedNetworkName);
+        if (lockedAssetSymbol) {
+            return filteredRoutes
+                .map(route => {
+                const filteredTokens = route.tokens?.filter(t => t.symbol === lockedAssetSymbol) || [];
+                return filteredTokens.length > 0 ? { ...route, tokens: filteredTokens } : null;
+            })
+                .filter((r) => r !== null);
+        }
+        return filteredRoutes;
+    }
+    return routes;
+}
+function useRoutes({ direction, values }) {
+    const { sourceRoutes, destinationRoutes } = useSettingsState();
+    const apiClient = new LayerSwapApiClient();
+    const url = useMemo(() => resolveNetworkRoutesURL(direction, values), [direction, values]);
+    const defaultRoutes = direction === 'from' ? sourceRoutes : destinationRoutes;
+    return useRoutesData(url, defaultRoutes || [], apiClient.fetcher);
+}
+// ---------- Token Helpers ----------
+function resolveTokenUSDBalance(route, token, balances) {
+    const networkBalance = balances?.[route.name]?.balances || [];
+    const match = networkBalance.find(b => b.token === token.symbol);
+    return match?.amount && match.amount > 0 ? match.amount * token.price_in_usd : 0;
+}
+function sortRoutesByBalance(routes, balances) {
+    // Calculate summed balances for each route before sorting
+    const routesWithBalances = routes.map(route => ({
+        route,
+        totalBalanceUSD: balances?.[route.name] ? getTotalBalanceInUSD(balances[route.name], route) : 0
+    }));
+    return routesWithBalances
+        .sort((a, b) => {
+        if (b?.totalBalanceUSD !== a?.totalBalanceUSD) {
+            return (b?.totalBalanceUSD || 0) - (a?.totalBalanceUSD || 0);
+        }
+        return a?.route?.display_name?.localeCompare(b?.route?.display_name);
+    })
+        .map(item => item.route);
+}
+function sortGroupedTokensByBalance(tokenElements, balances) {
+    return tokenElements.map(group => {
+        const items = group?.items?.map(item => ({
+            ...item,
+            usdValue: resolveTokenUSDBalance(item.route.route, item.route.token, balances),
+        })).sort((a, b) => b.usdValue - a.usdValue);
+        const totalUSD = items?.reduce((sum, i) => sum + i.usdValue, 0);
+        return { ...group, items, totalUSD };
+    }).sort((a, b) => b.totalUSD - a.totalUSD);
+}
+function resolveSearch(routes, search, direction, balances, routesHistory) {
+    const matchedNetworks = searchInNetworks(routes, search);
+    const matchedTokens = searchInTokens(routes, search).sort(sortSuggestedTokenElements(direction, balances, routesHistory));
+    return [
+        ...(matchedNetworks.length ? [resolveTitle('Networks'), ...matchedNetworks] : []),
+        ...(matchedTokens.length ? [resolveTitle('Tokens'), ...matchedTokens] : [])
+    ];
+}
+const searchInNetworks = (routes, search) => {
+    const lower = search.toLowerCase().trim();
+    return routes.filter(r => {
+        const internalNameMatch = r.name.toLowerCase().includes(lower);
+        const displayNameMatch = r.display_name?.toLowerCase().includes(lower);
+        return internalNameMatch || displayNameMatch;
+    }).map(r => ({ type: 'network', route: r }));
+};
+const searchInTokens = (routes, search) => {
+    const lower = search.toLowerCase().replace(/\s+/g, " ").trim();
+    return extractTokenElementsAsSuggested(routes).filter(e => {
+        const { token, route } = e.route;
+        const symbolMatch = token.symbol.toLowerCase().includes(lower);
+        const contractMatch = token.contract?.toLowerCase().includes(lower);
+        const nameMatch = token.display_asset?.toLowerCase().includes(lower);
+        const splitted = lower.split(' ');
+        const firstpart = splitted?.[0];
+        const secondpart = splitted?.[1];
+        const combo = (firstpart && secondpart) ? ((token.symbol.toLowerCase().includes(firstpart) && route.name.toLowerCase().includes(secondpart))
+            ||
+                (token.symbol.toLowerCase().includes(secondpart) && route.name.toLowerCase().includes(firstpart))
+            ||
+                (token.symbol.toLowerCase().includes(firstpart) && route.display_name.toLowerCase().includes(secondpart))
+            ||
+                (token.symbol.toLowerCase().includes(secondpart) && route.display_name.toLowerCase().includes(firstpart))) : false;
+        return symbolMatch || contractMatch || nameMatch || combo;
+    });
+};
+// ---------- Route Grouping ----------
+function groupRoutes(routes, direction, balances, groupBy = 'network', recents, balancesLoading, search) {
+    if (search) {
+        return resolveSearch(routes, search, direction, balances, recents);
+    }
+    const suggestedRoutes = getSuggestedRoutes(routes, balances, recents, direction, balancesLoading);
+    if (groupBy === "token") {
+        const groupedTokens = resolveTokenRoutes(routes, balances, direction);
+        return mergeGroups(suggestedRoutes, groupedTokens);
+    }
+    const groupedNetworks = resolveNetworkRoutes(routes, balances, direction);
+    return mergeGroups(suggestedRoutes, groupedNetworks);
+}
+const mergeGroups = (suggestedRoutes, allRoutes) => {
+    const allRoutesTitle = allRoutes.find(() => true)?.type === "grouped_token" ? 'All Tokens' : 'All Networks';
+    return [
+        ...(suggestedRoutes.length ? [resolveTitle('Suggestions'), ...suggestedRoutes] : []),
+        resolveTitle(allRoutesTitle),
+        ...allRoutes
+    ];
+};
+const resolveNetworkRoutes = (routes, balances, direction) => {
+    if (direction === "from" && balances) {
+        return sortRoutesByBalance(routes, balances).map(r => ({
+            type: 'network',
+            route: { ...r, tokens: sortNetworkTokens(r, balances) }
+        }));
+    }
+    return routes
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(r => ({ type: 'network', route: { ...r, tokens: r.tokens.sort((a, b) => a.symbol.localeCompare(b.symbol)) } }));
+};
+const resolveTokenRoutes = (routes, balances, direction) => {
+    const groupedRoutes = groupByTokens(routes);
+    if (direction === "from" && balances)
+        return sortGroupedTokensByBalance(groupedRoutes, balances);
+    return groupedRoutes.sort((a, b) => a.symbol.localeCompare(b.symbol));
+};
+function filterExchangesByQuery(exchanges, direction, queryParams) {
+    const { lockFrom, from, lockTo, to } = queryParams;
+    const hasNetworkLock = direction === 'from' ? !!lockFrom : !!lockTo;
+    if (!hasNetworkLock)
+        return exchanges;
+    const lockedExchangeName = direction === 'from'
+        ? (lockFrom && from ? normalize(from) : undefined)
+        : (lockTo && to ? normalize(to) : undefined);
+    if (lockedExchangeName)
+        return exchanges.filter(e => normalize(e.name) === lockedExchangeName);
+    return exchanges;
+}
+function groupExchanges(exchangesRoutes, search, direction, queryParams) {
+    let exchanges = exchangesRoutes.map((r) => ({ ...r }));
+    // Apply query-based filtering if parameters are provided
+    if (direction && queryParams) {
+        exchanges = filterExchangesByQuery(exchanges, direction, queryParams);
+    }
+    if (search) {
+        exchanges = exchanges.filter(r => r.name.toLowerCase().includes(search.toLowerCase()));
+    }
+    return exchanges.sort((a, b) => a.name.localeCompare(b.name));
+}
+// ---------- Token Grouping ----------
+function groupByTokens(routes) {
+    const tokenMap = {};
+    for (const r of routes) {
+        for (const t of r.tokens || []) {
+            const el = { type: 'network_token', route: { token: t, route: r } };
+            if (!tokenMap[t.symbol])
+                tokenMap[t.symbol] = [];
+            tokenMap[t.symbol].push(el);
+        }
+    }
+    const result = Object.entries(tokenMap)
+        .map(([symbol, items]) => ({
+        type: 'grouped_token',
+        symbol,
+        items
+    }));
+    return result;
+}
+// ---------- Sorting ----------
+function sortNetworkTokens(route, balances) {
+    return [...(route.tokens || [])].sort((a, b) => {
+        const balanceA = resolveTokenUSDBalance(route, a, balances || {});
+        const balanceB = resolveTokenUSDBalance(route, b, balances || {});
+        if (balanceB !== balanceA) {
+            return balanceB - balanceA; // Descending by balance
+        }
+        return a.symbol.localeCompare(b.symbol); // Ascending by symbol
+    });
+}
+// ---------- Resolvers ----------
+function resolveSelectedRoute(values, direction) {
+    return direction === 'from' ? values.from : values.to;
+}
+function resolveSelectedToken(values, direction) {
+    return direction === 'from' ? values.fromAsset : values.toAsset;
+}
+// ---------- Exchange ----------
+function useExchangeRoutes({ values }) {
+    const { sourceExchanges } = useSettingsState();
+    const apiClient = new LayerSwapApiClient();
+    const exchangeRoutesURL = useMemo(() => resolveExchangesURLForSelectedToken(values), [values]);
+    const { data: apiResponse, isLoading, } = useSWR(exchangeRoutesURL, apiClient.fetcher, { keepPreviousData: true, dedupingInterval: 10000 });
+    const defaultData = sourceExchanges || [];
+    const [exchangesRoutes, setExchangesData] = useState(defaultData);
+    useEffect(() => {
+        if (!isLoading && apiResponse?.data)
+            setExchangesData(apiResponse.data);
+    }, [apiResponse]);
+    const res = exchangesRoutes.map(r => ({ ...r, cex: true }));
+    return { exchangesRoutes: res, isLoading };
+}
+function getSuggestedRoutes(routes, balances, routesHistory, direction, balancesLoading, limit = 4) {
+    if (direction === "from") {
+        if (!balancesLoading && !balances)
+            return [];
+        if (balancesLoading && direction === "from")
+            return Array(limit).fill({ type: "sceleton_token" });
+    }
+    const tokenElements = extractTokenElementsAsSuggested(routes).filter(t => t.route.token.status === "active");
+    const sorted = tokenElements.sort(sortSuggestedTokenElements(direction, balances, routesHistory));
+    return sorted.slice(0, limit);
+}
+const extractTokenElementsAsSuggested = (routes) => routes.flatMap(route => (route.tokens || []).map(token => ({ type: 'suggested_token', route: { token, route } })));
+const sortSuggestedTokenElements = (direction, balances, routesHistory) => (a, b) => {
+    if (direction === "from" && balances) {
+        const a_balance = getNetworkTokenElementBalance(a, balances);
+        const b_balance = getNetworkTokenElementBalance(b, balances);
+        if (a_balance !== b_balance) {
+            return b_balance - a_balance;
+        }
+    }
+    if (routesHistory) {
+        const a_used = getUsedCount(a, routesHistory);
+        const b_used = getUsedCount(b, routesHistory);
+        if (a_used !== b_used) {
+            return b_used - a_used;
+        }
+    }
+    const a_rank = getRank(a, direction);
+    const b_rank = getRank(b, direction);
+    return a_rank - b_rank;
+};
+const getNetworkTokenElementBalance = (item, balances) => {
+    return (balances[item.route.route.name]?.balances?.find(b => b.token === item.route.token.symbol)?.amount || 0) * item.route.token.price_in_usd;
+};
+const getUsedCount = (item, history) => {
+    return history[item.route.route.name]?.[item.route.token.symbol] || 0;
+};
+const getRank = (item, direction) => {
+    switch (direction) {
+        case "from":
+            return item.route.token.source_rank || 0;
+        case "to":
+            return item.route.token.destination_rank || 0;
+    }
+};
+const resolveTitle = (text) => {
+    return { type: 'group_title', text };
+};
+const normalize = (v) => (v ?? "").toLowerCase();

package/dist/esm/hooks/useFormValidation.js

@@ -0,0 +1,52 @@
+import { isValidAddress } from '../lib/address/validator';
+export function resolveFormValidation({ values, maxAllowedAmount, minAllowedAmount, sourceAddress, sameAccountNetwork, quoteError }) {
+    let amount = values.amount ? Number(values.amount) : undefined;
+    if (!values.from && !values.fromExchange) {
+        return { message: 'Select source' };
+    }
+    if (!values.to) {
+        return { message: 'Select destination' };
+    }
+    if (!values.fromAsset) {
+        return { message: 'Select source asset' };
+    }
+    if (!values.toAsset) {
+        return { message: 'Select destination asset' };
+    }
+    if (!amount) {
+        return { message: 'Enter an amount' };
+    }
+    if (!/^[0-9]*[.,]?[0-9]*$/i.test(amount.toString())) {
+        return { message: 'Invalid amount' };
+    }
+    if (amount < 0) {
+        return { message: "Can't be negative" };
+    }
+    if (maxAllowedAmount != undefined && amount > maxAllowedAmount) {
+        return { message: `Max amount is ${maxAllowedAmount}` };
+    }
+    if (minAllowedAmount != undefined && amount < minAllowedAmount) {
+        return { message: `Min amount is ${minAllowedAmount}` };
+    }
+    if (values.to) {
+        if (values.destination_address && !isValidAddress(values.destination_address, values.to)) {
+            return { message: `Enter a valid ${values.to?.display_name} address` };
+        }
+    }
+    if (values.from?.name.toLowerCase() === sameAccountNetwork?.toLowerCase() ||
+        values.to?.name.toLowerCase() === sameAccountNetwork?.toLowerCase()) {
+        if (sourceAddress &&
+            values.destination_address &&
+            sourceAddress.toLowerCase() !== values.destination_address.toLowerCase()) {
+            return { message: `Address update required` };
+        }
+        if (values.depositMethod === "deposit_address") {
+            return { message: 'Manual Transfer is not supported' };
+        }
+    }
+    const quoteErrorCode = quoteError?.response?.data?.error?.code || quoteError?.code;
+    if (quoteError && quoteErrorCode !== "QUOTE_REQUIRES_NO_DEPOSIT_ADDRESS") {
+        return { message: quoteError.response?.data?.error?.message || 'Unable to retrieve quote' };
+    }
+    return { message: '' };
+}

package/dist/esm/hooks/useRouteValidation.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RouteOff } from 'lucide-react';
+import { useMemo } from 'react';
+import { useInitialSettings } from '../context/settings';
+import { useFormikContext } from 'formik';
+import { useSelectedAccount } from '../context/balanceAccounts';
+import { ICON_CLASSES_WARNING } from '../components/Pages/Swap/Form/SecondaryComponents/validationError/constants';
+export function resolveRouteValidation(quoteError) {
+    const { values } = useFormikContext();
+    const { to, from, destination_address } = values;
+    const selectedSourceAccount = useSelectedAccount("from", from?.name);
+    const initialSettings = useInitialSettings();
+    const quoteErrorCode = quoteError?.response?.data?.error?.code || quoteError?.code;
+    let validationMessage = '';
+    let validationDetails = {};
+    if (((from?.name && from?.name.toLowerCase() === initialSettings.sameAccountNetwork?.toLowerCase()) || (to?.name && to?.name.toLowerCase() === initialSettings.sameAccountNetwork?.toLowerCase()))) {
+        const network = from?.name.toLowerCase() === initialSettings.sameAccountNetwork?.toLowerCase() ? from : to;
+        if ((selectedSourceAccount && destination_address && selectedSourceAccount?.address?.toLowerCase() !== destination_address?.toLowerCase())) {
+            validationMessage = `Transfers between ${network?.display_name} and other chains are only allowed within the same account. Please make sure you're using the same address on both source and destination.`;
+            validationDetails = { title: 'Action Needed', type: 'warning', icon: _jsx(RouteOff, { className: ICON_CLASSES_WARNING }) };
+        }
+        if (values.depositMethod === "deposit_address") {
+            validationMessage = `Manually transferring between ${from?.display_name} and ${to?.display_name} networks is not supported.`;
+            validationDetails = { title: 'Manual Transfer is not supported', type: 'warning', icon: _jsx(RouteOff, { className: ICON_CLASSES_WARNING }) };
+        }
+    }
+    if (quoteErrorCode === "QUOTE_REQUIRES_NO_DEPOSIT_ADDRESS") {
+        validationDetails = { title: 'Manual swapping is not supported', type: 'warning', icon: _jsx(RouteOff, { className: ICON_CLASSES_WARNING }) };
+        validationMessage = `Swaps via manual transfer are not supported for this route. Please select a wallet to send from.`;
+    }
+    const value = useMemo(() => ({
+        message: validationMessage,
+        details: validationDetails
+    }), [validationMessage, validationDetails]);
+    return value;
+}

package/dist/esm/hooks/useSwapHistoryData.js

@@ -0,0 +1,37 @@
+import { useState } from 'react';
+import { useSwrSwaps } from './useSwrSwaps';
+import { SwapStatus } from '../Models/SwapStatus';
+export function useSwapHistoryData(addresses) {
+    const [revalidateAll, setRevalidateAll] = useState(false);
+    const pendingDeposit = useSwrSwaps({
+        statuses: ['PendingDeposit'],
+        addresses,
+        refreshInterval: (data) => {
+            const hasAny = !!data?.some((p) => (p?.data?.length ?? 0) > 0);
+            if (!hasAny)
+                return 30000;
+            setRevalidateAll(true);
+            return 2000;
+        },
+        revalidateAll: true,
+        revalidateFirstPage: true,
+    });
+    const completed = useSwrSwaps({
+        statuses: ['Completed', 'Refunded', 'PendingWithdrawal', 'PendingRefund'],
+        addresses,
+        refreshInterval: (data) => {
+            const hasAnyInProgress = !!data?.some((p) => (p?.data?.some(s => s.swap.status === SwapStatus.PendingRefund || s.swap.status === SwapStatus.LsTransferPending)));
+            if (!hasAnyInProgress)
+                return 0;
+            return 2000;
+        },
+        revalidateAll,
+        revalidateFirstPage: true,
+    });
+    return {
+        pendingDeposit,
+        completed,
+        isLoadingAny: pendingDeposit.isLoading || completed.isLoading,
+        isValidatingAny: pendingDeposit.isValidating || completed.isValidating,
+    };
+}

package/dist/esm/hooks/useSwrSwaps.js

@@ -0,0 +1,53 @@
+import useSWRInfinite from 'swr/infinite';
+import { useEffect } from 'react';
+import LayerSwapApiClient from '../lib/apiClients/layerSwapApiClient';
+import { EmptyApiResponse } from '../Models/ApiResponse';
+const PAGE_SIZE = 20;
+const getSwapsKey = (index, statuses, addresses) => {
+    const addressesParams = addresses?.map(a => `&addresses=${a}`).join('') || '';
+    const statusesParams = statuses.map(s => `&statuses=${s}`).join('') || '';
+    return `/internal/swaps?page=${index + 1}${statusesParams}${addressesParams}`;
+};
+export function useSwrSwaps({ statuses, addresses, refreshInterval, autoLoadAllInitially, revalidateAll, revalidateFirstPage }) {
+    const apiClient = new LayerSwapApiClient();
+    const getKey = (pageIndex, previous) => {
+        if (previous instanceof EmptyApiResponse)
+            return null;
+        if (previous && 'data' in previous && !(previous?.data?.length))
+            return null;
+        return getSwapsKey(pageIndex, statuses, addresses);
+    };
+    const { data, size, setSize, isLoading, isValidating, mutate, error } = useSWRInfinite(getKey, apiClient.fetcher, {
+        revalidateAll,
+        revalidateFirstPage,
+        dedupingInterval: 3000,
+        refreshInterval,
+    });
+    const pages = data ?? [];
+    const swaps = pages.flatMap(p => (p?.data ?? []));
+    const isEmpty = !isLoading && swaps.length === 0;
+    const hasMore = !(isEmpty || (pages.length && ((pages[pages.length - 1]?.data?.length ?? 0) < PAGE_SIZE)));
+    // Auto-load all pages on initial mount for small datasets (like in-progress)
+    useEffect(() => {
+        if (!autoLoadAllInitially)
+            return;
+        if (!pages.length)
+            return;
+        const lastPageLen = (pages[pages.length - 1]?.data?.length ?? 0);
+        if (lastPageLen === PAGE_SIZE && !isValidating) {
+            setSize(size + 1);
+        }
+    }, [autoLoadAllInitially, pages, isValidating, setSize, size]);
+    return {
+        pages,
+        swaps,
+        size,
+        setSize,
+        loadMore: () => setSize(size + 1),
+        isLoading,
+        isValidating,
+        hasMore,
+        error,
+        mutate,
+    };
+}

package/dist/esm/hooks/useWallet.js

@@ -0,0 +1,98 @@
+import { useCallback, useMemo } from "react";
+import { useWalletProviders } from "../context/walletProviders";
+export default function useWallet(network, purpose) {
+    const walletProviders = useWalletProviders();
+    const provider = useMemo(() => network && resolveProvider(network, walletProviders, purpose), [network, purpose, walletProviders]);
+    const wallets = useMemo(() => {
+        let connectedWallets = [];
+        walletProviders.forEach((provider) => {
+            const w = provider.connectedWallets?.map(wallet => {
+                return resolveWallet(wallet, network, provider, purpose);
+            });
+            connectedWallets = w ? [...connectedWallets, ...w] : [...connectedWallets];
+        });
+        return connectedWallets;
+    }, [walletProviders, network]);
+    const unAvailableWallets = useMemo(() => {
+        return wallets.filter(wallet => wallet.isNotAvailable);
+    }, [wallets]);
+    const availableWallets = useMemo(() => {
+        return wallets.filter(wallet => !wallet.isNotAvailable);
+    }, [wallets]);
+    const getProvider = useCallback((network, purpose) => {
+        return network && resolveProvider(network, walletProviders, purpose);
+    }, [walletProviders, purpose]);
+    const res = useMemo(() => ({
+        wallets: availableWallets,
+        unAvailableWallets,
+        provider,
+        providers: walletProviders,
+        getProvider
+    }), [wallets, provider, walletProviders, getProvider]);
+    return res;
+}
+const resolveProvider = (network, walletProviders, purpose) => {
+    if (!purpose || !network)
+        return;
+    let provider = undefined;
+    switch (purpose) {
+        case "withdrawal":
+            provider = walletProviders.find(provider => provider.withdrawalSupportedNetworks?.includes(network.name));
+            break;
+        case "autofil":
+            provider = walletProviders.find(provider => provider.autofillSupportedNetworks?.includes(network.name));
+            break;
+        case "asSource":
+            provider = walletProviders.find(provider => provider.asSourceSupportedNetworks?.includes(network.name));
+            break;
+    }
+    if (provider?.isNotAvailableCondition) {
+        const availableWalletsForConnect = provider.availableWalletsForConnect?.filter(connector => (provider.isNotAvailableCondition && network?.name) ? !provider.isNotAvailableCondition(connector.id, network?.name) : true);
+        const resolvedProvider = {
+            ...provider,
+            connectedWallets: provider.connectedWallets?.map(wallet => {
+                return {
+                    ...wallet,
+                    isNotAvailable: (provider.isNotAvailableCondition && network?.name && wallet.internalId) ? provider.isNotAvailableCondition(wallet.internalId, network?.name) : false,
+                };
+            }),
+            activeWallet: provider.activeWallet ? {
+                ...provider.activeWallet,
+                isNotAvailable: (network?.name) ? provider.isNotAvailableCondition(provider.activeWallet.id, network?.name) : false,
+            } : undefined,
+            availableWalletsForConnect
+        };
+        return resolvedProvider;
+    }
+    return provider;
+};
+const resolveWallet = (wallet, network, provider, purpose) => {
+    if (provider.isNotAvailableCondition && network?.name && wallet.internalId) {
+        return {
+            ...wallet,
+            isNotAvailable: provider.isNotAvailableCondition(wallet.internalId, network?.name),
+        };
+    }
+    if (purpose === "autofil") {
+        return {
+            ...wallet,
+            isNotAvailable: !wallet.autofillSupportedNetworks?.some(n => n.toLowerCase() === network?.name.toLowerCase()),
+        };
+    }
+    else if (purpose === "withdrawal") {
+        return {
+            ...wallet,
+            isNotAvailable: !wallet.withdrawalSupportedNetworks?.some(n => n.toLowerCase() === network?.name.toLowerCase()),
+        };
+    }
+    else if (purpose === "asSource") {
+        return {
+            ...wallet,
+            isNotAvailable: !wallet.asSourceSupportedNetworks?.some(n => n.toLowerCase() === network?.name.toLowerCase()),
+        };
+    }
+    return {
+        ...wallet,
+        isNotAvailable: false,
+    };
+};

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from './exports/index';

package/dist/esm/lib/AnimatedNumber.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { motion, useSpring, useTransform } from "framer-motion";
+import { useEffect } from "react";
+export const AnimatedNumber = ({ value }) => {
+    const spring = useSpring(value, { mass: 0.8, stiffness: 75, damping: 15 });
+    const display = useTransform(spring, (current) => current?.toLocaleString());
+    useEffect(() => {
+        spring.set(value);
+    }, [value, spring]);
+    return _jsx(motion.span, { children: display });
+};

package/dist/esm/lib/AppSettings.js

@@ -0,0 +1,30 @@
+class AppSettings {
+}
+AppSettings.ApiVersion = "mainnet";
+AppSettings.Integrator = 'Layerswap';
+AppSettings.ExplorerURl = `https://www.layerswap.io/explorer/`;
+AppSettings.LayerswapApiUri = 'https://api.layerswap.io';
+AppSettings.IdentitiyApiUri = 'https://identity-api.layerswap.io';
+AppSettings.ResourseStorageUrl = 'https://prodlslayerswapbridgesa.blob.core.windows.net/';
+AppSettings.WalletConnectConfig = {
+    projectId: '28168903b2d30c75e5f7f2d71902581b',
+    name: 'Layerswap',
+    description: 'Layerswap App',
+    url: 'https://layerswap.io/app/',
+    icons: ['https://www.layerswap.io/app/symbol.png'],
+};
+AppSettings.TonClientConfig = {
+    tonApiKey: 'ac793ea74c19105d617dfbeedb827f1b267b4e91f1b15b2420d003ec49722c82',
+};
+AppSettings.ImtblPassportConfig = {
+    appBasePath: "",
+    publishableKey: "",
+    clientId: "",
+    redirectUri: ""
+};
+AppSettings.DisableExchanges = false;
+AppSettings.LayerswapApiKeys = {
+    'mainnet': 'NDBxG+aon6WlbgIA2LfwmcbLU52qUL9qTnztTuTRPNSohf/VnxXpRaJlA5uLSQVqP8YGIiy/0mz+mMeZhLY4/Q',
+    'testnet': 'Dz1jVir9WUD0gBWoGbOmS1oe5K4985SGptaZXjF4z9VVrvO5nC9q55h8TE/3CIESRxWdYVpPnz/H2BogL2eG+A'
+};
+export default AppSettings;