@blazium/ton-connect-mobile 1.2.0 → 1.2.3

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * TON Connect Mobile SDK
  * Production-ready implementation for React Native and Expo
  */
-import { TonConnectMobileConfig, ConnectionStatus, WalletInfo, SendTransactionRequest, StatusChangeCallback } from './types';
+import { TonConnectMobileConfig, ConnectionStatus, WalletInfo, SendTransactionRequest, StatusChangeCallback, Network, TonConnectEventType, TonConnectEventListener, TransactionStatusResponse, BalanceResponse } from './types';
 import { type WalletDefinition } from './core/wallets';
 /**
  * Custom error classes
@@ -34,6 +34,7 @@ export declare class TonConnectMobile {
     private adapter;
     private config;
     private statusChangeCallbacks;
+    private eventListeners;
     private currentStatus;
     private urlUnsubscribe;
     private currentWallet;
@@ -103,6 +104,8 @@ export declare class TonConnectMobile {
     /**
      * Check if a wallet is available on the current platform
      * Note: This is a best-effort check and may not be 100% accurate
+     * CRITICAL FIX: On web, if wallet has universalLink, it's considered available
+     * because universal links can open in new tabs/windows
      */
     isWalletAvailable(walletName?: string): Promise<boolean>;
     /**
@@ -117,6 +120,22 @@ export declare class TonConnectMobile {
      * Notify all status change callbacks
      */
     private notifyStatusChange;
+    /**
+     * Emit event to all listeners
+     */
+    private emit;
+    /**
+     * Add event listener
+     */
+    on<T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>): () => void;
+    /**
+     * Remove event listener
+     */
+    off<T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>): void;
+    /**
+     * Remove all listeners for an event
+     */
+    removeAllListeners(event?: TonConnectEventType): void;
     /**
      * Validate session ID format
      */
@@ -137,6 +156,26 @@ export declare class TonConnectMobile {
      * Cleanup resources
      */
     destroy(): void;
+    /**
+     * Get current network
+     */
+    getNetwork(): Network;
+    /**
+     * Set network (mainnet/testnet)
+     */
+    setNetwork(network: Network): void;
+    /**
+     * Get wallet balance
+     */
+    getBalance(address?: string): Promise<BalanceResponse>;
+    /**
+     * Get transaction status
+     */
+    getTransactionStatus(boc: string, maxAttempts?: number, intervalMs?: number): Promise<TransactionStatusResponse>;
+    /**
+     * Get transaction status by hash (more reliable than BOC)
+     */
+    getTransactionStatusByHash(txHash: string, address: string): Promise<TransactionStatusResponse>;
 }
 export * from './types';
 export type { WalletDefinition } from './core/wallets';

package/dist/index.js

