npm - tiwiflix-wallet-connector - Versions diffs - 1.5.4 → 1.5.6 - Mend

tiwiflix-wallet-connector 1.5.4 → 1.5.6

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

@@ -2508,9 +2508,37 @@ class WalletConnector {
                                 });
                                 this.eventEmitter.emit(WalletEvent.CONNECTED, account);
                             }
+                            else {
+                                // No account found - user likely cancelled or connection failed
+                                this.debugTools.info('WALLET_CONNECTOR', 'No account found after visibility change - resetting state');
+                                clearTimeout(connectionTimeout);
+                                clearTimeout(safetyTimeout);
+                                document.removeEventListener('visibilitychange', handleVisibilityChange);
+                                this.updateState({
+                                    status: ConnectionStatus.DISCONNECTED,
+                                    wallet: null,
+                                    error: new Error('Connection cancelled or failed'),
+                                });
+                                this.eventEmitter.emit(WalletEvent.ERROR, new Error('Connection cancelled or failed'));
+                            }
                         }
                         catch (err) {
                             this.debugTools.warn('WALLET_CONNECTOR', 'Failed to check account on visibility change', err);
+                            // On error checking account, reset state after a longer delay
+                            setTimeout(() => {
+                                if (this.state.status === ConnectionStatus.CONNECTING) {
+                                    this.debugTools.info('WALLET_CONNECTOR', 'Still connecting after visibility check error - resetting state');
+                                    clearTimeout(connectionTimeout);
+                                    clearTimeout(safetyTimeout);
+                                    document.removeEventListener('visibilitychange', handleVisibilityChange);
+                                    this.updateState({
+                                        status: ConnectionStatus.DISCONNECTED,
+                                        wallet: null,
+                                        error: new Error('Connection timeout'),
+                                    });
+                                    this.eventEmitter.emit(WalletEvent.ERROR, new Error('Connection timeout'));
+                                }
+                            }, 3000); // Give it 3 more seconds
                         }
                     }
                 }, 1000);
@@ -7502,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
@@ -7634,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;
         });
@@ -7853,9 +7884,12 @@ 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);
+        // Safety: Clear isConnecting on mount (in case it was stuck from previous session)
+        setIsConnecting(false);
         // Only set wallets once to prevent re-renders
         if (!walletsRef.current) {
             walletsRef.current = connector.getAllWallets();
@@ -7872,6 +7906,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') {
@@ -7882,10 +7918,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);
                     }
@@ -7894,6 +7934,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);
@@ -7901,6 +7943,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         setIsInitializing(false);
                     }
                     catch (err) {
+                        if (!isMounted)
+                            return;
                         setBalanceLoading(false);
                         clearTimeout(safetyTimeout);
                         // Always stop initializing on error
@@ -7912,6 +7956,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
@@ -7925,6 +7971,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);
@@ -7934,6 +7982,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);
@@ -7950,6 +8000,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);
@@ -7965,9 +8017,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);
                                     });
@@ -7975,6 +8031,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);
@@ -7986,12 +8044,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);
@@ -8002,6 +8064,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
@@ -8014,9 +8078,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
@@ -8028,11 +8096,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);
@@ -8047,6 +8119,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     }
                 }
             }).catch((err) => {
+                if (!isMounted)
+                    return;
                 if (initTimeout)
                     clearTimeout(initTimeout);
                 setIsInitializing(false);
@@ -8060,7 +8134,11 @@ 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);
             // Don't set isInitializing to false yet - wait for balance to load
             // Load cached balance for new account immediately
             if (acc?.address) {
@@ -8078,9 +8156,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         fetchTONBalance(acc),
                         fetchTONNFTs(acc)
                     ]);
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
                 catch (err) {
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
             }
@@ -8088,9 +8170,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);
                 }
@@ -8125,9 +8211,14 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
         });
         const unsubscribeStatus = connector.on(WalletEvent.STATUS_CHANGED, (newStatus) => {
             setStatus(newStatus);
-            // If status changes to disconnected, stop initializing
+            // If status changes to disconnected, stop initializing and connecting
             if (newStatus === ConnectionStatus.DISCONNECTED) {
                 setIsInitializing(false);
+                setIsConnecting(false);
+            }
+            // If status changes to connected, clear connecting state
+            if (newStatus === ConnectionStatus.CONNECTED) {
+                setIsConnecting(false);
             }
         });
         const unsubscribeDisconnect = connector.on(WalletEvent.DISCONNECTED, () => {
@@ -8208,6 +8299,7 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
             }
         });
         return () => {
+            isMounted = false;
             clearTimeout(initTimeout);
             unsubscribeAccount();
             unsubscribeStatus();
@@ -8353,16 +8445,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);
             });
