@blazium/ton-connect-mobile 1.2.0 → 1.2.3

package/README.md

@@ -9,8 +9,8 @@ Production-ready TON Connect Mobile SDK for React Native and Expo. Implements th
 - ✅ **Full `@tonconnect/ui-react` Compatibility** - Drop-in replacement
 - ✅ **React Native & Expo Support** - Works with both Expo and React Native CLI
 - ✅ **Android & iOS Support** - Full deep linking support
-- ✅ **Multiple Wallet Support** - Tonkeeper, Tonhub, MyTonWallet, Telegram Wallet
-- ✅ **Beautiful Wallet Selection Modal** - Built-in wallet picker UI
+- ✅ **Multiple Wallet Support** - Tonkeeper (including Web), Tonhub, MyTonWallet, Telegram Wallet
+- ✅ **Beautiful Wallet Selection Modal** - Grid layout matching @tonconnect/ui-react design
 - ✅ **Transaction Signing** - Send transactions with wallet approval
 - ✅ **Data Signing** - Sign arbitrary data for authentication
 - ✅ **Transaction Builder Utilities** - Helper functions for building transactions
@@ -18,6 +18,10 @@ Production-ready TON Connect Mobile SDK for React Native and Expo. Implements th
 - ✅ **Enhanced Error Messages** - Clear error messages with recovery suggestions
 - ✅ **Wallet Availability Checking** - Check if wallets are available
 - ✅ **Session Persistence** - Maintains connection across app restarts
+- ✅ **Network Switching** - Switch between mainnet and testnet dynamically
+- ✅ **Event Emitters** - Listen to connect, disconnect, transaction, and error events
+- ✅ **Wallet Balance Checking** - Get wallet balance via TON Center API
+- ✅ **Transaction Status Tracking** - Track transaction status with polling
 - ✅ **TypeScript** - Full type safety
 - ✅ **Production Ready** - Battle-tested implementation
 
@@ -135,18 +139,50 @@ Pre-built button component for connecting/disconnecting wallets.
 
 #### `useTonConnectUI()`
 
-Access the TonConnectUI instance with all methods.
+Access the TonConnectUI instance with all methods and features.
 
 ```typescript
 const tonConnectUI = useTonConnectUI();
 
-// Methods:
+// Connection methods:
 await tonConnectUI.connectWallet();
 await tonConnectUI.disconnect();
+await tonConnectUI.restoreConnection(); // Restore from stored session
+
+// Transaction methods:
 await tonConnectUI.sendTransaction({ ... });
 await tonConnectUI.signData({ data: '...', version: '1.0' });
+
+// Modal methods:
 await tonConnectUI.openModal();
 tonConnectUI.closeModal();
+
+// Wallet customization:
+tonConnectUI.setWalletList([...]); // Customize available wallets
+
+// Network management:
+const network = tonConnectUI.getNetwork(); // Get current network
+tonConnectUI.setNetwork('testnet'); // Switch to testnet
+
+// Balance checking:
+const balance = await tonConnectUI.getBalance(); // Get connected wallet balance
+const balance2 = await tonConnectUI.getBalance(address); // Get specific address balance
+
+// Transaction status:
+const status = await tonConnectUI.getTransactionStatusByHash(txHash, address);
+
+// Event listeners:
+const unsubscribe = tonConnectUI.on('connect', (wallet) => {
+  console.log('Connected:', wallet);
+});
+tonConnectUI.on('disconnect', () => console.log('Disconnected'));
+tonConnectUI.on('transaction', (tx) => console.log('Transaction:', tx));
+tonConnectUI.on('error', (error) => console.error('Error:', error));
+
+// State access:
+tonConnectUI.wallet; // Current wallet state
+tonConnectUI.modalState.open; // Modal open state
+tonConnectUI.uiVersion; // UI kit version
 ```
 
 #### `useTonWallet()`
