@layerswap/widget 1.0.6 → 1.1.0

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]);
@@ -31,9 +31,10 @@ export default function useAllWithdrawalBalances() {
     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/useFormRoutes.js

@@ -19,14 +19,25 @@ export default function useFormRoutes({ direction, values }, search) {
     });
     const { lockFrom, from, lockTo, to, lockFromAsset, fromAsset, lockToAsset, toAsset } = useInitialSettings();
     const groupByToken = useRouteTokenSwitchStore((s) => s.showTokens);
-    const { balances, isLoading: balancesLoading } = useAllWithdrawalBalances();
+    const { balances, partialPublished, isLoading } = useAllWithdrawalBalances();
     const routesHistory = useRecentNetworksStore(state => state.recentRoutes);
+    const loadingSuggestions = useMemo(() => {
+        return !partialPublished && isLoading && direction === "from";
+    }, [isLoading, direction, partialPublished]);
     // 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 routeElements = useMemo(() => groupRoutes({
+        routes: filteredRoutes,
+        direction,
+        balances,
+        groupBy: groupByToken ? "token" : "network",
+        recents: routesHistory,
+        balancesLoaded: loadingSuggestions,
+        search
+    }), [filteredRoutes, balances, direction, search, groupByToken, routesHistory, loadingSuggestions]);
     const exchanges = useMemo(() => {
         return groupExchanges(exchangesRoutes, search, direction, { lockFrom, from, lockTo, to });
     }, [exchangesRoutes, search, direction, lockFrom, from, lockTo, to]);
@@ -42,7 +53,6 @@ export default function useFormRoutes({ direction, values }, search) {
         exchangeSourceNetworksLoading,
         selectedRoute,
         selectedToken,
-        allbalancesLoaded: !balancesLoading,
     }), [
         filteredRoutes,
         routesLoading,
@@ -52,8 +62,7 @@ export default function useFormRoutes({ direction, values }, search) {
         withdrawalNetworks,
         exchangeSourceNetworksLoading,
         selectedRoute,
-        selectedToken,
-        balancesLoading,
+        selectedToken
     ]);
 }
 function useRoutesData(url, defaultData, fetcher) {
@@ -169,12 +178,11 @@ const searchInTokens = (routes, search) => {
         return symbolMatch || contractMatch || nameMatch || combo;
     });
 };