@@ -60,14 +60,14 @@ class UserRejectedError extends TonConnectError {
 exports.UserRejectedError = UserRejectedError;
 class ConnectionInProgressError extends TonConnectError {
     constructor() {
-        super('Connection request already in progress', 'CONNECTION_IN_PROGRESS');
+        super('Connection request already in progress', 'CONNECTION_IN_PROGRESS', 'Please wait for the current connection attempt to complete before trying again.');
         this.name = 'ConnectionInProgressError';
     }
 }
 exports.ConnectionInProgressError = ConnectionInProgressError;
 class TransactionInProgressError extends TonConnectError {
     constructor() {
-        super('Transaction request already in progress', 'TRANSACTION_IN_PROGRESS');
+        super('Transaction request already in progress', 'TRANSACTION_IN_PROGRESS', 'Please wait for the current transaction to complete before sending another one.');
         this.name = 'TransactionInProgressError';
     }
 }
@@ -78,6 +78,7 @@ exports.TransactionInProgressError = TransactionInProgressError;
 class TonConnectMobile {
     constructor(config) {
         this.statusChangeCallbacks = new Set();
+        this.eventListeners = new Map();
         this.currentStatus = { connected: false, wallet: null };
         this.urlUnsubscribe = null;
         this.connectionPromise = null;
@@ -90,12 +91,23 @@ class TonConnectMobile {
         if (!config.scheme) {
             throw new TonConnectError('scheme is required');
         }
+        // Validate network
+        const network = config.network || 'mainnet';
+        if (network !== 'mainnet' && network !== 'testnet') {
+            throw new TonConnectError('Network must be either "mainnet" or "testnet"');
+        }
+        // Set default TON API endpoint based on network
+        const defaultTonApiEndpoint = network === 'testnet'
+            ? 'https://testnet.toncenter.com/api/v2'
+            : 'https://toncenter.com/api/v2';
         this.config = {
             storageKeyPrefix: 'tonconnect_',
             connectionTimeout: 300000, // 5 minutes
             transactionTimeout: 300000, // 5 minutes
             skipCanOpenURLCheck: true, // Skip canOpenURL check by default (Android issue)
             preferredWallet: config.preferredWallet,
+            network,
+            tonApiEndpoint: config.tonApiEndpoint || defaultTonApiEndpoint,
             ...config,
         };
         // Determine which wallet to use
@@ -116,6 +128,7 @@ class TonConnectMobile {
         console.log('[TON Connect] Initializing SDK with config:', {
             manifestUrl: this.config.manifestUrl,
             scheme: this.config.scheme,
+            network: this.config.network,
             wallet: this.currentWallet.name,
             universalLink: this.currentWallet.universalLink,
         });
@@ -198,8 +211,9 @@ class TonConnectMobile {
         const parsed = (0, protocol_1.parseCallbackURL)(url, this.config.scheme);
         console.log('[TON Connect] Parsed callback:', parsed.type, parsed.data ? 'has data' : 'no data');
         // CRITICAL FIX: Check for sign data response first (before other handlers)
-        if (this.signDataPromise && !this.signDataPromise.timeout) {
-            // Sign data request is pending
+        // Note: We check if promise exists and hasn't timed out (timeout !== null means not timed out yet)
+        if (this.signDataPromise && this.signDataPromise.timeout !== null) {
+            // Sign data request is pending and hasn't timed out
             if (parsed.type === 'error' && parsed.data) {
                 const errorData = parsed.data;
                 if (errorData?.error) {
@@ -283,13 +297,21 @@ class TonConnectMobile {
         // Update status
         this.currentStatus = { connected: true, wallet };
         this.notifyStatusChange();
+        // Emit connect event
+        this.emit('connect', wallet);
         // Resolve connection promise
+        // CRITICAL: Only resolve if promise still exists and hasn't timed out
         if (this.connectionPromise) {
+            // Clear timeout if it exists
             if (this.connectionPromise.timeout !== null) {
                 clearTimeout(this.connectionPromise.timeout);
             }
-            this.connectionPromise.resolve(wallet);
+            // Store reference before clearing to prevent race conditions
+            const promise = this.connectionPromise;
+            // Clear promise first
             this.connectionPromise = null;
+            // Then resolve
+            promise.resolve(wallet);
         }
     }
     /**
@@ -300,22 +322,33 @@ class TonConnectMobile {
             this.rejectWithError(new TonConnectError('Invalid transaction response'));
             return;
         }
+        const transactionResult = {
+            boc: response.boc,
+            signature: response.signature,
+        };
+        // Emit transaction event
+        this.emit('transaction', transactionResult);
         // Resolve transaction promise
+        // CRITICAL: Only resolve if promise still exists and hasn't timed out
         if (this.transactionPromise) {
+            // Clear timeout if it exists
             if (this.transactionPromise.timeout !== null) {
                 clearTimeout(this.transactionPromise.timeout);
             }
-            this.transactionPromise.resolve({
-                boc: response.boc,
-                signature: response.signature,
-            });
+            // Store reference before clearing
+            const promise = this.transactionPromise;
+            // Clear promise first to prevent race conditions
             this.transactionPromise = null;
+            // Then resolve
+            promise.resolve(transactionResult);
         }
     }
     /**
      * Reject current promise with error
      */
     rejectWithError(error) {
+        // Emit error event
+        this.emit('error', error);
         if (this.connectionPromise) {
             if (this.connectionPromise.timeout !== null) {
                 clearTimeout(this.connectionPromise.timeout);
@@ -330,6 +363,14 @@ class TonConnectMobile {
             this.transactionPromise.reject(error);
             this.transactionPromise = null;
         }
+        // CRITICAL FIX: Also clear signDataPromise to prevent memory leaks
+        if (this.signDataPromise) {
+            if (this.signDataPromise.timeout !== null) {
+                clearTimeout(this.signDataPromise.timeout);
+            }
+            this.signDataPromise.reject(error);
+            this.signDataPromise = null;
+        }
     }
     /**
      * Connect to wallet
@@ -627,6 +668,8 @@ class TonConnectMobile {
         // Update status
         this.currentStatus = { connected: false, wallet: null };
         this.notifyStatusChange();
+        // Emit disconnect event
+        this.emit('disconnect', null);
     }
     /**
      * Get current connection status
@@ -649,16 +692,21 @@ class TonConnectMobile {
     /**
      * Check if a wallet is available on the current platform
      * Note: This is a best-effort check and may not be 100% accurate
+     * CRITICAL FIX: On web, if wallet has universalLink, it's considered available
+     * because universal links can open in new tabs/windows
      */
     async isWalletAvailable(walletName) {
         const wallet = walletName ? (0, wallets_1.getWalletByName)(walletName) : this.currentWallet;
         if (!wallet) {
             return false;
         }
-        // On web, check if wallet supports web platform
-        // eslint-disable-next-line no-undef
-        if (typeof globalThis !== 'undefined' && globalThis.window) {
-            return wallet.platforms.includes('web');
+        // CRITICAL FIX: Check adapter type to reliably detect web platform
+        // WebAdapter is only used on web, so this is the most reliable check
+        const isWeb = this.adapter.constructor.name === 'WebAdapter';
+        if (isWeb) {
+            // On web, if wallet has universalLink or supports web platform, it's available
+            // Universal links can open in a new tab on web
+            return wallet.platforms.includes('web') || !!wallet.universalLink;
         }
         // On mobile, we can't reliably check if wallet is installed
         // Return true if wallet supports the current platform
@@ -712,6 +760,60 @@ class TonConnectMobile {
                 // Ignore errors in callbacks
             }
         });
+        // Emit statusChange event
+        this.emit('statusChange', status);
+    }
+    /**
+     * Emit event to all listeners
+     */
+    emit(event, data) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.forEach((listener) => {
+                try {
+                    listener(data);
+                }
+                catch (error) {
+                    console.error(`[TON Connect] Error in event listener for ${event}:`, error);
+                }
+            });
+        }
+    }
+    /**
+     * Add event listener
+     */
+    on(event, listener) {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, new Set());
+        }
+        this.eventListeners.get(event).add(listener);
+        // Return unsubscribe function
+        return () => {
+            const listeners = this.eventListeners.get(event);
+            if (listeners) {
+                listeners.delete(listener);
+            }
+        };
+    }
+    /**
+     * Remove event listener
+     */
+    off(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+        }
+    }
+    /**
+     * Remove all listeners for an event
+     */
+    removeAllListeners(event) {
+        if (event) {
+            this.eventListeners.delete(event);
+        }
+        else {
+            this.eventListeners.clear();
+        }
     }
     /**
      * Validate session ID format
@@ -815,10 +917,204 @@ class TonConnectMobile {
             this.adapter.destroy();
         }
         this.statusChangeCallbacks.clear();
+        this.eventListeners.clear();
         this.connectionPromise = null;
         this.transactionPromise = null;
         this.signDataPromise = null;
     }
+    /**
+     * Get current network
+     */
+    getNetwork() {
+        return this.config.network;
+    }
+    /**
+     * Set network (mainnet/testnet)
+     */
+    setNetwork(network) {
+        if (network !== 'mainnet' && network !== 'testnet') {
+            throw new TonConnectError('Network must be either "mainnet" or "testnet"');
+        }
+        const oldNetwork = this.config.network;
+        // Warn if switching network while connected (wallet connection is network-specific)
+        if (this.currentStatus.connected && oldNetwork !== network) {
+            console.warn('[TON Connect] Network changed while wallet is connected. ' +
+                'The wallet connection may be invalid for the new network. ' +
+                'Consider disconnecting and reconnecting after network change.');
+        }
+        this.config.network = network;
+        // Update TON API endpoint if not explicitly set
+        if (!this.config.tonApiEndpoint || this.config.tonApiEndpoint.includes(oldNetwork)) {
+            this.config.tonApiEndpoint =
+                network === 'testnet'
+                    ? 'https://testnet.toncenter.com/api/v2'
+                    : 'https://toncenter.com/api/v2';
+        }
+        console.log('[TON Connect] Network changed to:', network);
+        // Notify status change to update chain ID in React components
+        this.notifyStatusChange();
+    }
+    /**
+     * Get wallet balance
+     */
+    async getBalance(address) {
+        const targetAddress = address || this.currentStatus.wallet?.address;
+        if (!targetAddress) {
+            throw new TonConnectError('Address is required. Either connect a wallet or provide an address.');
+        }
+        // Validate address format
+        if (!/^[0-9A-Za-z_-]{48}$/.test(targetAddress)) {
+            throw new TonConnectError('Invalid TON address format');
+        }
+        try {
+            const apiEndpoint = this.config.tonApiEndpoint ||
+                (this.config.network === 'testnet'
+                    ? 'https://testnet.toncenter.com/api/v2'
+                    : 'https://toncenter.com/api/v2');
+            const url = `${apiEndpoint}/getAddressInformation?address=${encodeURIComponent(targetAddress)}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                throw new TonConnectError(`Failed to fetch balance: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (data.ok === false) {
+                throw new TonConnectError(data.error || 'Failed to fetch balance');
+            }
+            // TON Center API returns balance in nanotons
+            const balance = data.result?.balance || '0';
+            const balanceTon = (BigInt(balance) / BigInt(1000000000)).toString() + '.' +
+                (BigInt(balance) % BigInt(1000000000)).toString().padStart(9, '0').replace(/0+$/, '');
+            return {
+                balance,
+                balanceTon: balanceTon === '0.' ? '0' : balanceTon,
+                network: this.config.network,
+            };
+        }
+        catch (error) {
+            if (error instanceof TonConnectError) {
+                throw error;
+            }
+            throw new TonConnectError(`Failed to get balance: ${error?.message || String(error)}`);
+        }
+    }
+    /**
+     * Get transaction status
+     */
+    async getTransactionStatus(boc, maxAttempts = 10, intervalMs = 2000) {
+        if (!boc || typeof boc !== 'string' || boc.length === 0) {
+            throw new TonConnectError('Transaction BOC is required');
+        }
+        // Extract transaction hash from BOC (simplified - in production, you'd parse the BOC properly)
+        // For now, we'll use a polling approach with TON Center API
+        try {
+            const apiEndpoint = this.config.tonApiEndpoint ||
+                (this.config.network === 'testnet'
+                    ? 'https://testnet.toncenter.com/api/v2'
+                    : 'https://toncenter.com/api/v2');
+            // Try to get transaction info
+            // Note: This is a simplified implementation. In production, you'd need to:
+            // 1. Parse the BOC to extract transaction hash
+            // 2. Query the blockchain for transaction status
+            // 3. Handle different confirmation states
+            // For now, we'll return a basic status
+            // In a real implementation, you'd query the blockchain API
+            let attempts = 0;
+            let lastError = null;
+            while (attempts < maxAttempts) {
+                try {
+                    // This is a placeholder - you'd need to implement actual transaction lookup
+                    // For now, we'll simulate checking
+                    await new Promise((resolve) => setTimeout(() => resolve(), intervalMs));
+                    // In production, you would:
+                    // 1. Parse BOC to get transaction hash
+                    // 2. Query TON API: GET /getTransactions?address=...&limit=1
+                    // 3. Check if transaction exists and is confirmed
+                    // For now, return unknown status (as we can't parse BOC without additional libraries)
+                    return {
+                        status: 'unknown',
+                        error: 'Transaction status checking requires BOC parsing. Please use a TON library to parse the BOC and extract the transaction hash.',
+                    };
+                }
+                catch (error) {
+                    lastError = error;
+                    attempts++;
+                    if (attempts < maxAttempts) {
+                        await new Promise((resolve) => setTimeout(() => resolve(), intervalMs));
+                    }
+                }
+            }
+            return {
+                status: 'failed',
+                error: lastError?.message || 'Failed to check transaction status',
+            };
+        }
+        catch (error) {
+            throw new TonConnectError(`Failed to get transaction status: ${error?.message || String(error)}`);
+        }
+    }
+    /**
+     * Get transaction status by hash (more reliable than BOC)
+     */
+    async getTransactionStatusByHash(txHash, address) {
+        if (!txHash || typeof txHash !== 'string' || txHash.length === 0) {
+            throw new TonConnectError('Transaction hash is required');
+        }
+        if (!address || typeof address !== 'string' || address.length === 0) {
+            throw new TonConnectError('Address is required');
+        }
+        try {
+            const apiEndpoint = this.config.tonApiEndpoint ||
+                (this.config.network === 'testnet'
+                    ? 'https://testnet.toncenter.com/api/v2'
+                    : 'https://toncenter.com/api/v2');
+            // Query transactions for the address
+            const url = `${apiEndpoint}/getTransactions?address=${encodeURIComponent(address)}&limit=100`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                throw new TonConnectError(`Failed to fetch transactions: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (data.ok === false) {
+                throw new TonConnectError(data.error || 'Failed to fetch transactions');
+            }
+            // Search for transaction with matching hash
+            const transactions = data.result || [];
+            const transaction = transactions.find((tx) => tx.transaction_id?.hash === txHash ||
+                tx.transaction_id?.lt === txHash ||
+                JSON.stringify(tx.transaction_id).includes(txHash));
+            if (transaction) {
+                return {
+                    status: 'confirmed',
+                    hash: transaction.transaction_id?.hash || txHash,
+                    blockNumber: transaction.transaction_id?.lt,
+                };
+            }
+            // Transaction not found - could be pending or failed
+            return {
+                status: 'pending',
+                hash: txHash,
+            };
+        }
+        catch (error) {
+            if (error instanceof TonConnectError) {
+                throw error;
+            }
+            return {
+                status: 'failed',
+                error: error?.message || 'Failed to check transaction status',
+            };
+        }
+    }
 }
 exports.TonConnectMobile = TonConnectMobile;
 // Export types

package/dist/react/TonConnectUIProvider.d.ts

@@ -3,8 +3,8 @@
  * Provides TonConnectUIProvider, hooks, and components compatible with @tonconnect/ui-react API
  */
 import { ReactNode } from 'react';
-import { TonConnectMobile, WalletInfo, SendTransactionRequest } from '../index';
-import type { TonConnectMobileConfig } from '../types';
+import { TonConnectMobile, WalletInfo, SendTransactionRequest, WalletDefinition, Network, BalanceResponse, TransactionStatusResponse } from '../index';
+import type { TonConnectMobileConfig, TonConnectEventType, TonConnectEventListener } from '../types';
 /**
  * Account information (compatible with @tonconnect/ui-react)
  */
@@ -46,6 +46,7 @@ export interface SignDataResponse {
 }
 /**
  * TonConnect UI instance interface (compatible with @tonconnect/ui-react)
+ * Includes all features from @tonconnect/ui-react for full compatibility
  */
 export interface TonConnectUI {
     /** Open connection modal */
@@ -60,6 +61,24 @@ export interface TonConnectUI {
     sendTransaction: (transaction: SendTransactionRequest) => Promise<TransactionResponse>;
     /** Sign data */
     signData: (request: SignDataRequest) => Promise<SignDataResponse>;
+    /** Restore connection from stored session */
+    restoreConnection: () => Promise<void>;
+    /** Set wallet list (customize available wallets) */
+    setWalletList: (wallets: WalletDefinition[]) => void;
+    /** Get current network */
+    getNetwork: () => Network;
+    /** Set network (mainnet/testnet) */
+    setNetwork: (network: Network) => void;
+    /** Get wallet balance */
+    getBalance: (address?: string) => Promise<BalanceResponse>;
+    /** Get transaction status */
+    getTransactionStatus: (boc: string, maxAttempts?: number, intervalMs?: number) => Promise<TransactionStatusResponse>;
+    /** Get transaction status by hash */
+    getTransactionStatusByHash: (txHash: string, address: string) => Promise<TransactionStatusResponse>;
+    /** Add event listener */
+    on: <T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>) => () => void;
+    /** Remove event listener */
+    off: <T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>) => void;
     /** Current wallet state */
     wallet: WalletState | null;
     /** Modal open state */