@layerswap/widget 1.0.6 → 1.1.1

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/address/contractAddressResolver.js

@@ -0,0 +1,12 @@
+export class ContractAddressResolver {
+    constructor(providers) {
+        this.providers = providers || [];
+    }
+    async isContractAddress(network, address) {
+        const provider = this.providers.find(p => p.supportsNetwork(network));
+        if (!provider) {
+            return false;
+        }
+        return provider.isContractAddress(address, network);
+    }
+}

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,21 @@ 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',
-                // });
+                let error;
+                if (reason instanceof Error) {
+                    error = reason;
+                }
+                else {
+                    error = new Error(String(reason));
+                    error.name = "APIError";
+                }
+                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,24 @@
+import { ErrorHandler } from "../../lib/ErrorHandler";
+import { classifyNodeError } from "./nodeErrorClassifier";
+import { extractErrorDetails } from "./errorUtils";
+function formatErrorBalances(errorBalances) {
+    return errorBalances.map(b => ({
+        token: b.token,
+        error_message: b.error?.message,
+        error_name: b.error?.name,
+        error_code: b.error?.code,
+        error_category: b.error?.category,
+        response_status: b.error?.status,
+        response_status_text: b.error?.statusText,
+        request_url: b.error?.requestUrl,
+        // Include first 500 chars of stack trace for debugging
+        error_stack: b.error?.stack?.substring(0, 500),
+        // Include response data if available (truncated for size)
+        response_data: b.error?.responseData
+            ? JSON.stringify(b.error.responseData).substring(0, 1000)
+            : undefined
+    }));
+}
 export class BalanceResolver {
     constructor(providers) {
         this.providers = providers || [];
@@ -12,22 +33,47 @@ export class BalanceResolver {
             if (!provider)
                 throw new Error(`No balance provider found for network ${network.name}`);
             const balances = await provider.fetchBalance(address, network, { timeoutMs: options?.timeoutMs, retryCount: options?.retryCount });
+            const errorBalances = balances?.filter(b => b.error);
+            if (errorBalances?.length) {
+                const balanceError = new Error(`Could not fetch balance for ${errorBalances.map(t => t.token).join(", ")} in ${network.name}`);
+                ErrorHandler({
+                    type: 'BalanceResolverError',
+                    name: balanceError.name,
+                    stack: balanceError.stack,
+                    cause: balanceError.cause,
+                    message: balanceError.message,
+                    network: network.name,
+                    node_url: network.node_url,
+                    address: address,
+                    error_categories: [...new Set(errorBalances.map(b => classifyNodeError(b.error)))],
+                    error_codes: [...new Set(errorBalances.map(b => b.error?.code).filter(Boolean))],
+                    http_statuses: [...new Set(errorBalances.map(b => b.error?.status).filter(Boolean))],
+                    failed_tokens: formatErrorBalances(errorBalances),
+                });
+            }
             return { balances };
         }
         catch (e) {
-            const error = new Error(e);
+            const errorDetails = extractErrorDetails(e);
+            const error = new Error(errorDetails.message);
             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',
-            // });
+            ErrorHandler({
+                type: 'BalanceResolverError',
+                message: error.message,
+                name: error.name,
+                stack: error.stack,
+                cause: error.cause,
+                network: network.name,
+                node_url: network.node_url,
+                address: address,
+                error_category: classifyNodeError(e),
+                error_code: errorDetails.code,
+                response_status: errorDetails.status,
+                response_status_text: errorDetails.statusText,
+                response_data: errorDetails.responseData,
+                request_url: errorDetails.requestUrl,
+            });
             return { balances: [] };
         }
     }

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

@@ -0,0 +1,13 @@
+export function extractErrorDetails(error) {
+    const err = error;
+    return {
+        message: err?.message || String(error),
+        name: err?.name,
+        stack: err?.stack,
+        status: err?.response?.status,
+        statusText: err?.response?.statusText,
+        responseData: err?.response?.data,
+        requestUrl: err?.request?.url,
+        code: err?.code,
+    };
+}

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

@@ -0,0 +1,22 @@
+export function classifyNodeError(error) {
+    // If it's already a structured error with category, return it
+    if (typeof error === 'object' && error !== null && 'category' in error) {
+        const category = error.category;
+        if (category) {
+            return category;
+        }
+    }
+    // Otherwise classify from message
+    const message = (error?.message || String(error)).toLowerCase();
+    if (message.includes('timeout') || message.includes('timed out'))
+        return 'timeout';
+    if (message.includes('econnrefused') || message.includes('connection refused'))
+        return 'connection_refused';
+    if (message.includes('429') || message.includes('rate limit'))
+        return 'rate_limited';
+    if (message.includes('invalid json') || message.includes('unexpected token'))
+        return 'invalid_response';
+    if (message.includes('network') || message.includes('fetch failed'))
+        return 'network_error';
+    return 'unknown';
+}

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, refuel) => {
+    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) + Number(refuel?.amount_in_usd || 0)
+        : 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/generateSwapInitialValues.js

