@layerswap/widget 1.0.6 → 1.1.1

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,30 +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({ sortingDataIsLoading: false });
-                }
+                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/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();

package/dist/esm/types/balance.js

@@ -1,16 +1,18 @@
+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}`;
-            // posthog.captureException("balance_fetch_error", {
-            //     where: "BalanceProvider",
-            //     network: network.name,
-            //     $layerswap_exception_type: "Balance Fetch Error",
-            //     token: token.symbol ?? undefined,
-            //     message: `Could not fetch balance for ${token.symbol} in ${network.name}, err: ${errorMessage}`,
-            //     cause: err.cause,
-            //     timoutError: errorMessage.toLowerCase().includes("timeout") || errorMessage.toLowerCase().includes("took too long")
-            // });
+            ErrorHandler({
+                type: 'BalanceProviderError',
+                message: err.message,
+                name: err.name,
+                stack: err.stack,
+                cause: err
+            });
+            const errorDetails = extractErrorDetails(err);
+            const category = classifyNodeError(err);
             const tokenBalance = {
                 network: network.name,
                 token: token.symbol,
@@ -18,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

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

package/dist/esm/types/logEvents.js

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