@layerswap/widget 1.0.6 → 1.1.1

package/dist/esm/components/shadcn/checkbox.js

@@ -4,6 +4,6 @@ import * as React from "react";
 import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
 import { Check } from "lucide-react";
 import { classNames } from "../utils/classNames";
-const Checkbox = React.forwardRef(({ className, ...props }, ref) => (_jsx(CheckboxPrimitive.Root, { ref: ref, className: classNames("peer h-4 w-4 shrink-0 rounded border border-secondary-text focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-secondary-text data-[state=checked]:text-secondary-800", className), ...props, children: _jsx(CheckboxPrimitive.Indicator, { className: classNames("flex items-center justify-center text-current"), children: _jsx(Check, { className: "h-4 w-4" }) }) })));
+const Checkbox = React.forwardRef(({ className, ...props }, ref) => (_jsx(CheckboxPrimitive.Root, { ref: ref, className: classNames("peer h-3 w-3 shrink-0 rounded border border-secondary-text data-[state=checked]:border-primary-text focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary-text data-[state=checked]:text-secondary-800", className), ...props, children: _jsx(CheckboxPrimitive.Indicator, { className: classNames("flex items-center justify-center text-current"), children: _jsx(Check, { className: "h-3 w-3" }) }) })));
 Checkbox.displayName = CheckboxPrimitive.Root.displayName;
 export { Checkbox };

package/dist/esm/context/ErrorProvider.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useEffect } from 'react';
+import { useCallbacks } from './callbackProvider';
+import { logStore } from '../stores/logStore';
+const LogContext = createContext(null);
+export const ErrorProvider = ({ children }) => {
+    const callbacks = useCallbacks();
+    useEffect(() => {
+        if (callbacks?.onError) {
+            logStore.getState().setLogger(callbacks.onError);
+        }
+    }, [callbacks.onError]);
+    return _jsx(LogContext.Provider, { value: null, children: children });
+};

package/dist/esm/context/LayerswapProvider.js

@@ -16,17 +16,18 @@ import ColorSchema from "../components/ColorSchema";
 import { WidgetLoading } from "../components/WidgetLoading";
 import WalletsProviders from "../components/Wallet/WalletProviders";
 import { CallbackProvider } from "./callbackProvider";
-import { BalanceAccountsProvider } from "./balanceAccounts";
+import { SwapAccountsProvider } from "./swapAccounts";
 import { ResolverProviders } from "./resolverContext";