@@ -8395,6 +8494,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);
@@ -8410,6 +8511,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                             setIsInitializing(false);
                         }
                     }).catch(() => {
+                        if (!isActive)
+                            return;
                         setIsInitializing(false);
                     });
                 }
@@ -8430,22 +8533,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);
@@ -8458,17 +8572,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) {
@@ -8478,6 +8597,11 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
     const handleConnect = useCallback(async (walletType) => {
         setIsConnecting(true);
         setError(null);
+        // Safety timeout: ensure isConnecting is cleared after 75 seconds maximum
+        const safetyTimeout = setTimeout(() => {
+            setIsConnecting(false);
+            setIsInitializing(false);
+        }, 75000);
         // Close modal BEFORE connecting for TON wallets and WalletConnect
         // so external modals can show
         const isTonWallet = ['tonkeeper', 'tonhub', 'mytonwallet'].includes(walletType);
@@ -8491,27 +8615,20 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
             setShowSendModal(false);
         }
         try {
-            const result = await connector.connect(walletType);
-            // Set account from connection result immediately
-            if (result?.account) {
-                setAccount(result.account);
-                setIsInitializing(false);
-            }
-            else {
-                // Fallback: get account after connection
-                const newAccount = await connector.getAccount();
-                if (newAccount) {
-                    setAccount(newAccount);
-                    setIsInitializing(false);
-                }
-            }
+            // connector.connect() returns void - state updates happen via events
+            await connector.connect(walletType);
+            // Connection succeeded - state is updated via ACCOUNT_CHANGED event
+            // which also clears isConnecting
             // Close modal after connection for non-TON/walletconnect wallets
             if (!isTonWallet && !isWalletConnect) {
                 setShowModal(false);
             }
-            setIsConnecting(false);
+            // Clear safety timeout on success
+            clearTimeout(safetyTimeout);
         }
         catch (err) {
+            // Clear safety timeout on error
+            clearTimeout(safetyTimeout);
             // Always clear connection state on error
             setAccount(null);
             setStatus(ConnectionStatus.DISCONNECTED);

package/dist/index.js CHANGED Viewed

@@ -2510,9 +2510,37 @@ class WalletConnector {
                                 });
                                 this.eventEmitter.emit(exports.WalletEvent.CONNECTED, account);
                             }
+                            else {
+                                // No account found - user likely cancelled or connection failed
+                                this.debugTools.info('WALLET_CONNECTOR', 'No account found after visibility change - resetting state');
+                                clearTimeout(connectionTimeout);
+                                clearTimeout(safetyTimeout);
+                                document.removeEventListener('visibilitychange', handleVisibilityChange);
+                                this.updateState({
+                                    status: exports.ConnectionStatus.DISCONNECTED,
+                                    wallet: null,
+                                    error: new Error('Connection cancelled or failed'),
+                                });
+                                this.eventEmitter.emit(exports.WalletEvent.ERROR, new Error('Connection cancelled or failed'));
+                            }
                         }
                         catch (err) {
                             this.debugTools.warn('WALLET_CONNECTOR', 'Failed to check account on visibility change', err);
+                            // On error checking account, reset state after a longer delay
+                            setTimeout(() => {
+                                if (this.state.status === exports.ConnectionStatus.CONNECTING) {
+                                    this.debugTools.info('WALLET_CONNECTOR', 'Still connecting after visibility check error - resetting state');
+                                    clearTimeout(connectionTimeout);
+                                    clearTimeout(safetyTimeout);
+                                    document.removeEventListener('visibilitychange', handleVisibilityChange);
+                                    this.updateState({
+                                        status: exports.ConnectionStatus.DISCONNECTED,
+                                        wallet: null,
+                                        error: new Error('Connection timeout'),
+                                    });
+                                    this.eventEmitter.emit(exports.WalletEvent.ERROR, new Error('Connection timeout'));
+                                }
+                            }, 3000); // Give it 3 more seconds
                         }
                     }
                 }, 1000);
@@ -7504,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
@@ -7636,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;
         });
@@ -7855,9 +7886,12 @@ 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);
+        // Safety: Clear isConnecting on mount (in case it was stuck from previous session)
+        setIsConnecting(false);
         // Only set wallets once to prevent re-renders
         if (!walletsRef.current) {
             walletsRef.current = connector.getAllWallets();
@@ -7874,6 +7908,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') {
@@ -7884,10 +7920,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);
                     }