@@ -204,10 +240,12 @@ new TonConnectMobile(config: TonConnectMobileConfig)
 - `manifestUrl` (required): URL to your TonConnect manifest file
 - `scheme` (required): Your app's deep link scheme
 - `storageKeyPrefix` (optional): Prefix for storage keys (default: `'tonconnect_'`)
-- `connectionTimeout` (optional): Connection timeout in ms (default: `30000`)
-- `transactionTimeout` (optional): Transaction timeout in ms (default: `300000`)
+- `connectionTimeout` (optional): Connection timeout in ms (default: `300000` = 5 minutes)
+- `transactionTimeout` (optional): Transaction timeout in ms (default: `300000` = 5 minutes)
 - `skipCanOpenURLCheck` (optional): Skip canOpenURL check (default: `true` for Android compatibility)
 - `preferredWallet` (optional): Default wallet name
+- `network` (optional): Network to use - `'mainnet'` or `'testnet'` (default: `'mainnet'`)
+- `tonApiEndpoint` (optional): Custom TON API endpoint (default: auto-selected based on network)
 
 #### Methods
 
@@ -286,20 +324,124 @@ const unsubscribe = ton.onStatusChange((status) => {
 });
 ```
 
-## Platform Support
+##### `getNetwork(): Network`
+
+Get current network (mainnet or testnet).
+
+```typescript
+const network = ton.getNetwork(); // 'mainnet' or 'testnet'
+```
+
+##### `setNetwork(network: Network): void`
+
+Switch between mainnet and testnet.
+
+```typescript
+ton.setNetwork('testnet'); // Switch to testnet
+// Note: Warning is logged if switching while wallet is connected
+```
+
+##### `getBalance(address?: string): Promise<BalanceResponse>`
+
+Get wallet balance from TON Center API.
+
+```typescript
+// Get balance of connected wallet
+const balance = await ton.getBalance();
+
+// Get balance of specific address
+const balance = await ton.getBalance('EQD0vdSA_NedR9uvbgN9EikRX-suesDxGeFg69XQMavfLqIo');
+
+// Response:
+// {
+//   balance: "1000000000", // in nanotons
+//   balanceTon: "1.0", // formatted TON
+//   network: "mainnet"
+// }
+```
+
+##### `getTransactionStatusByHash(txHash: string, address: string): Promise<TransactionStatusResponse>`
+
+Get transaction status by hash (recommended method).
+
+```typescript
+const status = await ton.getTransactionStatusByHash(txHash, address);
+
+// Response:
+// {
+//   status: "confirmed" | "pending" | "failed" | "unknown",
+//   hash?: string,
+//   blockNumber?: number,
+//   error?: string
+// }
+```
+
+##### `getTransactionStatus(boc: string, maxAttempts?: number, intervalMs?: number): Promise<TransactionStatusResponse>`
+
+Get transaction status from BOC (requires BOC parsing library).
+
+```typescript
+// Note: This method requires BOC parsing. Use getTransactionStatusByHash() instead.
+const status = await ton.getTransactionStatus(boc, 10, 2000);
+```
+
+##### `on<T>(event: TonConnectEventType, listener: TonConnectEventListener<T>): () => void`
+
+Add event listener.
+
+```typescript
+// Listen to connection events
+const unsubscribe = ton.on('connect', (wallet) => {
+  console.log('Connected to:', wallet.name);
+});
+
+// Listen to transaction events
+ton.on('transaction', (tx) => {
+  console.log('Transaction sent:', tx.boc);
+});
+
+// Listen to errors
+ton.on('error', (error) => {
+  console.error('SDK error:', error);
+});
+
+// Cleanup
+unsubscribe();
+```
+
+##### `off<T>(event: TonConnectEventType, listener: TonConnectEventListener<T>): void`
+
+Remove event listener.
+
+```typescript
+ton.off('connect', listener);
+```
+
+##### `removeAllListeners(event?: TonConnectEventType): void`
 
-**⚠️ Important**: TON Connect deep links (`tonconnect://`) only work on **mobile devices** (Android/iOS). They do not work in web browsers.
+Remove all listeners for an event, or all events.
+
+```typescript
+ton.removeAllListeners('connect'); // Remove all connect listeners
+ton.removeAllListeners(); // Remove all listeners
+```
+
+## Platform Support
 
 - ✅ **Android**: Full support via Expo or React Native CLI
 - ✅ **iOS**: Full support via Expo or React Native CLI  
