@blazium/ton-connect-mobile 1.2.1 → 1.2.4

package/dist/index.js

@@ -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,
         });
@@ -284,6 +297,8 @@ 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) {
@@ -307,6 +322,12 @@ 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) {
@@ -319,16 +340,15 @@ class TonConnectMobile {
             // Clear promise first to prevent race conditions
             this.transactionPromise = null;
             // Then resolve
-            promise.resolve({
-                boc: response.boc,
-                signature: response.signature,
-            });
+            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);
@@ -648,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
@@ -738,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
@@ -841,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 */

package/dist/react/TonConnectUIProvider.js

@@ -67,13 +67,21 @@ function TonConnectUIProvider({ config, children, sdkInstance, }) {
     const [walletState, setWalletState] = (0, react_1.useState)(null);
     const [modalOpen, setModalOpen] = (0, react_1.useState)(false);
     const [isConnecting, setIsConnecting] = (0, react_1.useState)(false);
+    const [customWalletList, setCustomWalletList] = (0, react_1.useState)(null);
+    // Get chain ID based on network
+    const getChainId = (0, react_1.useCallback)((network) => {
+        // TON mainnet chain ID: -239
+        // TON testnet chain ID: -3
+        return network === 'testnet' ? -3 : -239;
+    }, []);
     // Update wallet state from SDK status
     const updateWalletState = (0, react_1.useCallback)((status) => {
         if (status.connected && status.wallet) {
+            const network = sdk.getNetwork();
             setWalletState({
                 account: {
                     address: status.wallet.address,
-                    chain: -239, // TON mainnet chain ID
+                    chain: getChainId(network),
                     publicKey: status.wallet.publicKey,
                 },
                 wallet: status.wallet,
@@ -87,7 +95,7 @@ function TonConnectUIProvider({ config, children, sdkInstance, }) {
                 connected: false,
             });
         }
-    }, []);
+    }, [sdk, getChainId]);
     // Subscribe to SDK status changes
     (0, react_1.useEffect)(() => {
         // Set initial state
@@ -184,6 +192,58 @@ function TonConnectUIProvider({ config, children, sdkInstance, }) {
             throw error;
         }
     }, [sdk]);
+    // Restore connection from stored session
+    const restoreConnection = (0, react_1.useCallback)(async () => {
+        try {
+            // SDK automatically loads session on initialization
+            // This method triggers a re-check of the stored session
+            const status = sdk.getStatus();
+            if (status.connected && status.wallet) {
+                updateWalletState(status);
+            }
+        }
+        catch (error) {
+            console.error('[TonConnectUIProvider] Restore connection error:', error);
+            throw error;
+        }
+    }, [sdk, updateWalletState]);
+    // Set wallet list (customize available wallets)
+    const setWalletList = (0, react_1.useCallback)((wallets) => {
+        if (!wallets || !Array.isArray(wallets)) {
+            throw new Error('Wallet list must be an array');
+        }
+        setCustomWalletList(wallets);
+    }, []);
+    // Get network
+    const getNetwork = (0, react_1.useCallback)(() => {
+        return sdk.getNetwork();
+    }, [sdk]);
+    // Set network
+    const setNetwork = (0, react_1.useCallback)((network) => {
+        sdk.setNetwork(network);
+        // Update wallet state to reflect new chain ID
+        const status = sdk.getStatus();
+        updateWalletState(status);
+    }, [sdk, updateWalletState]);
+    // Get balance
+    const getBalance = (0, react_1.useCallback)(async (address) => {
+        return await sdk.getBalance(address);
+    }, [sdk]);
+    // Get transaction status
+    const getTransactionStatus = (0, react_1.useCallback)(async (boc, maxAttempts = 10, intervalMs = 2000) => {
+        return await sdk.getTransactionStatus(boc, maxAttempts, intervalMs);
+    }, [sdk]);
+    // Get transaction status by hash
+    const getTransactionStatusByHash = (0, react_1.useCallback)(async (txHash, address) => {
+        return await sdk.getTransactionStatusByHash(txHash, address);
+    }, [sdk]);
+    // Event listeners
+    const on = (0, react_1.useCallback)((event, listener) => {
+        return sdk.on(event, listener);
+    }, [sdk]);
+    const off = (0, react_1.useCallback)((event, listener) => {
+        sdk.off(event, listener);
+    }, [sdk]);
     // Create TonConnectUI instance
     const tonConnectUI = {
         openModal,
@@ -192,6 +252,15 @@ function TonConnectUIProvider({ config, children, sdkInstance, }) {
         disconnect,
         sendTransaction,
         signData,
+        restoreConnection,
+        setWalletList,
+        getNetwork,
+        setNetwork,
+        getBalance,
+        getTransactionStatus,
+        getTransactionStatusByHash,
+        on,
+        off,
         wallet: walletState,
         modalState: {
             open: modalOpen,
@@ -204,7 +273,7 @@ function TonConnectUIProvider({ config, children, sdkInstance, }) {
     };
     return (react_1.default.createElement(TonConnectUIContext.Provider, { value: contextValue },
         children,
-        react_1.default.createElement(WalletSelectionModal_1.WalletSelectionModal, { visible: modalOpen && !walletState?.connected, onClose: closeModal })));
+        react_1.default.createElement(WalletSelectionModal_1.WalletSelectionModal, { visible: modalOpen && !walletState?.connected, onClose: closeModal, wallets: customWalletList || undefined })));
 }
 /**
  * Hook to access TonConnectUI instance

package/dist/react/WalletSelectionModal.d.ts

@@ -1,6 +1,7 @@
 /**
  * WalletSelectionModal component
  * Provides a beautiful wallet selection UI compatible with @tonconnect/ui-react
+ * Matches the exact UI/UX of @tonconnect/ui-react wallet selection modal
  */
 import type { WalletDefinition } from '../index';
 export interface WalletSelectionModalProps {