@@ -7896,6 +7936,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);
@@ -7903,6 +7945,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         setIsInitializing(false);
                     }
                     catch (err) {
+                        if (!isMounted)
+                            return;
                         setBalanceLoading(false);
                         clearTimeout(safetyTimeout);
                         // Always stop initializing on error
@@ -7914,6 +7958,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
@@ -7927,6 +7973,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);
@@ -7936,6 +7984,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);
@@ -7952,6 +8002,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);
@@ -7967,9 +8019,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);
                                     });
@@ -7977,6 +8033,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);
@@ -7988,12 +8046,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);
@@ -8004,6 +8066,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
@@ -8016,9 +8080,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
@@ -8030,11 +8098,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);
@@ -8049,6 +8121,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                     }
                 }
             }).catch((err) => {
+                if (!isMounted)
+                    return;
                 if (initTimeout)
                     clearTimeout(initTimeout);
                 setIsInitializing(false);
@@ -8062,7 +8136,11 @@ 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);
             // Don't set isInitializing to false yet - wait for balance to load
             // Load cached balance for new account immediately
             if (acc?.address) {
@@ -8080,9 +8158,13 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                         fetchTONBalance(acc),
                         fetchTONNFTs(acc)
                     ]);
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
                 catch (err) {
+                    if (!isMounted)
+                        return;
                     setIsInitializing(false);
                 }
             }
@@ -8090,9 +8172,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);
                 }
@@ -8127,9 +8213,14 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
         });
         const unsubscribeStatus = connector.on(exports.WalletEvent.STATUS_CHANGED, (newStatus) => {
             setStatus(newStatus);
-            // If status changes to disconnected, stop initializing
+            // If status changes to disconnected, stop initializing and connecting
             if (newStatus === exports.ConnectionStatus.DISCONNECTED) {
                 setIsInitializing(false);
+                setIsConnecting(false);
+            }
+            // If status changes to connected, clear connecting state
+            if (newStatus === exports.ConnectionStatus.CONNECTED) {
+                setIsConnecting(false);
             }
         });
         const unsubscribeDisconnect = connector.on(exports.WalletEvent.DISCONNECTED, () => {
@@ -8210,6 +8301,7 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
             }
         });
         return () => {
+            isMounted = false;
             clearTimeout(initTimeout);
             unsubscribeAccount();
             unsubscribeStatus();
@@ -8355,16 +8447,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);
             });
@@ -8397,6 +8496,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);
@@ -8412,6 +8513,8 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
                             setIsInitializing(false);
                         }
                     }).catch(() => {
+                        if (!isActive)
+                            return;
                         setIsInitializing(false);
                     });
                 }
@@ -8432,22 +8535,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);
@@ -8460,17 +8574,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) {
@@ -8480,6 +8599,11 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
     const handleConnect = React.useCallback(async (walletType) => {
         setIsConnecting(true);
         setError(null);
+        // Safety timeout: ensure isConnecting is cleared after 75 seconds maximum
+        const safetyTimeout = setTimeout(() => {
+            setIsConnecting(false);
+            setIsInitializing(false);
+        }, 75000);
         // Close modal BEFORE connecting for TON wallets and WalletConnect
         // so external modals can show
         const isTonWallet = ['tonkeeper', 'tonhub', 'mytonwallet'].includes(walletType);
@@ -8493,27 +8617,20 @@ const ConnectButton = ({ connector, onConnect, onDisconnect, onError, className,
             setShowSendModal(false);
         }
         try {
-            const result = await connector.connect(walletType);
-            // Set account from connection result immediately
-            if (result?.account) {
-                setAccount(result.account);
-                setIsInitializing(false);
-            }
-            else {
-                // Fallback: get account after connection
-                const newAccount = await connector.getAccount();
-                if (newAccount) {
-                    setAccount(newAccount);
-                    setIsInitializing(false);
-                }
-            }
+            // connector.connect() returns void - state updates happen via events
+            await connector.connect(walletType);
+            // Connection succeeded - state is updated via ACCOUNT_CHANGED event
+            // which also clears isConnecting
             // Close modal after connection for non-TON/walletconnect wallets
             if (!isTonWallet && !isWalletConnect) {
                 setShowModal(false);
             }
-            setIsConnecting(false);
+            // Clear safety timeout on success
+            clearTimeout(safetyTimeout);
         }
         catch (err) {
+            // Clear safety timeout on error
+            clearTimeout(safetyTimeout);
             // Always clear connection state on error
             setAccount(null);
             setStatus(exports.ConnectionStatus.DISCONNECTED);

package/package.json CHANGED Viewed

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