@@ -24,11 +24,11 @@ export function generateSwapInitialValues(settings, queryParams, type) {
     let initialAddress = destination_address && initialDestination && isValidAddress(destination_address, destinationNetwork) ? destination_address : "";
     let initialSourceCurrency = filteredSourceCurrencies?.find(c => c.symbol?.toUpperCase() == fromAsset?.toUpperCase());
     if (!initialSourceCurrency && !fromAsset && sourceNetwork) {
-        initialSourceCurrency = filteredSourceCurrencies?.[0];
+        initialSourceCurrency = filteredSourceCurrencies?.sort((a, b) => a.symbol.localeCompare(b.symbol))?.find(c => c.status === "active");
     }
     let initialDestinationCurrency = filteredDestinationCurrencies?.find(c => c.symbol?.toUpperCase() == toAsset?.toUpperCase());
     if (!initialDestinationCurrency && !toAsset && destinationNetwork) {
-        initialDestinationCurrency = filteredDestinationCurrencies?.[0];
+        initialDestinationCurrency = filteredDestinationCurrencies?.sort((a, b) => a.symbol.localeCompare(b.symbol))?.find(c => c.status === "active");
     }
     //TODO this looks wrong
     let initialAmount = (lockedDestinationCurrency && amount) || (initialDestinationCurrency ? amount : '');

package/dist/esm/lib/isNewListed.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
+export const isNewListed = (date) => {
+    return new Date(date)?.getTime() >= new Date().getTime() - ONE_WEEK;
+};
+export const NewBadge = () => {
+    return (_jsx("div", { className: "text-primary-text text-xs py-0.5 px-1.5 bg-linear-90 from-primary-800 to-primary-600 rounded-md", children: "New" }));
+};

package/dist/esm/lib/knownIds.js

@@ -140,6 +140,7 @@ KnownInternalNames.Networks = (_b = class {
     _b.BitcoinTestnet = "BITCOIN_TESTNET",
     _b.HyperliquidMainnet = "HYPERLIQUID_MAINNET",
     _b.HyperliquidTestnet = "HYPERLIQUID_TESTNET",
+    _b.MonadMainnet = "MONAD_MAINNET",
     _b);
 KnownInternalNames.Currencies = (_c = class {
     },

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

@@ -2,18 +2,24 @@ 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";
+import { ContractAddressResolver } from "../../lib/address/contractAddressResolver";
 class UtilsResolverService {
     constructor() {
         this.balanceResolver = null;
         this.gasResolver = null;
         this.addressUtilsResolver = null;
         this.nftResolver = null;
+        this.transferResolver = null;
+        this.contractAddressResolver = null;
     }
-    setProviders(balanceProviders, gasProviders, addressUtilsProviders, nftProviders) {
+    setProviders(balanceProviders, gasProviders, addressUtilsProviders, nftProviders, transferProviders, contractAddressProviders) {
         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);
+        this.contractAddressResolver = new ContractAddressResolver(contractAddressProviders);
     }
     getBalanceResolver() {
         if (!this.balanceResolver) {
@@ -39,5 +45,17 @@ class UtilsResolverService {
         }
         return this.nftResolver;
     }
+    getTransferResolver() {
+        if (!this.transferResolver) {
+            throw new Error('TransferResolver not initialized. Make sure to call setProviders first.');
+        }
+        return this.transferResolver;
+    }
+    getContractAddressResolver() {
+        if (!this.contractAddressResolver) {
+            throw new Error('ContractAddressResolver not initialized. Make sure to call setProviders first.');
+        }
+        return this.contractAddressResolver;
+    }
 }
 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);
+    }
+}