@layerswap/widget 1.1.0 → 1.1.1

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

@@ -40,7 +40,14 @@ class LayerSwapApiClient {
                 return Promise.resolve(new EmptyApiResponse());
             }
             else {
-                const error = reason;
+                let error;
+                if (reason instanceof Error) {
+                    error = reason;
+                }
+                else {
+                    error = new Error(String(reason));
+                    error.name = "APIError";
+                }
                 ErrorHandler({
                     type: 'APIError',
                     message: error.message,

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

@@ -1,4 +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 || [];
@@ -13,16 +33,46 @@ 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 = e;
+            const errorDetails = extractErrorDetails(e);
+            const error = new Error(errorDetails.message);
+            error.name = "BalanceError";
+            error.cause = e;
             ErrorHandler({
                 type: 'BalanceResolverError',
                 message: error.message,
                 name: error.name,
                 stack: error.stack,
-                cause: error
+                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,7 +1,7 @@
 export function CalculateMinimalAuthorizeAmount(usd_price, amount) {
     return Math.ceil((usd_price * amount) + (usd_price * amount * 0.02));
 }
-export const resolvePriceImpactValues = (quote) => {
+export const resolvePriceImpactValues = (quote, refuel) => {
     const receiveAmount = quote?.receive_amount;
     const requestedAmount = quote?.requested_amount;
     const sourceTokenPriceUsd = quote?.source_token?.price_in_usd;
@@ -24,7 +24,7 @@ export const resolvePriceImpactValues = (quote) => {
         ? bridgeFee * sourceTokenPriceUsd
         : undefined;
     const marketImpact = priceImpact !== undefined && layerswapFees !== undefined && bridgeExpenses !== undefined
-        ? priceImpact + Number(layerswapFees) + Number(bridgeExpenses)
+        ? 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))

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

@@ -3,6 +3,7 @@ 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;
@@ -10,13 +11,15 @@ class UtilsResolverService {
         this.addressUtilsResolver = null;
         this.nftResolver = null;
         this.transferResolver = null;
+        this.contractAddressResolver = null;
     }
-    setProviders(balanceProviders, gasProviders, addressUtilsProviders, nftProviders, transferProviders) {
+    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) {
@@ -48,5 +51,11 @@ class UtilsResolverService {
         }
         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/stores/balanceStore.js

@@ -24,6 +24,19 @@ export const useBalanceStore = create()(subscribeWithSelector((set, get, api) =>
     sortingDataIsLoading: false,
     partialPublished: false,
     startTimeOfInit: undefined,
+    sortingTimerId: undefined,
+    sortingUnsubscribe: undefined,
+    cleanupSortingBalances: () => {
+        const { sortingTimerId, sortingUnsubscribe } = get();
+        if (sortingTimerId) {
+            clearTimeout(sortingTimerId);
+            set({ sortingTimerId: undefined });
+        }
+        if (sortingUnsubscribe) {
+            sortingUnsubscribe();
+            set({ sortingUnsubscribe: undefined });
+        }
+    },
     fetchBalance: (address, network, options) => {
         const key = getKey(address, network);
         const entry = get().balances[key];
@@ -80,6 +93,8 @@ export const useBalanceStore = create()(subscribeWithSelector((set, get, api) =>
         return queuedPromise;
     },
     initSortingBalances: pairs => {
+        get().cleanupSortingBalances();
+        // Setup initiated balances and start fetches
         const initiatedBalances = pairs.reduce((acc, { address, network }) => {
             const key = getKey(address, network);
             acc[network.name] = key;
@@ -93,29 +108,36 @@ export const useBalanceStore = create()(subscribeWithSelector((set, get, api) =>
         set({ initiatedBalances });
         set({ startTimeOfInit: Date.now() });
         set({ partialPublished: false });
-        api.subscribe(state => state.balances, balances => {
+        // Active timer - fires at 3 seconds
+        const timerId = setTimeout(() => {
+            const state = get();
+            // Only publish if not already published and still loading
+            if (!state.partialPublished && state.sortingDataIsLoading) {
+                const partial = {};
+                const balances = state.balances;
+                Object.entries(state.initiatedBalances || {}).forEach(([networkName, key]) => {
+                    if (balances[key]?.data) {
+                        partial[networkName] = key;
+                    }
+                });
+                set({ balanceKeysForSorting: partial });
+                set({ partialPublished: true });
+            }
+        }, 3000);
+        set({ sortingTimerId: timerId });
+        //Subscribe for completion detection
+        const unsubscribe = api.subscribe(state => state.balances, balances => {
             const keysArray = Object.entries(get().initiatedBalances || {});
-            const done = keysArray.every(([_, key]) => balances[key].data);
+            const done = keysArray.every(([_, key]) => balances[key]?.data);
             if (done) {
+                // All complete - cleanup and finalize
+                get().cleanupSortingBalances();
                 set({ sortingDataIsLoading: false });
                 set({ balanceKeysForSorting: get().initiatedBalances });
-                set({ partialPublished: false });
-            }
-            else {
-                const startedAt = get().startTimeOfInit ?? 0;
-                const elapsed = Date.now() - startedAt;
-                if (!get().partialPublished && elapsed >= 3000) {
-                    const partial = {};
-                    keysArray.forEach(([networkName, key]) => {
-                        if (balances[key]?.data) {
-                            partial[networkName] = key;
-                        }
-                    });
-                    set({ balanceKeysForSorting: partial });
-                    set({ partialPublished: true });
-                }
+                set({ partialPublished: false }); // Reset for next time
             }
         }, { fireImmediately: true });
+        set({ sortingUnsubscribe: unsubscribe });
     }
 })));
 export const selectResolvedSortingBalances = (state) => {

package/dist/esm/stores/contractAddressStore.js

@@ -0,0 +1,178 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+import { resolverService } from '../lib/resolvers/resolverService';
+const isContractAddress = async (address, network) => {
+    if (!network || !address) {
+        return false;
+    }
+    try {
+        const resolver = resolverService.getContractAddressResolver();
+        return await resolver.isContractAddress(network, address);
+    }
+    catch (error) {
+        console.log(error);
+        return false;
+    }
+};
+export const useContractAddressStore = create()(persist((set, get) => ({
+    contractStatuses: [],
+    confirmedAddresses: [],
+    isChecking: false,
+    pendingChecks: new Map(),
+    checkContractStatus: async (address, sourceNetwork, destinationNetwork) => {
+        if (!address || !sourceNetwork || !destinationNetwork) {
+            return { sourceIsContract: false, destinationIsContract: false, isContractInAnyNetwork: false };
+        }
+        const { hasStatus, isContractInNetwork, isContractInAnyNetwork } = get();
+        // Check if we already have cached results for both networks
+        const hasSourceStatus = hasStatus(address, sourceNetwork.name);
+        const hasDestStatus = hasStatus(address, destinationNetwork.name);
+        if (hasSourceStatus && hasDestStatus) {
+            return {
+                sourceIsContract: isContractInNetwork(address, sourceNetwork.name),
+                destinationIsContract: isContractInNetwork(address, destinationNetwork.name),
+                isContractInAnyNetwork: isContractInAnyNetwork(address)
+            };
+        }
+        const checkKey = `${address.toLowerCase()}-${sourceNetwork.name}-${destinationNetwork.name}`;
+        // If there's already a pending check for these params, return that promise
+        const pendingCheck = get().pendingChecks.get(checkKey);
+        if (pendingCheck) {
+            return pendingCheck;
+        }
+        set({ isChecking: true });
+        const checkPromise = (async () => {
+            try {
+                // Check source network only if not already cached
+                let sourceIsContract = false;
+                if (hasSourceStatus) {
+                    sourceIsContract = isContractInNetwork(address, sourceNetwork.name);
+                }
+                else {
+                    sourceIsContract = await isContractAddress(address, sourceNetwork);
+                    set((state) => {
+                        const existingIndex = state.contractStatuses.findIndex((cs) => cs.address.toLowerCase() === address.toLowerCase() &&
+                            cs.network === sourceNetwork.name);
+                        if (existingIndex >= 0) {
+                            const updated = [...state.contractStatuses];
+                            updated[existingIndex] = { address, network: sourceNetwork.name, isContract: sourceIsContract };
+                            return { contractStatuses: updated };
+                        }
+                        return {
+                            contractStatuses: [...state.contractStatuses, { address, network: sourceNetwork.name, isContract: sourceIsContract }]
+                        };
+                    });
+                }
+                // Check destination network only if not already cached
+                let destinationIsContract = false;
+                if (hasDestStatus) {
+                    destinationIsContract = isContractInNetwork(address, destinationNetwork.name);
+                }
+                else {
+                    destinationIsContract = await isContractAddress(address, destinationNetwork);
+                    set((state) => {
+                        const existingIndex = state.contractStatuses.findIndex((cs) => cs.address.toLowerCase() === address.toLowerCase() &&
+                            cs.network === destinationNetwork.name);
+                        if (existingIndex >= 0) {
+                            const updated = [...state.contractStatuses];
+                            updated[existingIndex] = { address, network: destinationNetwork.name, isContract: destinationIsContract };
+                            return { contractStatuses: updated };
+                        }
+                        return {
+                            contractStatuses: [...state.contractStatuses, { address, network: destinationNetwork.name, isContract: destinationIsContract }]
+                        };
+                    });
+                }
+                // Check if contract in any network after updates
+                const isInAnyNetwork = get().isContractInAnyNetwork(address);
+                return { sourceIsContract, destinationIsContract, isContractInAnyNetwork: isInAnyNetwork };
+            }
+            catch (error) {
+                console.error('Error checking contract status:', error);
+                return { sourceIsContract: false, destinationIsContract: false, isContractInAnyNetwork: false };
+            }
+            finally {
+                set((state) => {
+                    const newPendingChecks = new Map(state.pendingChecks);
+                    newPendingChecks.delete(checkKey);
+                    return { pendingChecks: newPendingChecks, isChecking: false };
+                });
+            }
+        })();
+        set((state) => {
+            const newPendingChecks = new Map(state.pendingChecks);
+            newPendingChecks.set(checkKey, checkPromise);
+            return { pendingChecks: newPendingChecks };
+        });
+        return checkPromise;
+    },
+    hasStatus: (address, network) => {
+        return get().contractStatuses.some((cs) => cs.address.toLowerCase() === address.toLowerCase() &&
+            cs.network === network);
+    },
+    isContractInNetwork: (address, network) => {
+        const status = get().contractStatuses.find((cs) => cs.address.toLowerCase() === address.toLowerCase() &&
+            cs.network === network);
+        return status?.isContract ?? false;
+    },
+    isContractInAnyNetwork: (address) => {
+        return get().contractStatuses.some((cs) => cs.address.toLowerCase() === address.toLowerCase() &&
+            cs.isContract === true);
+    },
+    getContractNetworks: (address) => {
+        return get().contractStatuses
+            .filter((cs) => cs.address.toLowerCase() === address.toLowerCase() &&
+            cs.isContract === true)
+            .map((cs) => cs.network);
+    },
+    clearContractStatus: (address, network) => set((state) => {
+        if (network) {
+            return {
+                contractStatuses: state.contractStatuses.filter((cs) => !(cs.address.toLowerCase() === address.toLowerCase() &&
+                    cs.network === network))
+            };
+        }
+        else {
+            return {
+                contractStatuses: state.contractStatuses.filter((cs) => cs.address.toLowerCase() !== address.toLowerCase())
+            };
+        }
+    }),
+    setConfirmed: (address, network) => set((state) => {
+        const exists = state.confirmedAddresses.some((ca) => ca.address.toLowerCase() === address.toLowerCase() &&
+            ca.network === network);
+        if (exists) {
+            return state;
+        }
+        return {
+            confirmedAddresses: [
+                ...state.confirmedAddresses,
+                { address, network }
+            ]
+        };
+    }),
+    isConfirmed: (address, network) => {
+        return get().confirmedAddresses.some((ca) => ca.address.toLowerCase() === address.toLowerCase() &&
+            ca.network === network);
+    },
+    clearConfirmed: (address, network) => set((state) => {
+        if (network) {
+            return {
+                confirmedAddresses: state.confirmedAddresses.filter((ca) => !(ca.address.toLowerCase() === address.toLowerCase() &&
+                    ca.network === network))
+            };
+        }
+        else {
+            return {
+                confirmedAddresses: state.confirmedAddresses.filter((ca) => ca.address.toLowerCase() !== address.toLowerCase())
+            };
+        }
+    }),
+}), {
+    name: 'contractAddress',
+    storage: createJSONStorage(() => localStorage),
+    partialize: (state) => ({
+        contractStatuses: state.contractStatuses,
+        confirmedAddresses: state.confirmedAddresses,
+    }),
+}));

package/dist/esm/types/balance.js

@@ -1,8 +1,9 @@
 import { ErrorHandler } from "../lib/ErrorHandler";
+import { extractErrorDetails } from "../lib/balances/errorUtils";
+import { classifyNodeError } from "../lib/balances/nodeErrorClassifier";
 export class BalanceProvider {
     constructor() {
         this.resolveTokenBalanceFetchError = (err, token, network, isNativeCurrency) => {
-            const errorMessage = `${err.message || err}`;
             ErrorHandler({
                 type: 'BalanceProviderError',
                 message: err.message,
@@ -10,6 +11,8 @@ export class BalanceProvider {
                 stack: err.stack,
                 cause: err
             });
+            const errorDetails = extractErrorDetails(err);
+            const category = classifyNodeError(err);
             const tokenBalance = {
                 network: network.name,
                 token: token.symbol,
@@ -17,7 +20,17 @@ export class BalanceProvider {
                 request_time: new Date().toJSON(),
                 decimals: Number(token?.decimals),
                 isNativeCurrency: isNativeCurrency ?? !token.contract,
-                error: errorMessage
+                error: {
+                    message: errorDetails.message,
+                    name: errorDetails.name,
+                    stack: errorDetails.stack,
+                    code: errorDetails.code,
+                    status: errorDetails.status,
+                    statusText: errorDetails.statusText,
+                    responseData: errorDetails.responseData,
+                    requestUrl: errorDetails.requestUrl,
+                    category: category
+                }
             };
             return tokenBalance;
         };

package/dist/esm/types/contract.js

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

package/dist/esm/types/index.js

@@ -3,6 +3,7 @@ export * from './logEvents';
 export * from './balance';
 export * from './gas';
 export * from './addressUtils';
+export * from './contract';
 export * from './transfer';
 export * from './nft';
 export * from './multiStepTransfer';