-- ⚠️ **Web**: Deep links are not supported. The SDK will throw a clear error message if you try to use it in a web browser.
+- ✅ **Web**: Universal links supported (opens wallet in new tab/window)
 
-**Why?** The `tonconnect://` protocol is a custom URI scheme that requires a mobile app handler. Web browsers cannot handle these custom protocols.
+**Web Platform Notes:**
+- On web, wallets with universal links (like Tonkeeper Web, MyTonWallet) can be opened in a new browser tab
+- The SDK automatically detects web platform and shows all available wallets
+- Wallet availability is checked based on universal link support
+- Deep links (`tonconnect://`) are not supported in web browsers, but universal links work perfectly
 
-**Testing**: To test wallet connections, use:
+**Testing**: 
 - Android device or emulator
 - iOS device or simulator
-- Not web browsers
+- Web browsers (for wallets with web support like Tonkeeper Web)
 
 ## Configuration
 
@@ -368,10 +510,12 @@ The manifest URL must be accessible via HTTPS.
 
 ## Supported Wallets
 
-- **Tonkeeper** - Full support
-- **Tonhub** - Full support
-- **MyTonWallet** - Full support
-- **Wallet in Telegram** - Full support
+- **Tonkeeper** - Full support (iOS, Android, Web)
+- **MyTonWallet** - Full support (iOS, Android, Web)
+- **Tonhub** - Full support (iOS, Android)
+- **Wallet in Telegram** - Full support (iOS, Android)
+
+**Note**: Wallet icons are automatically loaded from official sources. If an icon fails to load, a placeholder with the wallet's initial is shown.
 
 ## Migration from @tonconnect/ui-react
 