+import { ErrorProvider } from "./ErrorProvider";
 const INTERCOM_APP_ID = 'h5zisg78';
 const LayerswapProviderComponent = ({ children, callbacks, config, walletProviders = [] }) => {
-    let { apiKey, version, settings: _settings, theme: themeData, imtblPassport, initialValues } = config || {};
+    let { apiKey, version, settings: _settings, theme: themeData, initialValues, imtblPassport, tonConfigs, walletConnect } = config || {};
     const [fetchedSettings, setFetchedSettings] = useState(null);
     themeData = { ...THEME_COLORS['default'], ...config?.theme };
     AppSettings.ApiVersion = version || AppSettings.ApiVersion;
     AppSettings.ImtblPassportConfig = imtblPassport;
-    AppSettings.TonClientConfig = config?.tonConfigs || AppSettings.TonClientConfig;
-    AppSettings.WalletConnectConfig = config?.walletConnect || AppSettings.WalletConnectConfig;
+    AppSettings.TonClientConfig = tonConfigs || AppSettings.TonClientConfig;
+    AppSettings.WalletConnectConfig = walletConnect || AppSettings.WalletConnectConfig;
     AppSettings.ThemeData = themeData;
     if (apiKey)
         LayerSwapApiClient.apiKey = apiKey;
@@ -44,7 +45,7 @@ const LayerswapProviderComponent = ({ children, callbacks, config, walletProvide
     if (!settings)
         return _jsx(WidgetLoading, {});
     let appSettings = new LayerSwapAppSettings(settings);
-    return (_jsx(IntercomProvider, { appId: INTERCOM_APP_ID, initializeDelay: 2500, children: _jsx(SettingsProvider, { initialLayerswapData: appSettings, initialSettings: config?.initialValues, children: _jsx(CallbackProvider, { callbacks: callbacks, children: _jsx(ErrorBoundary, { FallbackComponent: ErrorFallback, children: _jsx(ThemeWrapper, { children: _jsx(WalletsProviders, { appName: initialValues?.appName, themeData: themeData, walletProviders: walletProviders, children: _jsx(ResolverProviders, { walletProviders: walletProviders, children: _jsx(BalanceAccountsProvider, { children: _jsx(AsyncModalProvider, { children: children }) }) }) }) }) }) }) }) }));
+    return (_jsx(IntercomProvider, { appId: INTERCOM_APP_ID, initializeDelay: 2500, children: _jsx(SettingsProvider, { initialLayerswapData: appSettings, initialSettings: config?.initialValues, children: _jsx(CallbackProvider, { callbacks: callbacks, children: _jsx(ErrorProvider, { children: _jsx(ErrorBoundary, { FallbackComponent: ErrorFallback, children: _jsx(ThemeWrapper, { children: _jsx(WalletsProviders, { appName: initialValues?.appName, themeData: themeData, walletProviders: walletProviders, children: _jsx(ResolverProviders, { walletProviders: walletProviders, children: _jsx(SwapAccountsProvider, { children: _jsx(AsyncModalProvider, { children: children }) }) }) }) }) }) }) }) }) }));
 };
 export const LayerswapProvider = (props) => {
     return (_jsxs(_Fragment, { children: [_jsx(ColorSchema, { themeData: props.config?.theme }), _jsx("div", { style: { backgroundColor: 'transparent', height: '100%' }, className: "layerswap-styles", children: _jsx(LayerswapProviderComponent, { ...props, children: props.children }) })] }));

package/dist/esm/context/callbackProvider.js

@@ -1,58 +1,66 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useCallback } from 'react';
-const CallbackContext = createContext({});
-export function CallbackProvider({ children, callbacks = {} }) {
-    return (_jsx(CallbackContext.Provider, { value: callbacks, children: children }));
+import { createContext, useContext, useMemo } from 'react';
+import { ErrorHandler } from '../lib/ErrorHandler';
+const CallbackContext = createContext(undefined);
+export function CallbackProvider({ children, callbacks }) {
+    const value = useMemo(() => {
+        return {
+            onFormChange: (formData) => { try {
+                callbacks?.onFormChange?.(formData);
+            }
+            catch (error) {
+                ErrorHandler(error);
+            } },
+            onSwapCreate: (swapData) => { try {
+                callbacks?.onSwapCreate?.(swapData);
+            }
+            catch (error) {
+                ErrorHandler(error);
+            } },
+            onSwapComplete: (swapData) => { try {
+                callbacks?.onSwapComplete?.(swapData);
+            }
+            catch (error) {
+                ErrorHandler(error);
+            } },
+            onSwapModalStateChange: (open) => { try {
+                callbacks?.onSwapModalStateChange?.(open);
+            }
+            catch (error) {
+                ErrorHandler(error);
+            } },
+            onBackClick: () => { try {
+                callbacks?.onBackClick?.();
+            }
+            catch (error) {
+                ErrorHandler(error);
+            } },
+            onError: (error) => { try {
+                callbacks?.onError?.(error);
+            }
+            catch (error) {
+                ErrorHandler(error);
+            } },
+            onSwapStatusChange: (event) => { try {
+                callbacks?.onSwapStatusChange?.(event);
+            }
+            catch (error) {
+                ErrorHandler(error);
+            } },
+            onMenuNavigationChange: (path) => { try {
+                callbacks?.onMenuNavigationChange?.(path);
+            }
+            catch (error) {
+                ErrorHandler(error);
+            } },
+        };
+    }, [callbacks]);
+    return (_jsx(CallbackContext.Provider, { value: value, children: children }));
 }
 export function useCallbacks() {
     const context = useContext(CallbackContext);
+    if (!context) {
+        throw new Error('useCallbacks must be used within a CallbackProvider');
+    }
     return context;
 }
-export function useFormChangeCallback() {
-    const { onFormChange } = useCallbacks();
-    return useCallback((formData) => {
-        if (onFormChange) {
-            onFormChange(formData);
-        }
-    }, [onFormChange]);
-}
-export function useSwapCreateCallback() {
-    const { onSwapCreate } = useCallbacks();
-    return useCallback((swapData) => {
-        if (onSwapCreate) {
-            onSwapCreate(swapData);
-        }
-    }, [onSwapCreate]);
-}
-export function useSwapCompleteCallback() {
-    const { onSwapComplete } = useCallbacks();
-    return useCallback((swapData) => {
-        if (onSwapComplete) {
-            onSwapComplete(swapData);
-        }
-    }, [onSwapComplete]);
-}
-export function useSwapModalStateChangeCallback() {
-    const { onSwapModalStateChange } = useCallbacks();
-    return useCallback((open) => {
-        if (onSwapModalStateChange) {
-            onSwapModalStateChange(open);
-        }
-    }, [onSwapModalStateChange]);
-}
-export function useBackClickCallback() {
-    const { onBackClick } = useCallbacks();
-    return useCallback(() => {
-        if (onBackClick) {
-            onBackClick();
-        }
-    }, [onBackClick]);
-}
-export function useErrorCallback() {
-    const { onError } = useCallbacks();
-    return useCallback((error) => {
-        if (onError) {
-            onError(error);
-        }
-    }, [onError]);
-}

package/dist/esm/context/resolverContext.js

@@ -3,6 +3,15 @@ import { createContext, useContext, useMemo } from "react";
 import { resolverService } from "../lib/resolvers/resolverService";
 const ResolverContext = createContext(null);
 export const ResolverProviders = ({ children, walletProviders }) => {
+    const transferProviders = walletProviders
+        .map(provider => provider.transferProvider)
+        .flat()
+        .filter((provider) => Boolean(provider))
+        .map(provider => provider());
+    const contractAddressProviders = walletProviders
+        .map(provider => provider.contractAddressProvider)
+        .flat()
+        .filter((provider) => Boolean(provider));
     const isInitialized = useMemo(() => {
         // Extract balance providers from wallet providers
         const balanceProviders = walletProviders
@@ -23,9 +32,9 @@ export const ResolverProviders = ({ children, walletProviders }) => {
             .map(provider => provider.nftProvider)
             .flat()
             .filter((provider) => Boolean(provider));
-        resolverService.setProviders(balanceProviders, gasProviders, addressUtilsProviders, nftProviders);
+        resolverService.setProviders(balanceProviders, gasProviders, addressUtilsProviders, nftProviders, transferProviders, contractAddressProviders);
         return true;
-    }, [walletProviders]);
+    }, [walletProviders, transferProviders]);
     return (_jsx(ResolverContext.Provider, { value: { isInitialized }, children: children }));
 };
 export const useResolvers = () => {

package/dist/esm/context/swap.js

@@ -7,11 +7,11 @@ import useWallet from '../hooks/useWallet';
 import { useSettingsState } from './settings';
 import { transformSwapDataToQuoteArgs, useQuoteData } from '../hooks/useFee';
 import { useRecentNetworksStore } from '../stores/recentRoutesStore';
-import { useSelectedAccount } from './balanceAccounts';
+import { useSelectedAccount } from './swapAccounts';
 import { useInitialSettings } from './settings';
 import { addressFormat } from '../lib/address/formatter';
 import { useSlippageStore } from '../stores/slippageStore';
-// import { posthog } from 'posthog-js';
+import { useCallbacks } from './callbackProvider';
 export const SwapDataStateContext = createContext({
     depositAddressIsFromAccount: false,
     withdrawType: undefined,
@@ -31,18 +31,19 @@ export const SwapDataStateContext = createContext({
 });
 export const SwapDataUpdateContext = createContext(null);
 export function SwapDataProvider({ children }) {
+    const { sourceRoutes, destinationRoutes } = useSettingsState();
+    const initialSettings = useInitialSettings();
+    const { onSwapCreate } = useCallbacks();
+    const updateRecentTokens = useRecentNetworksStore(state => state.updateRecentNetworks);
+    const [swapBasicFormData, setSwapBasicFormData] = useState();
+    const { providers } = useWallet(swapBasicFormData?.source_network, 'asSource');
     const [quoteIsLoading, setQuoteLoading] = useState(false);
     const [withdrawType, setWithdrawType] = useState();
     const [depositAddressIsFromAccount, setDepositAddressIsFromAccount] = useState();
-    const initialSettings = useInitialSettings();
     const [swapId, setSwapId] = useState(initialSettings.swapId?.toString());
     const [swapTransaction, setSwapTransaction] = useState();
-    const { sourceRoutes, destinationRoutes } = useSettingsState();
-    const [swapBasicFormData, setSwapBasicFormData] = useState();
-    const updateRecentTokens = useRecentNetworksStore(state => state.updateRecentNetworks);
     const [swapModalOpen, setSwapModalOpen] = useState(false);
     const [swapError, setSwapError] = useState('');
-    const { providers } = useWallet(swapBasicFormData?.source_network, 'asSource');
     const quoteArgs = useMemo(() => transformSwapDataToQuoteArgs(swapBasicFormData, !!swapBasicFormData?.refuel), [swapBasicFormData]);
     const { quote: formDataQuote, quoteError: formDataQuoteError } = useQuoteData(quoteArgs, swapId ? 0 : undefined);
     const handleUpdateSwapid = (value) => {
@@ -169,17 +170,13 @@ export function SwapDataProvider({ children }) {
         const swap = swapResponse?.data;
         if (!swap?.swap.id)
             throw new Error("Could not create swap");
+        onSwapCreate(swap);
         updateRecentTokens({
             from: !fromExchange ? { network: from.name, token: fromCurrency.symbol } : undefined,
             to: { network: to.name, token: toCurrency.symbol }
         });
-        // posthog.capture('Swap initiated', {
-        //     name: 'Swap initiated',
-        //     swapId: swapDetails?.id ?? null,
-        //     path: typeof window !== 'undefined' ? window.location.pathname : undefined,
-        // });
         return swap;
-    }, [selectedSourceAccount, formDataQuote]);
+    }, [selectedSourceAccount, formDataQuote, onSwapCreate]);
     const updateFns = {
         createSwap,
         setInterval,

package/dist/esm/context/{balanceAccounts.js → swapAccounts.js}

@@ -3,9 +3,9 @@ import { createContext, useCallback, useContext, useMemo, useState } from 'react
 import useWallet from '../hooks/useWallet';
 import AddressIcon from '../components/Common/AddressIcon';
 import { getKey, useBalanceStore } from '../stores/balanceStore';
-const BalanceAccountsStateContext = createContext(null);
-const BalanceAccountsUpdateContext = createContext(null);
-export function BalanceAccountsProvider({ children }) {
+const SwapAccountsStateContext = createContext(null);
+const SwapAccountsUpdateContext = createContext(null);
+export function SwapAccountsProvider({ children }) {
     const [selectedDestAccounts, setSelectedDestinationAccounts] = useState([]);
     const [selectedSourceAccounts, setSelectedSourceAccounts] = useState([]);
     const { providers } = useWallet();
@@ -17,7 +17,7 @@ export function BalanceAccountsProvider({ children }) {
             const wallet = selectedWallet || provider.activeWallet;
             const selectedAccountAddress = selectedWallet ? selectedSourceAccounts.find(acc => acc.providerName === provider.name && acc.id === selectedWallet.id)?.address : undefined;
             const address = selectedAccountAddress ? selectedAccountAddress : wallet.address;
-            const res = ResolveWalletBalanceAccount(provider, wallet, address);
+            const res = ResolveWalletSwapAccount(provider, wallet, address);
             if (!selectedAccountAddress) {
                 setSelectedSourceAccounts(prev => {
                     const existingAccountIndex = prev.findIndex(acc => acc.providerName === res.providerName);
@@ -36,7 +36,7 @@ export function BalanceAccountsProvider({ children }) {
         return providers.map(provider => {
             const manuallyAdded = selectedDestAccounts.find(acc => acc.providerName === provider.name && acc.id === 'manually_added');
             if (manuallyAdded) {
-                return ResolveManualBalanceAccount(provider, manuallyAdded.address);
+                return ResolveManualSwapAccount(provider, manuallyAdded.address);
             }
             if (!hasWallet(provider))
                 return null;
@@ -44,7 +44,7 @@ export function BalanceAccountsProvider({ children }) {
             const wallet = selectedWallet || provider.activeWallet;
             const selectedAccountAddress = selectedWallet ? selectedDestAccounts.find(acc => acc.providerName === provider.name && acc.id === selectedWallet.id)?.address : undefined;
             const address = selectedAccountAddress ? selectedAccountAddress : wallet.address;
-            return ResolveWalletBalanceAccount(provider, wallet, address);
+            return ResolveWalletSwapAccount(provider, wallet, address);
         }).filter(Boolean);
     }, [providers, selectedDestAccounts]);
     const selectDestinationAccount = useCallback((account) => {
@@ -81,21 +81,21 @@ export function BalanceAccountsProvider({ children }) {
         selectDestinationAccount,
         selectSourceAccount,
     }), [sourceAccounts, destinationAccounts, selectSourceAccount, selectDestinationAccount]);
-    return (_jsx(BalanceAccountsStateContext.Provider, { value: stateValues, children: _jsx(BalanceAccountsUpdateContext.Provider, { value: update, children: children }) }));
+    return (_jsx(SwapAccountsStateContext.Provider, { value: stateValues, children: _jsx(SwapAccountsUpdateContext.Provider, { value: update, children: children }) }));
 }
-export function useBalanceAccounts(direction) {
-    const values = useContext(BalanceAccountsStateContext);
+export function useSwapAccounts(direction) {
+    const values = useContext(SwapAccountsStateContext);
     if (values === undefined) {
-        throw new Error('useBalanceAccounts must be used within a BalanceAccountsProvider');
+        throw new Error('useSwapAccounts must be used within a SwapAccountsProvider');
     }
     return direction === "from" ? values.sourceAccounts : values.destinationAccounts;
 }
 export function useSelectedAccount(direction, networkName) {
-    const values = useContext(BalanceAccountsStateContext);
+    const values = useContext(SwapAccountsStateContext);
     if (!networkName)
         return undefined;
     if (values === undefined) {
-        throw new Error('useBalanceAccounts must be used within a BalanceAccountsProvider');
+        throw new Error('useSwapAccounts must be used within a SwapAccountsProvider');
     }
     return direction === "from" ? values.sourceAccounts.find(acc => acc.provider.withdrawalSupportedNetworks?.some(n => n === networkName))
         :
@@ -117,17 +117,17 @@ export function useNetworkBalance(direction, networkName) {
     const balance = useBalanceStore((s) => (s.balances[balanceKey || "unknown"]));
     return balance;
 }
-export function useUpdateBalanceAccount(direction) {
-    const values = useContext(BalanceAccountsUpdateContext);
+export function useSelectSwapAccount(direction) {
+    const values = useContext(SwapAccountsUpdateContext);
     if (values === undefined) {
-        throw new Error('useUpdateBalanceAccount must be used within a BalanceAccountsUpdateContext');
+        throw new Error('useSelectSwapAccount must be used within a SwapAccountsUpdateContext');
     }
     return direction === "from" ? values.selectSourceAccount : values.selectDestinationAccount;
 }
 function hasWallet(p) {
     return Boolean(p.activeWallet);
 }
-function ResolveWalletBalanceAccount(provider, wallet, address) {
+function ResolveWalletSwapAccount(provider, wallet, address) {
     return {
         address,
         provider,
@@ -141,7 +141,7 @@ function ResolveWalletBalanceAccount(provider, wallet, address) {
         icon: wallet.icon || ((props) => _jsx(AddressIcon, { address: address, size: 24, ...props })),
     };
 }
-function ResolveManualBalanceAccount(provider, address) {
+function ResolveManualSwapAccount(provider, address) {
     return {
         address,
         provider,

package/dist/esm/context/validationContext.js

@@ -6,7 +6,7 @@ import { transformFormValuesToQuoteArgs, useQuoteData } from '../hooks/useFee';
 import { resolveFormValidation } from '../hooks/useFormValidation';
 import { resolveRouteValidation } from '../hooks/useRouteValidation';
 import { useSwapDataState } from './swap';
-import { useSelectedAccount } from './balanceAccounts';
+import { useSelectedAccount } from './swapAccounts';
 const defaultContext = {
     formValidation: { message: '' },
     routeValidation: { message: '', details: {} },

package/dist/esm/context/walletProviders.js

@@ -8,10 +8,15 @@ import { ChevronLeft } from "lucide-react";
 import ConnectorsList from "../components/Wallet/WalletModal/ConnectorsList";
 import { useConnectModal } from "../components/Wallet/WalletModal";
 import { isMobile } from "../lib/wallets/utils/isMobile";
+import AppSettings from "../lib/AppSettings";
+import { filterSourceNetworks } from "../helpers/filterSourceNetworks";
+import useWindowDimensions from "../hooks/useWindowDimensions";
 const WalletProvidersContext = createContext([]);
 export const WalletProvidersProvider = ({ children, walletProviders }) => {
     const { networks } = useSettingsState();
+    const settings = useSettingsState();
     const isMobilePlatform = isMobile();
+    const { isMobile: isMobileSize } = useWindowDimensions();
     const { goBack, onFinish, open, setOpen, selectedConnector, selectedMultiChainConnector } = useConnectModal();
     const allProviders = walletProviders.map(provider => provider.walletConnectionProvider ? provider.walletConnectionProvider({ networks }) : undefined).filter(provider => provider !== undefined);
     const providers = useMemo(() => {
@@ -19,9 +24,10 @@ export const WalletProvidersProvider = ({ children, walletProviders }) => {
             networks.some(net => provider.autofillSupportedNetworks?.includes(net.name) ||
                 provider.withdrawalSupportedNetworks?.includes(net.name) ||
                 provider.asSourceSupportedNetworks?.includes(net.name)));
+        AppSettings.AvailableSourceNetworkTypes = filterSourceNetworks(settings, filteredProviders);
         return filteredProviders;
     }, [networks, isMobilePlatform, allProviders]);
     return (_jsxs(WalletProvidersContext.Provider, { value: providers, children: [children, _jsx(VaulDrawer, { show: open, setShow: setOpen, onClose: onFinish, modalId: "connectNewWallet", header: _jsxs("div", { className: "flex items-center gap-1", children: [(selectedConnector || selectedMultiChainConnector) &&
-                            _jsx("div", { className: "sm:-ml-2 -ml-0", children: _jsx(IconButton, { onClick: goBack, icon: _jsx(ChevronLeft, { className: "h-6 w-6" }) }) }), _jsx("p", { children: (selectedMultiChainConnector && !selectedConnector) ? "Select ecosystem" : "Connect wallet" })] }), children: _jsx(VaulDrawer.Snap, { openFullHeight: !isMobilePlatform, id: 'item-1', className: "pb-4 sm:!pb-0 sm:h-full", children: _jsx(ConnectorsList, { onFinish: onFinish }) }) })] }));
+                            _jsx("div", { className: "sm:-ml-2 ml-0", children: _jsx(IconButton, { onClick: goBack, icon: _jsx(ChevronLeft, { className: "h-6 w-6" }) }) }), _jsx("p", { children: (selectedMultiChainConnector && !selectedConnector) ? "Select ecosystem" : "Connect wallet" })] }), children: _jsx(VaulDrawer.Snap, { openFullHeight: !isMobileSize, id: 'item-1', className: "pb-4 sm:pb-0! sm:h-full", children: _jsx(ConnectorsList, { onFinish: onFinish }) }) })] }));
 };
 export const useWalletProviders = () => useContext(WalletProvidersContext);

package/dist/esm/context/withdrawalContext.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 const WalletWithdrawalContext = React.createContext(null);
-export const WithdrawalProvider = ({ onWalletWithdrawalSuccess, children }) => {
-    return (_jsx(WalletWithdrawalContext.Provider, { value: { onWalletWithdrawalSuccess }, children: children }));
+export const WithdrawalProvider = ({ onWalletWithdrawalSuccess, onCancelWithdrawal, children }) => {
+    return (_jsx(WalletWithdrawalContext.Provider, { value: { onWalletWithdrawalSuccess, onCancelWithdrawal }, children: children }));
 };
 export function useWalletWithdrawalState() {
     const data = React.useContext(WalletWithdrawalContext);

package/dist/esm/exports/internal.js

@@ -3,8 +3,6 @@ import KnownInternalNames from "../lib/knownIds";
 export { KnownInternalNames };
 import NetworkSettings from "../lib/NetworkSettings";
 export { NetworkSettings };
-import logError from "../lib/logError";
-export { logError };
 export { insertIfNotExists } from "../lib/balances/helpers";
 export * from "../lib/retry";
 export { fetchWithTimeout } from "../lib/fetchWithTimeout";
@@ -18,11 +16,14 @@ export * from "../components/shadcn";
 export { default as WalletMessage } from "../components/Pages/Swap/Withdraw/messages/Message";
 export * from "../components/Buttons";
 export * from "../components/Pages/Swap/Withdraw/Wallet/Common/buttons";
+export * from "../components/Pages/Swap/Withdraw/Wallet/Common/actionMessage";
 export { default as ClickTooltip } from "../components/Common/ClickTooltip";
-export { useSelectedAccount, useUpdateBalanceAccount, useBalanceAccounts, useNetworkBalance } from "../context/balanceAccounts";
+export { useSelectedAccount, useSelectSwapAccount, useSwapAccounts, useNetworkBalance } from "../context/swapAccounts";
 export { default as useWallet } from "../hooks/useWallet";
 export * from "../lib/apiClients";
 export * from "../lib/formatUnits";
 export * from "../stores";
 export { default as shortenAddress } from "../components/utils/ShortenAddress";
 export * from "../context/swap";
+export { useWalletProvidersList } from "../components/Wallet/WalletProviders";
+export { ErrorHandler } from '../lib/ErrorHandler';

package/dist/esm/helpers/filterSourceNetworks.js

@@ -0,0 +1,23 @@
+export function filterSourceNetworks(settings, walletProviders) {
+    const networkTypesAggregation = settings.sourceRoutes?.reduce((acc, route) => {
+        if (!acc[route.type]) {
+            acc[route.type] = [];
+        }
+        acc[route.type].push(route);
+        return acc;
+    }, {}) || {};
+    const allNetworkTypes = Object.keys(networkTypesAggregation);
+    const availableNetworkTypes = allNetworkTypes.filter(networkType => {
+        return networkTypesAggregation[networkType].some(route => route.deposit_methods.includes("deposit_address") ||
+            walletProviders.some(provider => provider.withdrawalSupportedNetworks.includes(route.name)));
+    });
+    if (availableNetworkTypes.length === allNetworkTypes.length) {
+        return {
+            all: true,
+        };
+    }
+    return {
+        all: false,
+        networks: availableNetworkTypes
+    };
+}

package/dist/esm/helpers/getSettings/getSettings.js

@@ -2,17 +2,22 @@ import LayerSwapApiClient from "../../lib/apiClients/layerSwapApiClient";
 export async function getSettings(apiKey) {
     const apiClient = new LayerSwapApiClient();
     LayerSwapApiClient.apiKey = apiKey;
-    const { data: networkData } = await apiClient.GetLSNetworksAsync();
-    const { data: sourceExchangesData } = await apiClient.GetSourceExchangesAsync();
-    const { data: sourceRoutes } = await apiClient.GetRoutesAsync('sources');
-    const { data: destinationRoutes } = await apiClient.GetRoutesAsync('destinations');
-    if (!networkData)
-        return;
-    const settings = {
-        networks: networkData,
-        sourceExchanges: sourceExchangesData || [],
-        sourceRoutes: sourceRoutes || [],
-        destinationRoutes: destinationRoutes || []
-    };
-    return settings;
+    try {
+        const { data: networkData } = await apiClient.GetLSNetworksAsync();
+        const { data: sourceExchangesData } = await apiClient.GetSourceExchangesAsync();
+        const { data: sourceRoutes } = await apiClient.GetRoutesAsync('sources');
+        const { data: destinationRoutes } = await apiClient.GetRoutesAsync('destinations');
+        if (!networkData)
+            return;
+        const settings = {
+            networks: networkData,
+            sourceExchanges: sourceExchangesData || [],
+            sourceRoutes: sourceRoutes || [],
+            destinationRoutes: destinationRoutes || []
+        };
+        return settings;
+    }
+    catch (error) {
+        return null;
+    }
 }

package/dist/esm/helpers/routes.js

@@ -1,3 +1,4 @@
+import AppSettings from "../lib/AppSettings";
 export const resolveExchangesURLForSelectedToken = (values) => {
     const include_unmatched = 'true';
     const include_swaps = 'false';
@@ -62,7 +63,9 @@ export const resolveRoutesURLForSelectedToken = ({ direction, network, token, in
             }
             : {})
     });
-    const sourceRoutesURL = `/sources?${params.toString()}`;
+    const availableNetworkTypes = AppSettings.AvailableSourceNetworkTypes;
+    const networkTypesQuery = availableNetworkTypes?.all ? '' : availableNetworkTypes?.networks?.map(type => `network_types=${type}`).join('&') || '';
+    const sourceRoutesURL = `/sources?${params.toString()}${networkTypesQuery ? `&${networkTypesQuery}` : ''}`;
     const destinationRoutesURL = `/destinations?${params.toString()}`;
     const result = direction === "from" ? sourceRoutesURL : destinationRoutesURL;
     return result;

package/dist/esm/hooks/useAllWithdrawalBalances.js

@@ -1,12 +1,12 @@
 import { useSettingsState } from "../context/settings";
 import { selectResolvedSortingBalances, useBalanceStore } from "../stores/balanceStore";
 import { useEffect, useMemo, useRef } from "react";
-import { useBalanceAccounts } from "../context/balanceAccounts";
+import { useSwapAccounts } from "../context/swapAccounts";
 export default function useAllWithdrawalBalances() {
     const networks = useSettingsState().networks;
-    const balanceAccounts = useBalanceAccounts("from");
+    const swapAccounts = useSwapAccounts("from");
     const walletNetworks = useMemo(() => {
-        return balanceAccounts.map(account => {
+        return swapAccounts.map(account => {
             const withdrawalNetworks = account.walletWithdrawalSupportedNetworks;
             if (!withdrawalNetworks || withdrawalNetworks.length === 0)
                 return [];
@@ -20,7 +20,7 @@ export default function useAllWithdrawalBalances() {
                 };
             });
         }).flat().filter(item => item !== null);
-    }, [balanceAccounts, networks]);
+    }, [swapAccounts, networks]);
     const walletNetwokrsString = useMemo(() => {
         return walletNetworks.map(item => `${item.address}-${item.network.name}`).join(',');
     }, [walletNetworks]);
@@ -28,12 +28,18 @@ export default function useAllWithdrawalBalances() {
         if (walletNetworks)
             useBalanceStore.getState().initSortingBalances(walletNetworks);
     }, [walletNetwokrsString]);
+    useEffect(() => {
+        return () => {
+            useBalanceStore.getState().cleanupSortingBalances();
+        };
+    }, []);
     const lastBalancesRef = useRef(null);
     const resolvedBalances = useBalanceStore(selectResolvedSortingBalances);
     const isLoading = useBalanceStore(s => s.sortingDataIsLoading);
+    const partialPublished = useBalanceStore(s => s.partialPublished);
     if (resolvedBalances != null && Object.keys(resolvedBalances).length > 0) {
         lastBalancesRef.current = resolvedBalances;
     }
     const result = resolvedBalances === null && isLoading ? lastBalancesRef.current : resolvedBalances;
-    return useMemo(() => ({ isLoading, balances: result }), [result, isLoading]);
+    return useMemo(() => ({ isLoading, balances: result, partialPublished }), [result, isLoading, partialPublished]);
 }

package/dist/esm/hooks/useConnectors.js

@@ -0,0 +1,72 @@
+import { useMemo } from "react";
+export function useConnectors({ featuredProviders, filteredProviders, searchValue, recentConnectors, }) {
+    const featuredConnectors = useMemo(() => featuredProviders
+        .filter(g => g.availableWalletsForConnect && g.availableWalletsForConnect?.length > 0)
+        .map((provider) => provider.availableWalletsForConnect
+        ?.filter(v => searchValue ? v.name.toLowerCase().includes(searchValue.toLowerCase()) : true)
+        .map((connector) => ({ ...connector, providerName: provider.name })))
+        .flat(), [featuredProviders, searchValue]);
+    const hiddenConnectors = useMemo(() => featuredProviders
+        .filter(g => g.availableHiddenWalletsForConnect && g.availableHiddenWalletsForConnect?.length > 0)
+        .map((provider) => provider.availableHiddenWalletsForConnect
+        ?.filter(v => (searchValue ? v.name.toLowerCase().includes(searchValue.toLowerCase()) : true) &&
+        !featuredWalletsIds.includes(v.id.toLowerCase()))
+        .map((connector) => ({ ...connector, providerName: provider.name, isHidden: true })))
+        .flat(), [featuredProviders, searchValue]);
+    const initialConnectors = useMemo(() => {
+        return removeDuplicatesWithKey([...featuredConnectors, ...hiddenConnectors]
+            .sort((a, b) => sortRecentConnectors(a, b, recentConnectors)), 'name');
+    }, [featuredConnectors, hiddenConnectors, searchValue?.length, recentConnectors]);
+    return {
+        featuredConnectors,
+        hiddenConnectors,
+        initialConnectors,
+        featuredProviders,
+        filteredProviders,
+    };
+}
+const featuredWalletsIds = [
+    'metamask',
+    'argent',
+    'rainbow',
+    'bitkeep',
+    'okx-wallet',
+];
+function removeDuplicatesWithKey(arr, key) {
+    const countMap = {};
+    // First pass: Count occurrences of each unique key.
+    arr.forEach(item => {
+        const identifier = item[key];
+        countMap[identifier] = (countMap[identifier] || 0) + 1;
+    });
+    // Second pass: Create a new array with one instance of each object.
+    const unique = [];
+    const seen = new Set();
+    arr.forEach(item => {
+        const identifier = item[key];
+        if (!seen.has(identifier)) {
+            seen.add(identifier);
+            // Add a property 'duplicateCount' to indicate extra duplicates found.
+            unique.push({
+                ...item,
+                isMultiChain: countMap[identifier] > 1
+            });
+        }
+    });
+    return unique;
+}
+export function sortRecentConnectors(a, b, recentConnectors) {
+    function getIndex(c) {
+        const idx = recentConnectors?.findIndex(v => v.connectorName === c.name);
+        return idx === -1 ? Infinity : idx;
+    }
+    const indexA = getIndex(a);
+    const indexB = getIndex(b);
+    if (indexA !== indexB) {
+        return indexA - indexB;
+    }
+    if (a.type && b.type) {
+        return a.type.localeCompare(b.type);
+    }
+    return 0;
+}