-// ---------- Route Grouping ----------
-function groupRoutes(routes, direction, balances, groupBy = 'network', recents, balancesLoading, search) {
+function groupRoutes({ routes, direction, balances, groupBy, recents, balancesLoaded, search }) {
     if (search) {
         return resolveSearch(routes, search, direction, balances, recents);
     }
-    const suggestedRoutes = getSuggestedRoutes(routes, balances, recents, direction, balancesLoading);
+    const suggestedRoutes = getSuggestedRoutes(routes, balances, recents, direction, balancesLoaded);
     if (groupBy === "token") {
         const groupedTokens = resolveTokenRoutes(routes, balances, direction);
         return mergeGroups(suggestedRoutes, groupedTokens);

package/dist/esm/hooks/useFormValidation.js

@@ -1,5 +1,6 @@
 import { isValidAddress } from '../lib/address/validator';
 export const FORM_VALIDATION_ERROR_CODES = {
+    ROUTE_NOT_FOUND: "ROUTE_NOT_FOUND",
     MIN_AMOUNT_ERROR: "MIN_AMOUNT_ERROR",
     MAX_AMOUNT_ERROR: "MAX_AMOUNT_ERROR",
 };
@@ -20,9 +21,6 @@ export function resolveFormValidation({ values, maxAllowedAmount, minAllowedAmou
     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" };
     }
@@ -32,6 +30,9 @@ export function resolveFormValidation({ values, maxAllowedAmount, minAllowedAmou
     if (minAllowedAmount != undefined && amount < minAllowedAmount) {
         return { code: FORM_VALIDATION_ERROR_CODES.MIN_AMOUNT_ERROR, message: `Min amount is ${minAllowedAmount}` };
     }
+    if (!/^[0-9]*[.,]?[0-9]*$/i.test(amount.toString())) {
+        return { message: 'Invalid amount' };
+    }
     if (values.to) {
         if (values.destination_address && !isValidAddress(values.destination_address, values.to)) {
             return { message: `Enter a valid ${values.to?.display_name} address` };
@@ -50,7 +51,7 @@ export function resolveFormValidation({ values, maxAllowedAmount, minAllowedAmou
     }
     const quoteErrorCode = quoteError?.response?.data?.error?.code || quoteError?.code;
     if (quoteError && quoteErrorCode !== "QUOTE_REQUIRES_NO_DEPOSIT_ADDRESS") {
-        return { message: 'Route not found' };
+        return { message: 'Route not found', code: FORM_VALIDATION_ERROR_CODES.ROUTE_NOT_FOUND };
     }
     return { message: '' };
 }

package/dist/esm/hooks/useRouteValidation.js

@@ -3,7 +3,7 @@ import { RouteOff } from 'lucide-react';
 import { useMemo } from 'react';
 import { useInitialSettings } from '../context/settings';
 import { useFormikContext } from 'formik';
-import { useSelectedAccount } from '../context/balanceAccounts';
+import { useSelectedAccount } from '../context/swapAccounts';
 import { ICON_CLASSES_WARNING } from '../components/Pages/Swap/Form/SecondaryComponents/validationError/constants';
 export function resolveRouteValidation(quoteError) {
     const { values } = useFormikContext();

package/dist/esm/hooks/useSwrSwaps.js

@@ -6,7 +6,7 @@ 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}`;
+    return `/swaps/internal?page=${index + 1}${statusesParams}${addressesParams}`;
 };
 export function useSwrSwaps({ statuses, addresses, refreshInterval, autoLoadAllInitially, revalidateAll, revalidateFirstPage }) {
     const apiClient = new LayerSwapApiClient();

package/dist/esm/hooks/useTransfer.js

@@ -0,0 +1,9 @@
+import { resolverService } from "../lib/resolvers/resolverService";
+import { useCallback } from "react";
+export function useTransfer() {
+    const executeTransfer = useCallback(async (params, wallet) => {
+        const transferResolver = resolverService.getTransferResolver();
+        return transferResolver.executeTransfer(params, wallet);
+    }, []);
+    return { executeTransfer };
+}

package/dist/esm/hooks/useWallet.js

@@ -39,26 +39,26 @@ const resolveProvider = (network, walletProviders, purpose) => {
         case "withdrawal":
             provider = walletProviders.find(provider => provider.withdrawalSupportedNetworks?.includes(network.name));
             break;
-        case "autofil":
+        case "autofill":
             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);
+    if (provider?.isNotAvailableCondition && purpose) {
+        const availableWalletsForConnect = provider.availableWalletsForConnect?.filter(connector => (provider.isNotAvailableCondition && network?.name) ? !provider.isNotAvailableCondition(connector.id, network?.name, purpose) : 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,
+                    isNotAvailable: (provider.isNotAvailableCondition && network?.name && wallet.internalId) ? provider.isNotAvailableCondition(wallet.internalId, network?.name, purpose) : false,
                 };
             }),
             activeWallet: provider.activeWallet ? {
                 ...provider.activeWallet,
-                isNotAvailable: (network?.name) ? provider.isNotAvailableCondition(provider.activeWallet.id, network?.name) : false,
+                isNotAvailable: (network?.name) ? provider.isNotAvailableCondition(provider.activeWallet.id, network?.name, purpose) : false,
             } : undefined,
             availableWalletsForConnect
         };
@@ -67,13 +67,13 @@ const resolveProvider = (network, walletProviders, purpose) => {
     return provider;
 };
 const resolveWallet = (wallet, network, provider, purpose) => {
-    if (provider.isNotAvailableCondition && network?.name && wallet.internalId) {
+    if (provider.isNotAvailableCondition && network?.name && wallet.internalId && !purpose) {
         return {
             ...wallet,
             isNotAvailable: provider.isNotAvailableCondition(wallet.internalId, network?.name),
         };
     }
-    if (purpose === "autofil") {
+    if (purpose === "autofill") {
         return {
             ...wallet,
             isNotAvailable: !wallet.autofillSupportedNetworks?.some(n => n.toLowerCase() === network?.name.toLowerCase()),

package/dist/esm/lib/AppSettings.js

@@ -1,33 +1,44 @@
-class AppSettings {
+class WalletsConfigs {
 }
-AppSettings.ApiVersion = "mainnet";
-AppSettings.ExplorerURl = `https://www.layerswap.io/explorer/`;
-AppSettings.LayerswapApiUri = 'https://api.layerswap.io';
-AppSettings.ResourseStorageUrl = 'https://prodlslayerswapbridgesa.blob.core.windows.net/';
-AppSettings.TelegramLogConfigs = {
-    feedback_token: '',
-    feedback_chat_id: '',
-    error_token: '',
-    error_chat_id: ''
-};
-AppSettings.WalletConnectConfig = {
+/**
+ * @deprecated Pass `walletConnectConfigs` directly to the wallet provider factory
+ * (e.g. `createEVMProvider({ walletConnectConfigs })`). This static config will be removed soon.
+ */
+WalletsConfigs.WalletConnectConfig = {
     projectId: '28168903b2d30c75e5f7f2d71902581b',
     name: 'Layerswap',
     description: 'Layerswap App',
     url: 'https://layerswap.io/app/',
-    icons: ['https://www.layerswap.io/app/symbol.png'],
+    icons: ['https://www.layerswap.io/app/symbol.png']
 };
-AppSettings.TonClientConfig = {
+/**
+ * @deprecated Pass `tonConfigs` to `createTONProvider({ tonConfigs })`. This fallback will be removed.
+ */
+WalletsConfigs.TonClientConfig = {
     tonApiKey: '815b3d3036592d941bbcec5a4db824a588c1b2d210c3a4b6d188dcd4a15337d2',
     manifestUrl: `https://layerswap.io/app/tonconnect-manifest.json`
 };
-AppSettings.ImtblPassportConfig = {
+/**
+ * @deprecated Pass `imtblPassportConfig` to `createImmutablePassportProvider({ imtblPassportConfig })`.
+ */
+WalletsConfigs.ImtblPassportConfig = {
     publishableKey: "",
     clientId: "",
     redirectUri: "",
     logoutRedirectUri: ""
 };
-AppSettings.DisableExchanges = false;
+class AppSettings extends WalletsConfigs {
+}
+AppSettings.ApiVersion = "mainnet";
+AppSettings.ExplorerURl = `https://www.layerswap.io/explorer/`;
+AppSettings.LayerswapApiUri = 'https://api.layerswap.io';
+AppSettings.ResourseStorageUrl = 'https://prodlslayerswapbridgesa.blob.core.windows.net/';
+AppSettings.TelegramLogConfigs = {
+    feedback_token: '',
+    feedback_chat_id: '',
+    error_token: '',
+    error_chat_id: ''
+};
 AppSettings.LayerswapApiKeys = {
     'mainnet': 'NDBxG+aon6WlbgIA2LfwmcbLU52qUL9qTnztTuTRPNSohf/VnxXpRaJlA5uLSQVqP8YGIiy/0mz+mMeZhLY4/Q',
     'testnet': 'Dz1jVir9WUD0gBWoGbOmS1oe5K4985SGptaZXjF4z9VVrvO5nC9q55h8TE/3CIESRxWdYVpPnz/H2BogL2eG+A'

package/dist/esm/lib/ErrorHandler.js

@@ -0,0 +1,6 @@
+import { logStore } from "../stores/logStore";
+export function ErrorHandler(event) {
+    const { logger } = logStore.getState();
+    ;
+    return logger(event);
+}

package/dist/esm/lib/apiClients/layerSwapApiClient.js

@@ -3,7 +3,7 @@ import { InitializeUnauthInstance, InitializeAuthInstance } from "../axiosInterc
 import { v4 as uuidv4 } from 'uuid';
 import { AuthRefreshFailedError } from "../Errors/AuthRefreshFailedError";
 import { EmptyApiResponse } from "../../Models/ApiResponse";
-// import posthog from "posthog-js";
+import { ErrorHandler } from "../../lib/ErrorHandler";
 class LayerSwapApiClient {
     constructor() {
         this.fetcher = (url) => this.AuthenticatedRequest("GET", url);
@@ -23,31 +23,12 @@ class LayerSwapApiClient {
         const correlationId = uuidv4();
         return await this.AuthenticatedRequest("POST", `/swaps`, params, { 'X-LS-CORRELATION-ID': correlationId });
     }
-    async GetSwapsAsync(page, include_expired) {
-        return await this.AuthenticatedRequest("GET", `/internal/swaps?page=${page}&include_expired=${include_expired}`);
-    }
-    async GetQuote({ params }) {
-        const { source_network, source_token, source_address, destination_token, destination_network, amount, use_deposit_address, include_gas, refuel } = params;
-        return await this.AuthenticatedRequest("GET", `/quote?source_network=${source_network}&source_token=${source_token}&source_address=${source_address}&destination_network=${destination_network}&destination_token=${destination_token}&use_deposit_address=${use_deposit_address}&include_gas=${include_gas}&amount=${amount}&refuel=${refuel}`);
-    }
-    async DisconnectExchangeAsync(swapid, exchangeName) {
-        return await this.AuthenticatedRequest("DELETE", `/internal/swaps/${swapid}/exchange/${exchangeName}/disconnect`);
-    }
-    async GetSwapDetailsAsync(id) {
-        return await this.AuthenticatedRequest("GET", `/swaps/${id}`);
-    }
-    async GetDepositAddress(network, source) {
-        return await this.AuthenticatedRequest("GET", `/internal/swaps?network=${network}&source=${source}`);
-    }
-    async WithdrawFromExchange(swapId, exchange, twoFactorCode) {
-        return await this.AuthenticatedRequest("POST", `/internal/swaps/${swapId}/exchange/${exchange}/withdraw${twoFactorCode ? `?twoFactorCode=${twoFactorCode}` : ''}`);
-    }
-    async SwapsMigration(GuestAuthorization) {
-        return await this.AuthenticatedRequest("POST", `/internal/swaps/migrate`, null, { GuestAuthorization });
-    }
     async GetTransactionStatus(network, tx_id) {
         return await this.UnauthenticatedRequest("GET", `/transaction_status?network=${network}&transaction_id=${tx_id}`);
     }
+    async SwapCatchup(swapId, tx_id) {
+        return await this.AuthenticatedRequest("POST", `/swaps/${swapId}/deposit_speedup`, { transaction_id: tx_id });
+    }
     async AuthenticatedRequest(method, endpoint, data, header) {
         let uri = LayerSwapApiClient.apiBaseEndpoint + "/api/v2" + endpoint;
         return await this._authInterceptor(uri, { method: method, data: data, headers: { 'Access-Control-Allow-Origin': '*', ...(header ? header : {}) } })
@@ -59,18 +40,14 @@ class LayerSwapApiClient {
                 return Promise.resolve(new EmptyApiResponse());
             }
             else {
-                const renderingError = new Error(`API request error with uri:${uri}`);
-                renderingError.name = `APIError`;
-                renderingError.cause = reason;
-                // posthog.capture('$exception', {
-                //     name: renderingError.name,
-                //     message: renderingError.message,
-                //     $layerswap_exception_type: "API Error",
-                //     stack: renderingError.stack,
-                //     cause: renderingError.cause,
-                //     where: 'apiClient',
-                //     severity: 'error',
-                // });
+                const error = reason;
+                ErrorHandler({
+                    type: 'APIError',
+                    message: error.message,
+                    name: error.name,
+                    stack: error.stack,
+                    cause: error.cause
+                });
                 return Promise.reject(reason);
             }
         });

package/dist/esm/lib/balances/balanceResolver.js

@@ -1,3 +1,4 @@
+import { ErrorHandler } from "../../lib/ErrorHandler";
 export class BalanceResolver {
     constructor(providers) {
         this.providers = providers || [];
@@ -15,19 +16,14 @@ export class BalanceResolver {
             return { balances };
         }
         catch (e) {
-            const error = new Error(e);
-            error.name = "BalanceError";
-            error.cause = e;
-            // posthog.capture('$exception', {
-            //     name: error.name,
-            //     message: error.message,
-            //     $layerswap_exception_type: "Balance Error",
-            //     stack: error.stack,
-            //     cause: error.cause,
-            //     type: 'BalanceError',
-            //     where: 'BalanceProviderError',
-            //     severity: 'error',
-            // });
+            const error = e;
+            ErrorHandler({
+                type: 'BalanceResolverError',
+                message: error.message,
+                name: error.name,
+                stack: error.stack,
+                cause: error
+            });
             return { balances: [] };
         }
     }

package/dist/esm/lib/fees.js

@@ -1,3 +1,53 @@
 export function CalculateMinimalAuthorizeAmount(usd_price, amount) {
     return Math.ceil((usd_price * amount) + (usd_price * amount * 0.02));
 }
+export const resolvePriceImpactValues = (quote) => {
+    const receiveAmount = quote?.receive_amount;
+    const requestedAmount = quote?.requested_amount;
+    const sourceTokenPriceUsd = quote?.source_token?.price_in_usd;
+    const destinationTokenPriceUsd = quote?.destination_token?.price_in_usd;
+    const serviceFee = quote?.service_fee;
+    const bridgeFee = quote?.blockchain_fee;
+    const receiveAmountUSD = receiveAmount && destinationTokenPriceUsd
+        ? receiveAmount * destinationTokenPriceUsd
+        : undefined;
+    const requestedAmountUSD = requestedAmount && sourceTokenPriceUsd
+        ? requestedAmount * sourceTokenPriceUsd
+        : undefined;
+    const priceImpact = requestedAmountUSD !== undefined && receiveAmountUSD !== undefined
+        ? receiveAmountUSD - requestedAmountUSD
+        : undefined;
+    const layerswapFees = serviceFee != null && sourceTokenPriceUsd != null
+        ? serviceFee * sourceTokenPriceUsd
+        : undefined;
+    const bridgeExpenses = bridgeFee != null && sourceTokenPriceUsd != null
+        ? bridgeFee * sourceTokenPriceUsd
+        : undefined;
+    const marketImpact = priceImpact !== undefined && layerswapFees !== undefined && bridgeExpenses !== undefined
+        ? priceImpact + Number(layerswapFees) + Number(bridgeExpenses)
+        : undefined;
+    const priceImpactPercentage = requestedAmountUSD !== undefined && receiveAmountUSD !== undefined
+        ? Number((((receiveAmountUSD - requestedAmountUSD) / requestedAmountUSD) * 100).toFixed(2))
+        : undefined;
+    const marketImpactPercentage = marketImpact !== undefined && requestedAmountUSD !== undefined && requestedAmountUSD > 0
+        ? Number(((marketImpact / requestedAmountUSD) * 100).toFixed(2))
+        : undefined;
+    const highMarketPriceImpact = marketImpactPercentage ? marketImpactPercentage < -5 : false;
+    const criticalMarketPriceImpact = marketImpactPercentage ? marketImpactPercentage < -10 : false;
+    const minReceiveAmountUSD = quote?.min_receive_amount && destinationTokenPriceUsd != null
+        ? Number(quote.min_receive_amount * destinationTokenPriceUsd).toFixed(2)
+        : undefined;
+    return {
+        receiveAmountUSD,
+        requestedAmountUSD,
+        priceImpact,
+        layerswapFees,
+        bridgeExpenses,
+        marketImpact,
+        priceImpactPercentage,
+        marketImpactPercentage,
+        highMarketPriceImpact,
+        criticalMarketPriceImpact,
+        minReceiveAmountUSD,
+    };
+};

package/dist/esm/lib/resolvers/resolverService.js

@@ -2,18 +2,21 @@ import { BalanceResolver } from "../../lib/balances/balanceResolver";
 import { GasResolver } from "../../lib/gases/gasResolver";
 import { AddressUtilsResolver } from '../../lib/address/addressUtilsResolver';
 import { NftBalanceResolver } from "../nft/nftBalanceResolver";
+import { TransferResolver } from "../transfers/transferResolver";
 class UtilsResolverService {
     constructor() {
         this.balanceResolver = null;
         this.gasResolver = null;
         this.addressUtilsResolver = null;
         this.nftResolver = null;
+        this.transferResolver = null;
     }
-    setProviders(balanceProviders, gasProviders, addressUtilsProviders, nftProviders) {
+    setProviders(balanceProviders, gasProviders, addressUtilsProviders, nftProviders, transferProviders) {
         this.balanceResolver = new BalanceResolver(balanceProviders);
         this.gasResolver = new GasResolver(gasProviders);
         this.addressUtilsResolver = new AddressUtilsResolver(addressUtilsProviders);
         this.nftResolver = new NftBalanceResolver(nftProviders);
+        this.transferResolver = new TransferResolver(transferProviders);
     }
     getBalanceResolver() {
         if (!this.balanceResolver) {
@@ -39,5 +42,11 @@ class UtilsResolverService {
         }
         return this.nftResolver;
     }
+    getTransferResolver() {
+        if (!this.transferResolver) {
+            throw new Error('TransferResolver not initialized. Make sure to call setProviders first.');
+        }
+        return this.transferResolver;
+    }
 }
 export const resolverService = new UtilsResolverService();

package/dist/esm/lib/transfers/index.js

@@ -0,0 +1 @@
+export { TransferResolver } from './transferResolver';

package/dist/esm/lib/transfers/transferResolver.js

@@ -0,0 +1,14 @@
+export class TransferResolver {
+    constructor(providers) {
+        this.providers = providers || [];
+    }
+    async executeTransfer(params, wallet) {
+        const provider = this.providers.find(p => p.supportsNetwork(params.network));
+        if (!provider) {
+            const error = `No transfer provider found for network: ${params.network.name}`;
+            console.warn(error);
+            throw error;
+        }
+        return provider.executeTransfer(params, wallet);
+    }
+}

package/dist/esm/stores/balanceStore.js

@@ -113,7 +113,6 @@ export const useBalanceStore = create()(subscribeWithSelector((set, get, api) =>
                     });
                     set({ balanceKeysForSorting: partial });
                     set({ partialPublished: true });
-                    set({ sortingDataIsLoading: false });
                 }
             }
         }, { fireImmediately: true });

package/dist/esm/stores/logStore.js

@@ -0,0 +1,11 @@
+import { createStore } from 'zustand';
+const defaultHandler = (error) => {
+    console.log('[layerswap:log]', error);
+};
+const createLogStore = () => {
+    return createStore()((set) => ({
+        logger: defaultHandler,
+        setLogger: (handler) => set({ logger: handler })
+    }));
+};
+export const logStore = createLogStore();