@@ -453,10 +597,133 @@ MIT
 For issues and questions:
 - GitHub Issues: [https://github.com/blaziumdev/ton-connect-mobile/issues](https://github.com/blaziumdev/ton-connect-mobile/issues)
 
-## New Features in v1.2.0
+## New Features in v1.2.3
+
+### 🌐 Network Switching
+Switch between mainnet and testnet dynamically:
+
+```typescript
+// Initialize with network
+const ton = new TonConnectMobile({
+  network: 'testnet', // or 'mainnet' (default)
+  // ... other config
+});
+
+// Or switch at runtime
+ton.setNetwork('testnet');
+tonConnectUI.setNetwork('testnet');
+
+// Get current network
+const network = ton.getNetwork(); // 'mainnet' or 'testnet'
+```
+
+**Features:**
+- Chain ID automatically updates (-239 for mainnet, -3 for testnet)
+- TON API endpoint automatically switches based on network
+- Warning logged if switching network while wallet is connected
+- React components automatically update chain ID
+
+### 📡 Event Emitters
+Listen to SDK events for reactive programming:
+
+```typescript
+// Add event listeners
+tonConnectUI.on('connect', (wallet) => {
+  console.log('Connected to:', wallet.name);
+});
+
+tonConnectUI.on('disconnect', () => {
+  console.log('Disconnected');
+});
+
+tonConnectUI.on('transaction', (tx) => {
+  console.log('Transaction sent:', tx.boc);
+});
+
+tonConnectUI.on('error', (error) => {
+  console.error('SDK error:', error);
+});
+
+// Remove listener
+const unsubscribe = tonConnectUI.on('connect', listener);
+unsubscribe(); // or
+tonConnectUI.off('connect', listener);
+```
+
+**Available Events:**
+- `connect` - Fired when wallet connects
+- `disconnect` - Fired when wallet disconnects
+- `transaction` - Fired when transaction is sent
+- `error` - Fired when an error occurs
+- `statusChange` - Fired when connection status changes
+
+### 💰 Wallet Balance Checking
+Get wallet balance from TON Center API:
+
+```typescript
+// Get balance of connected wallet
+const balance = await tonConnectUI.getBalance();
+
+// Get balance of specific address
+const balance = await tonConnectUI.getBalance('EQD0vdSA_NedR9uvbgN9EikRX-suesDxGeFg69XQMavfLqIo');
+
+// Response:
+// {
+//   balance: "1000000000", // in nanotons
+//   balanceTon: "1.0", // formatted TON
+//   network: "mainnet"
+// }
+```
+
+**Features:**
+- Automatically uses correct API endpoint based on network
+- Returns balance in both nanotons and formatted TON
+- Validates address format before API call
+- Handles API errors gracefully
+
+### 📊 Transaction Status Tracking
+Track transaction status after sending:
+
+```typescript
+// Using transaction hash (recommended)
+const status = await tonConnectUI.getTransactionStatusByHash(txHash, address);
+
+// Response:
+// {
+//   status: "confirmed" | "pending" | "failed" | "unknown",
+//   hash: "transaction_hash",
+//   blockNumber: 12345,
+//   error?: "error message"
+// }
+
+// Using BOC (requires BOC parsing library)
+const status = await tonConnectUI.getTransactionStatus(boc, maxAttempts, intervalMs);
+```
+
+**Features:**
+- Polling mechanism with configurable attempts and intervals
+- Network-specific API endpoint selection
+- Returns detailed status information
+- Handles API errors gracefully
+
+### 🎯 Complete TonConnectUI API
+All features from `@tonconnect/ui-react` are now available:
+
+```typescript
+const tonConnectUI = useTonConnectUI();
+
+// Restore connection from stored session
+await tonConnectUI.restoreConnection();
+
+// Customize available wallets
+tonConnectUI.setWalletList([
+  { name: 'Tonkeeper', universalLink: '...', platforms: ['ios', 'android', 'web'] },
+  { name: 'MyTonWallet', universalLink: '...', platforms: ['ios', 'android', 'web'] },
+]);
+```
 
 ### 🎨 Wallet Selection Modal
-Beautiful, built-in wallet selection modal that automatically appears when you call `openModal()`:
+Beautiful, built-in wallet selection modal with grid layout matching @tonconnect/ui-react design. Automatically appears when you call `openModal()`:
 
 ```typescript
 import { WalletSelectionModal } from '@blazium/ton-connect-mobile/react';
@@ -469,6 +736,14 @@ import { WalletSelectionModal } from '@blazium/ton-connect-mobile/react';
 />
 ```
 
+**Features:**
+- Grid layout (4 columns) matching @tonconnect/ui-react design
+- Real wallet icons loaded from official sources
+- Availability status for each wallet
+- Automatic wallet filtering by platform
+- Smooth animations and loading states
+- Custom wallet list support via `setWalletList()`
+
 ### 🛠️ Transaction Builder Utilities
 Helper functions for building transactions easily:
 
@@ -533,6 +808,12 @@ if (isAvailable) {
 }
 ```
 
+**Platform Detection:**
+- On web: Checks if wallet has universal link support (can open in new tab)
+- On mobile: Checks if wallet supports the current platform (iOS/Android)
+- Uses adapter type for reliable platform detection
+- All wallets with universal links are considered available on web
+
 ### 💬 Enhanced Error Messages
 All errors now include helpful recovery suggestions:
 
@@ -549,6 +830,23 @@ try {
 
 ## Changelog
 
+### v1.2.3
+- ✅ **NEW**: Network switching - Switch between mainnet and testnet dynamically
+- ✅ **NEW**: Event emitters - Listen to connect, disconnect, transaction, and error events
+- ✅ **NEW**: Wallet balance checking - Get wallet balance via TON Center API integration
+- ✅ **NEW**: Transaction status tracking - Track transaction status with polling mechanism
+- ✅ **NEW**: Complete TonConnectUI API implementation - all features from @tonconnect/ui-react
+- ✅ **NEW**: `restoreConnection()` method - restore connection from stored session
+- ✅ **NEW**: `setWalletList()` method - customize available wallets in modal
+- ✅ **NEW**: Wallet selection modal with grid layout matching @tonconnect/ui-react design
+- ✅ **NEW**: Real wallet icons loaded from official sources
+- ✅ **NEW**: Improved web platform support (Tonkeeper Web, MyTonWallet Web)
+- ✅ **IMPROVED**: Wallet availability detection using adapter type (more reliable)
+- ✅ **IMPROVED**: All wallets shown on web platform (with availability status)
+- ✅ **IMPROVED**: Chain ID automatically updates when network changes
+- ✅ **FIXED**: Tonkeeper now correctly shows as available on web
+- ✅ **FIXED**: All Turkish comments translated to English
+
 ### v1.2.0
 - ✅ **NEW**: Beautiful wallet selection modal component
 - ✅ **NEW**: Transaction builder utilities (`buildTransferTransaction`, `tonToNano`, etc.)

package/dist/adapters/expo.js

@@ -67,15 +67,15 @@ class ExpoAdapter {
             else {
                 console.log('[ExpoAdapter] Skipping canOpenURL check (Android compatibility)');
             }
-            // CRITICAL FIX: Android'de canOpenURL() tonconnect:// protokolünü tanımayabilir
-            // Bu yüzden direkt openURL() çağırıyoruz. Eğer açılamazsa hata fırlatır.
+            // CRITICAL FIX: On Android, canOpenURL() may not recognize tonconnect:// protocol
+            // So we call openURL() directly. If it fails, it will throw an error.
             await Linking.openURL(url);
             console.log('[ExpoAdapter] URL opened successfully');
             return true;
         }
         catch (error) {
             console.error('[ExpoAdapter] Error in openURL:', error);
-            // Android'de tonconnect:// protokolü tanınmıyorsa veya cüzdan yüklü değilse hata verir
+            // On Android, if tonconnect:// protocol is not recognized or wallet is not installed, it will throw an error
             const errorMessage = error?.message || String(error);
             if (errorMessage.includes('No Activity found') || errorMessage.includes('No app found') || errorMessage.includes('Cannot open URL')) {
                 throw new Error('No TON wallet app found. Please install Tonkeeper or another TON Connect compatible wallet from Google Play Store.');

package/dist/adapters/react-native.js

@@ -55,15 +55,15 @@ class ReactNativeAdapter {
             else {
                 console.log('[ReactNativeAdapter] Skipping canOpenURL check (Android compatibility)');
             }
-            // CRITICAL FIX: Android'de canOpenURL() tonconnect:// protokolünü tanımayabilir
-            // Bu yüzden direkt openURL() çağırıyoruz. Eğer açılamazsa hata fırlatır.
+            // CRITICAL FIX: On Android, canOpenURL() may not recognize tonconnect:// protocol
+            // So we call openURL() directly. If it fails, it will throw an error.
             await Linking.openURL(url);
             console.log('[ReactNativeAdapter] URL opened successfully');
             return true;
         }
         catch (error) {
             console.error('[ReactNativeAdapter] Error in openURL:', error);
-            // Android'de tonconnect:// protokolü tanınmıyorsa veya cüzdan yüklü değilse hata verir
+            // On Android, if tonconnect:// protocol is not recognized or wallet is not installed, it will throw an error
             const errorMessage = error?.message || String(error);
             if (errorMessage.includes('No Activity found') || errorMessage.includes('No app found') || errorMessage.includes('Cannot open URL')) {
                 throw new Error('No TON wallet app found. Please install Tonkeeper or another TON Connect compatible wallet from Google Play Store.');

package/dist/core/protocol.d.ts

@@ -35,6 +35,7 @@ export declare function parseCallbackURL(url: string, scheme: string): {
 };
 /**
  * Extract wallet info from connection response
+ * CRITICAL: This function assumes response has been validated by validateConnectionResponse
  */
 export declare function extractWalletInfo(response: ConnectionResponsePayload): WalletInfo;
 /**

package/dist/core/protocol.js

@@ -195,12 +195,21 @@ function parseCallbackURL(url, scheme) {
             return { type: 'unknown', data: null };
         }
         // Extract encoded payload
-        const encoded = url.substring(expectedPrefix.length);
+        let encoded = url.substring(expectedPrefix.length);
+        // CRITICAL FIX: Decode URL encoding first (wallet may URL-encode the payload)
+        try {
+            encoded = decodeURIComponent(encoded);
+        }
+        catch (error) {
+            // If decodeURIComponent fails, try using the original encoded string
+            // Some wallets may not URL-encode the payload
+            console.log('[TON Connect] Payload not URL-encoded, using as-is');
+        }
         // CRITICAL FIX: Validate base64 payload size (prevent DoS)
         if (encoded.length === 0 || encoded.length > 5000) {
             return { type: 'unknown', data: null };
         }
-        // CRITICAL FIX: Validate base64 characters only
+        // CRITICAL FIX: Validate base64 characters only (after URL decoding)
         if (!/^[A-Za-z0-9_-]+$/.test(encoded)) {
             return { type: 'unknown', data: null };
         }
@@ -241,12 +250,17 @@ function parseCallbackURL(url, scheme) {
 }
 /**
  * Extract wallet info from connection response
+ * CRITICAL: This function assumes response has been validated by validateConnectionResponse
  */
 function extractWalletInfo(response) {
+    // CRITICAL FIX: Add null checks to prevent runtime errors
+    if (!response || !response.name || !response.address || !response.publicKey) {
+        throw new Error('Invalid connection response: missing required fields');
+    }
     return {
         name: response.name,
-        appName: response.appName,
-        version: response.version,
+        appName: response.appName || response.name,
+        version: response.version || 'unknown',
         platform: response.platform || 'unknown',
         address: response.address,
         publicKey: response.publicKey,
@@ -280,13 +294,59 @@ function validateTransactionRequest(request) {
     if (!request.messages || request.messages.length === 0) {
         return { valid: false, error: 'Transaction must have at least one message' };
     }
-    for (const msg of request.messages) {
-        if (!msg.address) {
-            return { valid: false, error: 'Message address is required' };
+    // CRITICAL: Validate each message
+    for (let i = 0; i < request.messages.length; i++) {
+        const msg = request.messages[i];
+        // Validate address
+        if (!msg.address || typeof msg.address !== 'string') {
+            return { valid: false, error: `Message ${i + 1}: Address is required and must be a string` };
+        }
+        // CRITICAL: Validate TON address format (EQ... or 0Q...)
+        if (!/^(EQ|0Q)[A-Za-z0-9_-]{46}$/.test(msg.address)) {
+            return { valid: false, error: `Message ${i + 1}: Invalid TON address format. Address must start with EQ or 0Q and be 48 characters long.` };
+        }
+        // Validate amount
+        if (!msg.amount || typeof msg.amount !== 'string') {
+            return { valid: false, error: `Message ${i + 1}: Amount is required and must be a string (nanotons)` };
+        }
+        // CRITICAL: Validate amount is a valid positive number (nanotons)
+        try {
+            const amount = BigInt(msg.amount);
+            if (amount <= 0n) {
+                return { valid: false, error: `Message ${i + 1}: Amount must be greater than 0` };
+            }
+            // Check for reasonable maximum (prevent overflow)
+            if (amount > BigInt('1000000000000000000')) { // 1 billion TON
+                return { valid: false, error: `Message ${i + 1}: Amount exceeds maximum allowed (1 billion TON)` };
+            }
         }
-        if (!msg.amount || isNaN(Number(msg.amount))) {
-            return { valid: false, error: 'Message amount must be a valid number' };
+        catch (error) {
+            return { valid: false, error: `Message ${i + 1}: Amount must be a valid number string (nanotons)` };
         }
+        // Validate payload if provided (must be base64)
+        if (msg.payload !== undefined && msg.payload !== null) {
+            if (typeof msg.payload !== 'string') {
+                return { valid: false, error: `Message ${i + 1}: Payload must be a base64 string` };
+            }
+            // Basic base64 validation
+            if (msg.payload.length > 0 && !/^[A-Za-z0-9+/=]+$/.test(msg.payload)) {
+                return { valid: false, error: `Message ${i + 1}: Payload must be valid base64 encoded` };
+            }
+        }
+        // Validate stateInit if provided (must be base64)
+        if (msg.stateInit !== undefined && msg.stateInit !== null) {
+            if (typeof msg.stateInit !== 'string') {
+                return { valid: false, error: `Message ${i + 1}: StateInit must be a base64 string` };
+            }
+            // Basic base64 validation
+            if (msg.stateInit.length > 0 && !/^[A-Za-z0-9+/=]+$/.test(msg.stateInit)) {
+                return { valid: false, error: `Message ${i + 1}: StateInit must be valid base64 encoded` };
+            }
+        }
+    }
+    // CRITICAL: Limit maximum number of messages (prevent DoS)
+    if (request.messages.length > 255) {
+        return { valid: false, error: 'Transaction cannot have more than 255 messages' };
     }
     return { valid: true };
 }

package/dist/core/wallets.js

@@ -17,7 +17,8 @@ exports.SUPPORTED_WALLETS = [
         appName: 'Tonkeeper',
         universalLink: 'https://app.tonkeeper.com/ton-connect',
         deepLink: 'tonkeeper://',
-        platforms: ['ios', 'android'],
+        iconUrl: 'https://tonkeeper.com/assets/tonconnect-icon.png',
+        platforms: ['ios', 'android', 'web'], // CRITICAL FIX: Tonkeeper Web is supported
         preferredReturnStrategy: 'post_redirect', // CRITICAL FIX: 'back' strategy may not send callback properly, use 'post_redirect'
         requiresReturnScheme: true, // CRITICAL FIX: Mobile apps need returnScheme for proper callback handling
     },
@@ -26,6 +27,7 @@ exports.SUPPORTED_WALLETS = [
         appName: 'MyTonWallet',
         universalLink: 'https://connect.mytonwallet.org',
         deepLink: 'mytonwallet://',
+        iconUrl: 'https://static.mytonwallet.io/icon-256.png',
         platforms: ['ios', 'android', 'web'],
         preferredReturnStrategy: 'post_redirect',
         requiresReturnScheme: true, // MyTonWallet requires explicit returnScheme
@@ -35,6 +37,7 @@ exports.SUPPORTED_WALLETS = [
         appName: 'Wallet',
         universalLink: 'https://wallet.tonapi.io/ton-connect',
         deepLink: 'tg://',
+        iconUrl: 'https://wallet.tonapi.io/icon.png',
         platforms: ['ios', 'android'],
         preferredReturnStrategy: 'post_redirect',
         requiresReturnScheme: true, // Telegram Wallet requires explicit returnScheme
@@ -44,6 +47,7 @@ exports.SUPPORTED_WALLETS = [
         appName: 'Tonhub',
         universalLink: 'https://tonhub.com/ton-connect',
         deepLink: 'tonhub://',
+        iconUrl: 'https://tonhub.com/tonconnect_logo.png',
         platforms: ['ios', 'android'],
         preferredReturnStrategy: 'post_redirect',
         requiresReturnScheme: true, // Tonhub requires explicit returnScheme for proper callback