npm - tiwiflix-wallet-connector - Versions diffs - 1.5.5 → 1.5.7 - Mend

tiwiflix-wallet-connector 1.5.5 → 1.5.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.esm.js CHANGED Viewed

@@ -7530,7 +7530,7 @@ const defaultStyles = {
         fontFamily: 'Lexend, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
         boxShadow: '0 4px 14px 0 rgba(51, 150, 255, 0.39)',
     }};
-const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className, style, showBalance = false, modalPosition = 'center', theme = 'auto', buttonText = 'Connect Wallet', fetchTransactions, getExplorerUrl, fetchBalance: fetchBalanceProp, }) => {
+const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className, style, showBalance = false, modalPosition = 'center', theme = 'auto', buttonText = 'Connect Wallet Now', fetchTransactions, getExplorerUrl, fetchBalance: fetchBalanceProp, }) => {
     // Provide a default fetchBalance if not passed
     const fetchBalance = fetchBalanceProp || (async (account) => {
         // Default: return zero balance with symbol based on chain
@@ -7662,12 +7662,15 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
     });
     // Stable USD value updater - only updates if value changes significantly
     const setUsdValueStable = useCallback((newValue) => {
-        // Set USD value immediately - only skip if value is the same
         setUsdValue((prevValue) => {
             // If new value is null/undefined and we have a previous value, keep it
             if ((newValue === null || newValue === undefined) && prevValue !== null) {
                 return prevValue;
             }
+            // Only update if value actually changed
+            if (prevValue === newValue) {
+                return prevValue;
+            }
             // Otherwise set the new value
             return newValue;
         });
@@ -7832,6 +7835,18 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
         });
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [account?.address, fetchTransactions, cacheTimeout]);
+    // Fallback guard to avoid getting stuck in a loading state (e.g., after page refresh)
+    useEffect(() => {
+        // Only run when we are actually in a loading state
+        if (!isInitializing && !balanceLoading && !isConnecting)
+            return;
+        const timeout = setTimeout(() => {
+            setIsInitializing(false);
+            setBalanceLoading(false);
+            setIsConnecting(false);
+        }, 4000); // force-resolve after 4s
+        return () => clearTimeout(timeout);
+    }, [isInitializing, balanceLoading, isConnecting]);
     // Check chain ID and validate network
     useEffect(() => {
         const checkChain = async () => {
@@ -7881,9 +7896,29 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
     const walletsRef = useRef(null);
     // Initialize and subscribe to events
     useEffect(() => {
+        let isMounted = true;
         // Get initial state
         const initialState = connector.getState();
         setStatus(initialState.status);
+        // Immediate hydration from cached state/localStorage to avoid loading flashes on page changes
+        if (initialState.account) {
+            setAccount(initialState.account);
+            // Prefer fresh TWC state, otherwise restore from localStorage cache
+            if (initialState.twcBalance && initialState.twcBalance !== '0' && initialState.twcBalance !== '0.00') {
+                setTwcBalance(initialState.twcBalance);
+                setUsdValueStable(initialState.usdValue ?? null);
+            }
+            else {
+                const cached = loadTWCBalanceFromCache(initialState.account.address);
+                if (cached?.balance) {
+                    setTwcBalance(cached.balance);
+                    setUsdValueStable(cached.usdValue);
+                }
+            }
+            // Since we have hydrated from cache, avoid showing the loading state
+            setIsInitializing(false);
+            setBalanceLoading(false);
+        }
         // Safety: Clear isConnecting on mount (in case it was stuck from previous session)
         setIsConnecting(false);
         // Only set wallets once to prevent re-renders
@@ -7902,6 +7937,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                 setBalanceLoading(false);
             }, 2000);
             connector.getAccount().then(async (acc) => {
+                if (!isMounted)
+                    return;
                 setAccount(acc);
                 // Load balance when account is available
                 if (acc && acc.chainType === 'ton') {
@@ -7912,10 +7949,14 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                             fetchTONBalance(acc),
                             fetchTONNFTs(acc)
                         ]);
+                        if (!isMounted)
+                            return;
                         clearTimeout(safetyTimeout);
                         setIsInitializing(false);
                     }
                     catch (err) {
+                        if (!isMounted)
+                            return;
                         clearTimeout(safetyTimeout);
                         setIsInitializing(false);
                     }
@@ -7924,6 +7965,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     try {
                         setBalanceLoading(true);
                         const hasRealBalance = await loadBalance();
+                        if (!isMounted)
+                            return;
                         // Always stop loading state after balance fetch
                         setBalanceLoading(false);
                         clearTimeout(safetyTimeout);
@@ -7931,6 +7974,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         setIsInitializing(false);
                     }
                     catch (err) {
+                        if (!isMounted)
+                            return;
                         setBalanceLoading(false);
                         clearTimeout(safetyTimeout);
                         // Always stop initializing on error
@@ -7942,6 +7987,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     const state = connector.getState();
                     const stateTwcBalance = state.twcBalance;
                     if (acc && stateTwcBalance && stateTwcBalance !== '0' && stateTwcBalance !== '0.00') {
+                        if (!isMounted)
+                            return;
                         setTwcBalance(stateTwcBalance);
                         setUsdValueStable(state.usdValue ?? null);
                         // Save to cache
@@ -7955,6 +8002,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         // Try to load from cache as fallback
                         const cached = loadTWCBalanceFromCache(acc.address);
                         if (cached?.balance && cached.balance !== '0' && cached.balance !== '0.00') {
+                            if (!isMounted)
+                                return;
                             setTwcBalance(cached.balance);
                             setUsdValueStable(cached.usdValue);
                             clearTimeout(safetyTimeout);
@@ -7964,6 +8013,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                             // No real balance yet, but for EVM wallets, proactively fetch with retries
                             if (acc.chainType === 'evm') {
                                 fetchTWCBalanceWithRetry(2, 200).then((result) => {
+                                    if (!isMounted)
+                                        return;
                                     if (result) {
                                         setTwcBalance(result.balance);
                                         setUsdValueStable(result.usdValue);
@@ -7980,6 +8031,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                                         setIsInitializing(false);
                                     }
                                 }).catch((error) => {
+                                    if (!isMounted)
+                                        return;
                                     // On error - show connected button with 0 balance
                                     setTwcBalance('0');
                                     clearTimeout(safetyTimeout);
@@ -7995,9 +8048,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                                         fetchTONBalance(acc),
                                         fetchTONNFTs(acc)
                                     ]).then(() => {
+                                        if (!isMounted)
+                                            return;
                                         clearTimeout(safetyTimeout);
                                         setIsInitializing(false);
                                     }).catch((err) => {
+                                        if (!isMounted)
+                                            return;
                                         clearTimeout(safetyTimeout);
                                         setIsInitializing(false);
                                     });
@@ -8005,6 +8062,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                                 else if (fetchBalance) {
                                     // For other non-EVM chains: If fetchBalance is provided, load balance and then stop initializing
                                     fetchTWCBalanceWithRetry(1, 100).then((result) => {
+                                        if (!isMounted)
+                                            return;
                                         if (result) {
                                             setTwcBalance(result.balance);
                                             setUsdValueStable(result.usdValue);
@@ -8016,12 +8075,16 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                                         clearTimeout(safetyTimeout);
                                         setIsInitializing(false);
                                     }).catch(() => {
+                                        if (!isMounted)
+                                            return;
                                         // Stop initializing even on error
                                         clearTimeout(safetyTimeout);
                                         setIsInitializing(false);
                                     });
                                 }
                                 else {
+                                    if (!isMounted)
+                                        return;
                                     // No fetchBalance and no cached balance - stop initializing with 0 balance
                                     setTwcBalance('0');
                                     clearTimeout(safetyTimeout);
@@ -8032,6 +8095,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     }
                 }
             }).catch((err) => {
+                if (!isMounted)
+                    return;
                 clearTimeout(safetyTimeout);
                 setIsInitializing(false);
                 // If we can't get account even though status is connected, disconnect
@@ -8044,9 +8109,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
             setIsInitializing(true);
             // Set a shorter timeout to prevent stuck loading state
             initTimeout = setTimeout(() => {
+                if (!isMounted)
+                    return;
                 setIsInitializing(false);
                 // If still no account after timeout, ensure we show connect button
                 connector.getAccount().then((acc) => {
+                    if (!isMounted)
+                        return;
                     if (!acc) {
                         setAccount(null);
                         // If status is disconnected and no account, ensure we're fully disconnected
@@ -8058,11 +8127,15 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         }
                     }
                 }).catch((err) => {
+                    if (!isMounted)
+                        return;
                     setAccount(null);
                     setStatus(ConnectionStatus.DISCONNECTED);
                 });
             }, 1500); // Reduced to 1.5 second timeout to prevent stuck loading
             connector.getAccount().then((acc) => {
+                if (!isMounted)
+                    return;
                 if (initTimeout)
                     clearTimeout(initTimeout);
                 setAccount(acc);
@@ -8077,6 +8150,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     }
                 }
             }).catch((err) => {
+                if (!isMounted)
+                    return;
                 if (initTimeout)
                     clearTimeout(initTimeout);
                 setIsInitializing(false);
@@ -8090,6 +8165,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
         }
         // Subscribe to events
         const unsubscribeAccount = connector.on(WalletEvent.ACCOUNT_CHANGED, async (acc) => {
+            if (!isMounted)
+                return;
             setAccount(acc);
             // Clear isConnecting when account changes (connection succeeded)
             setIsConnecting(false);
@@ -8110,9 +8187,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         fetchTONBalance(acc),
                         fetchTONNFTs(acc)
                     ]);
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
                 catch (err) {
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
             }
@@ -8120,9 +8201,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                 setBalanceLoading(true);
                 try {
                     await loadBalance();
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
                 catch (err) {
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                     setBalanceLoading(false);
                 }
@@ -8245,6 +8330,7 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
             }
         });
         return () => {
+            isMounted = false;
             clearTimeout(initTimeout);
             unsubscribeAccount();
             unsubscribeStatus();
@@ -8390,16 +8476,23 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
     }, [connector]);
     // Load balance when account changes
     useEffect(() => {
+        let isActive = true;
         if (account && fetchBalance) {
             setBalanceLoading(true);
             loadBalance()
                 .then(() => {
+                if (!isActive)
+                    return;
                 // Always stop initializing once balance request completes
             })
                 .catch(() => {
+                if (!isActive)
+                    return;
                 // Ignore errors, we still clear loading states
             })
                 .finally(() => {
+                if (!isActive)
+                    return;
                 setBalanceLoading(false);
                 setIsInitializing(false);
             });
@@ -8432,6 +8525,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                 // Only fetch if we don't have a balance yet
                 if (!hasBalance) {
                     fetchTWCBalanceWithRetry(2, 200).then((result) => {
+                        if (!isActive)
+                            return;
                         if (result) {
                             setTwcBalance(result.balance);
                             setUsdValueStable(result.usdValue);
@@ -8447,6 +8542,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                             setIsInitializing(false);
                         }
                     }).catch(() => {
+                        if (!isActive)
+                            return;
                         setIsInitializing(false);
                     });
                 }
@@ -8467,22 +8564,33 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                 }
             }
         }
+        return () => {
+            isActive = false;
+        };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [account?.address, fetchBalance]);
     // Polling mechanism as fallback to ensure TWC balance is always fetched
     useEffect(() => {
-        if (!account || account.chainType !== 'evm' || isInitializing) {
+        if (!account || account.chainType !== 'evm') {
             return;
         }
-        // If we don't have a balance yet, start polling
-        const hasBalance = twcBalance && twcBalance !== '0' && twcBalance !== '0.00';
-        if (!hasBalance) {
+        // Check if we already have a balance
+        const currentBalance = twcBalance;
+        const hasBalance = currentBalance && currentBalance !== '0' && currentBalance !== '0.00';
+        if (!hasBalance && !isInitializing) {
             // Poll every 2 seconds, up to 3 times (6 seconds total) - faster polling
             let pollCount = 0;
             const maxPolls = 3;
+            let isActive = true;
             const pollInterval = setInterval(() => {
+                if (!isActive) {
+                    clearInterval(pollInterval);
+                    return;
+                }
                 pollCount++;
                 fetchTWCBalanceWithRetry(2, 200).then((result) => {
+                    if (!isActive)
+                        return;
                     if (result) {
                         setTwcBalance(result.balance);
                         setUsdValueStable(result.usdValue);
@@ -8495,17 +8603,22 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         clearInterval(pollInterval);
                     }
                 }).catch((error) => {
+                    if (!isActive)
+                        return;
                     if (pollCount >= maxPolls) {
                         clearInterval(pollInterval);
                     }
                 });
             }, 2000); // Poll every 2 seconds (faster)
             return () => {
+                isActive = false;
                 clearInterval(pollInterval);
             };
         }
+        return undefined;
+        // Only depend on account address - check balance inside effect
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [account?.address, twcBalance, isInitializing]);
+    }, [account?.address]);
     // Load transactions when details modal opens
     useEffect(() => {
         if (showDetailsModal && account) {

package/dist/index.js CHANGED Viewed

@@ -7532,7 +7532,7 @@ const defaultStyles = {
         fontFamily: 'Lexend, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
         boxShadow: '0 4px 14px 0 rgba(51, 150, 255, 0.39)',
     }};
-const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className, style, showBalance = false, modalPosition = 'center', theme = 'auto', buttonText = 'Connect Wallet', fetchTransactions, getExplorerUrl, fetchBalance: fetchBalanceProp, }) => {
+const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className, style, showBalance = false, modalPosition = 'center', theme = 'auto', buttonText = 'Connect Wallet Now', fetchTransactions, getExplorerUrl, fetchBalance: fetchBalanceProp, }) => {
     // Provide a default fetchBalance if not passed
     const fetchBalance = fetchBalanceProp || (async (account) => {
         // Default: return zero balance with symbol based on chain
@@ -7664,12 +7664,15 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
     });
     // Stable USD value updater - only updates if value changes significantly
     const setUsdValueStable = React.useCallback((newValue) => {
-        // Set USD value immediately - only skip if value is the same
         setUsdValue((prevValue) => {
             // If new value is null/undefined and we have a previous value, keep it
             if ((newValue === null || newValue === undefined) && prevValue !== null) {
                 return prevValue;
             }
+            // Only update if value actually changed
+            if (prevValue === newValue) {
+                return prevValue;
+            }
             // Otherwise set the new value
             return newValue;
         });
@@ -7834,6 +7837,18 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
         });
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [account?.address, fetchTransactions, cacheTimeout]);
+    // Fallback guard to avoid getting stuck in a loading state (e.g., after page refresh)
+    React.useEffect(() => {
+        // Only run when we are actually in a loading state
+        if (!isInitializing && !balanceLoading && !isConnecting)
+            return;
+        const timeout = setTimeout(() => {
+            setIsInitializing(false);
+            setBalanceLoading(false);
+            setIsConnecting(false);
+        }, 4000); // force-resolve after 4s
+        return () => clearTimeout(timeout);
+    }, [isInitializing, balanceLoading, isConnecting]);
     // Check chain ID and validate network
     React.useEffect(() => {
         const checkChain = async () => {
@@ -7883,9 +7898,29 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
     const walletsRef = React.useRef(null);
     // Initialize and subscribe to events
     React.useEffect(() => {
+        let isMounted = true;
         // Get initial state
         const initialState = connector.getState();
         setStatus(initialState.status);
+        // Immediate hydration from cached state/localStorage to avoid loading flashes on page changes
+        if (initialState.account) {
+            setAccount(initialState.account);
+            // Prefer fresh TWC state, otherwise restore from localStorage cache
+            if (initialState.twcBalance && initialState.twcBalance !== '0' && initialState.twcBalance !== '0.00') {
+                setTwcBalance(initialState.twcBalance);
+                setUsdValueStable(initialState.usdValue ?? null);
+            }
+            else {
+                const cached = loadTWCBalanceFromCache(initialState.account.address);
+                if (cached?.balance) {
+                    setTwcBalance(cached.balance);
+                    setUsdValueStable(cached.usdValue);
+                }
+            }
+            // Since we have hydrated from cache, avoid showing the loading state
+            setIsInitializing(false);
+            setBalanceLoading(false);
+        }
         // Safety: Clear isConnecting on mount (in case it was stuck from previous session)
         setIsConnecting(false);
         // Only set wallets once to prevent re-renders
@@ -7904,6 +7939,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                 setBalanceLoading(false);
             }, 2000);
             connector.getAccount().then(async (acc) => {
+                if (!isMounted)
+                    return;
                 setAccount(acc);
                 // Load balance when account is available
                 if (acc && acc.chainType === 'ton') {
@@ -7914,10 +7951,14 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                             fetchTONBalance(acc),
                             fetchTONNFTs(acc)
                         ]);
+                        if (!isMounted)
+                            return;
                         clearTimeout(safetyTimeout);
                         setIsInitializing(false);
                     }
                     catch (err) {
+                        if (!isMounted)
+                            return;
                         clearTimeout(safetyTimeout);
                         setIsInitializing(false);
                     }
@@ -7926,6 +7967,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     try {
                         setBalanceLoading(true);
                         const hasRealBalance = await loadBalance();
+                        if (!isMounted)
+                            return;
                         // Always stop loading state after balance fetch
                         setBalanceLoading(false);
                         clearTimeout(safetyTimeout);
@@ -7933,6 +7976,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         setIsInitializing(false);
                     }
                     catch (err) {
+                        if (!isMounted)
+                            return;
                         setBalanceLoading(false);
                         clearTimeout(safetyTimeout);
                         // Always stop initializing on error
@@ -7944,6 +7989,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     const state = connector.getState();
                     const stateTwcBalance = state.twcBalance;
                     if (acc && stateTwcBalance && stateTwcBalance !== '0' && stateTwcBalance !== '0.00') {
+                        if (!isMounted)
+                            return;
                         setTwcBalance(stateTwcBalance);
                         setUsdValueStable(state.usdValue ?? null);
                         // Save to cache
@@ -7957,6 +8004,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         // Try to load from cache as fallback
                         const cached = loadTWCBalanceFromCache(acc.address);
                         if (cached?.balance && cached.balance !== '0' && cached.balance !== '0.00') {
+                            if (!isMounted)
+                                return;
                             setTwcBalance(cached.balance);
                             setUsdValueStable(cached.usdValue);
                             clearTimeout(safetyTimeout);
@@ -7966,6 +8015,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                             // No real balance yet, but for EVM wallets, proactively fetch with retries
                             if (acc.chainType === 'evm') {
                                 fetchTWCBalanceWithRetry(2, 200).then((result) => {
+                                    if (!isMounted)
+                                        return;
                                     if (result) {
                                         setTwcBalance(result.balance);
                                         setUsdValueStable(result.usdValue);
@@ -7982,6 +8033,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                                         setIsInitializing(false);
                                     }
                                 }).catch((error) => {
+                                    if (!isMounted)
+                                        return;
                                     // On error - show connected button with 0 balance
                                     setTwcBalance('0');
                                     clearTimeout(safetyTimeout);
@@ -7997,9 +8050,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                                         fetchTONBalance(acc),
                                         fetchTONNFTs(acc)
                                     ]).then(() => {
+                                        if (!isMounted)
+                                            return;
                                         clearTimeout(safetyTimeout);
                                         setIsInitializing(false);
                                     }).catch((err) => {
+                                        if (!isMounted)
+                                            return;
                                         clearTimeout(safetyTimeout);
                                         setIsInitializing(false);
                                     });
@@ -8007,6 +8064,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                                 else if (fetchBalance) {
                                     // For other non-EVM chains: If fetchBalance is provided, load balance and then stop initializing
                                     fetchTWCBalanceWithRetry(1, 100).then((result) => {
+                                        if (!isMounted)
+                                            return;
                                         if (result) {
                                             setTwcBalance(result.balance);
                                             setUsdValueStable(result.usdValue);
@@ -8018,12 +8077,16 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                                         clearTimeout(safetyTimeout);
                                         setIsInitializing(false);
                                     }).catch(() => {
+                                        if (!isMounted)
+                                            return;
                                         // Stop initializing even on error
                                         clearTimeout(safetyTimeout);
                                         setIsInitializing(false);
                                     });
                                 }
                                 else {
+                                    if (!isMounted)
+                                        return;
                                     // No fetchBalance and no cached balance - stop initializing with 0 balance
                                     setTwcBalance('0');
                                     clearTimeout(safetyTimeout);
@@ -8034,6 +8097,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     }
                 }
             }).catch((err) => {
+                if (!isMounted)
+                    return;
                 clearTimeout(safetyTimeout);
                 setIsInitializing(false);
                 // If we can't get account even though status is connected, disconnect
@@ -8046,9 +8111,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
             setIsInitializing(true);
             // Set a shorter timeout to prevent stuck loading state
             initTimeout = setTimeout(() => {
+                if (!isMounted)
+                    return;
                 setIsInitializing(false);
                 // If still no account after timeout, ensure we show connect button
                 connector.getAccount().then((acc) => {
+                    if (!isMounted)
+                        return;
                     if (!acc) {
                         setAccount(null);
                         // If status is disconnected and no account, ensure we're fully disconnected
@@ -8060,11 +8129,15 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         }
                     }
                 }).catch((err) => {
+                    if (!isMounted)
+                        return;
                     setAccount(null);
                     setStatus(exports.ConnectionStatus.DISCONNECTED);
                 });
             }, 1500); // Reduced to 1.5 second timeout to prevent stuck loading
             connector.getAccount().then((acc) => {
+                if (!isMounted)
+                    return;
                 if (initTimeout)
                     clearTimeout(initTimeout);
                 setAccount(acc);
@@ -8079,6 +8152,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     }
                 }
             }).catch((err) => {
+                if (!isMounted)
+                    return;
                 if (initTimeout)
                     clearTimeout(initTimeout);
                 setIsInitializing(false);
@@ -8092,6 +8167,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
         }
         // Subscribe to events
         const unsubscribeAccount = connector.on(exports.WalletEvent.ACCOUNT_CHANGED, async (acc) => {
+            if (!isMounted)
+                return;
             setAccount(acc);
             // Clear isConnecting when account changes (connection succeeded)
             setIsConnecting(false);
@@ -8112,9 +8189,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         fetchTONBalance(acc),
                         fetchTONNFTs(acc)
                     ]);
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
                 catch (err) {
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
             }
@@ -8122,9 +8203,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                 setBalanceLoading(true);
                 try {
                     await loadBalance();
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
                 catch (err) {
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                     setBalanceLoading(false);
                 }
@@ -8247,6 +8332,7 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
             }
         });
         return () => {
+            isMounted = false;
             clearTimeout(initTimeout);
             unsubscribeAccount();
             unsubscribeStatus();
@@ -8392,16 +8478,23 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
     }, [connector]);
     // Load balance when account changes
     React.useEffect(() => {
+        let isActive = true;
         if (account && fetchBalance) {
             setBalanceLoading(true);
             loadBalance()
                 .then(() => {
+                if (!isActive)
+                    return;
                 // Always stop initializing once balance request completes
             })
                 .catch(() => {
+                if (!isActive)
+                    return;
                 // Ignore errors, we still clear loading states
             })
                 .finally(() => {
+                if (!isActive)
+                    return;
                 setBalanceLoading(false);
                 setIsInitializing(false);
             });
@@ -8434,6 +8527,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                 // Only fetch if we don't have a balance yet
                 if (!hasBalance) {
                     fetchTWCBalanceWithRetry(2, 200).then((result) => {
+                        if (!isActive)
+                            return;
                         if (result) {
                             setTwcBalance(result.balance);
                             setUsdValueStable(result.usdValue);
@@ -8449,6 +8544,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                             setIsInitializing(false);
                         }
                     }).catch(() => {
+                        if (!isActive)
+                            return;
                         setIsInitializing(false);
                     });
                 }
@@ -8469,22 +8566,33 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                 }
             }
         }
+        return () => {
+            isActive = false;
+        };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [account?.address, fetchBalance]);
     // Polling mechanism as fallback to ensure TWC balance is always fetched
     React.useEffect(() => {
-        if (!account || account.chainType !== 'evm' || isInitializing) {
+        if (!account || account.chainType !== 'evm') {
             return;
         }
-        // If we don't have a balance yet, start polling
-        const hasBalance = twcBalance && twcBalance !== '0' && twcBalance !== '0.00';
-        if (!hasBalance) {
+        // Check if we already have a balance
+        const currentBalance = twcBalance;
+        const hasBalance = currentBalance && currentBalance !== '0' && currentBalance !== '0.00';
+        if (!hasBalance && !isInitializing) {
             // Poll every 2 seconds, up to 3 times (6 seconds total) - faster polling
             let pollCount = 0;
             const maxPolls = 3;
+            let isActive = true;
             const pollInterval = setInterval(() => {
+                if (!isActive) {
+                    clearInterval(pollInterval);
+                    return;
+                }
                 pollCount++;
                 fetchTWCBalanceWithRetry(2, 200).then((result) => {
+                    if (!isActive)
+                        return;
                     if (result) {
                         setTwcBalance(result.balance);
                         setUsdValueStable(result.usdValue);
@@ -8497,17 +8605,22 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         clearInterval(pollInterval);
                     }
                 }).catch((error) => {
+                    if (!isActive)
+                        return;
                     if (pollCount >= maxPolls) {
                         clearInterval(pollInterval);
                     }
                 });
             }, 2000); // Poll every 2 seconds (faster)
             return () => {
+                isActive = false;
                 clearInterval(pollInterval);
             };
         }
+        return undefined;
+        // Only depend on account address - check balance inside effect
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [account?.address, twcBalance, isInitializing]);
+    }, [account?.address]);
     // Load transactions when details modal opens
     React.useEffect(() => {
         if (showDetailsModal && account) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "tiwiflix-wallet-connector",
-  "version": "1.5.5",
+  "version": "1.5.7",
   "description": "Multi-chain wallet connector for Tiwiflix supporting EVM, TON, Solana, and Tron wallets",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",