@blazium/ton-connect-mobile 1.2.1 → 1.2.4

package/src/index.ts

@@ -13,6 +13,12 @@ import {
   SendTransactionRequest,
   StatusChangeCallback,
   PlatformAdapter,
+  Network,
+  TonConnectEventType,
+  TonConnectEventListener,
+  TransactionStatus,
+  TransactionStatusResponse,
+  BalanceResponse,
 } from './types';
 import {
   buildConnectionRequest,
@@ -106,8 +112,13 @@ export class TransactionInProgressError extends TonConnectError {
  */
 export class TonConnectMobile {
   private adapter: PlatformAdapter;
-  private config: Required<Omit<TonConnectMobileConfig, 'preferredWallet'>> & { preferredWallet?: string };
+  private config: Required<Omit<TonConnectMobileConfig, 'preferredWallet' | 'network' | 'tonApiEndpoint'>> & {
+    preferredWallet?: string;
+    network: Network;
+    tonApiEndpoint?: string;
+  };
   private statusChangeCallbacks: Set<StatusChangeCallback> = new Set();
+  private eventListeners: Map<TonConnectEventType, Set<TonConnectEventListener>> = new Map();
   private currentStatus: ConnectionStatus = { connected: false, wallet: null };
   private urlUnsubscribe: (() => void) | null = null;
   private currentWallet!: WalletDefinition;
@@ -136,14 +147,32 @@ export class TonConnectMobile {
       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,
-    } as Required<Omit<TonConnectMobileConfig, 'preferredWallet'>> & { preferredWallet?: string };
+    } as Required<Omit<TonConnectMobileConfig, 'preferredWallet' | 'network' | 'tonApiEndpoint'>> & {
+      preferredWallet?: string;
+      network: Network;
+      tonApiEndpoint?: string;
+    };
 
     // Determine which wallet to use
     if (this.config.preferredWallet) {
@@ -162,6 +191,7 @@ export 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,
     });
@@ -347,6 +377,9 @@ export class TonConnectMobile {
     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) {
@@ -372,6 +405,14 @@ export class TonConnectMobile {
       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) {
@@ -384,10 +425,7 @@ export 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);
     }
   }
 
@@ -395,6 +433,9 @@ export class TonConnectMobile {
    * Reject current promise with error
    */
   private rejectWithError(error: Error): void {
+    // Emit error event
+    this.emit('error', error);
+
     if (this.connectionPromise) {
       if (this.connectionPromise.timeout !== null) {
         clearTimeout(this.connectionPromise.timeout);
@@ -772,6 +813,9 @@ export class TonConnectMobile {
     // Update status
     this.currentStatus = { connected: false, wallet: null };
     this.notifyStatusChange();
+
+    // Emit disconnect event
+    this.emit('disconnect', null);
   }
 
   /**
@@ -876,6 +920,63 @@ export class TonConnectMobile {
         // Ignore errors in callbacks
       }
     });
+    // Emit statusChange event
+    this.emit('statusChange', status);
+  }
+
+  /**
+   * Emit event to all listeners
+   */
+  private emit<T>(event: TonConnectEventType, data: T): void {
+    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<T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>): () => void {
+    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<T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>): void {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+
+  /**
+   * Remove all listeners for an event
+   */
+  removeAllListeners(event?: TonConnectEventType): void {
+    if (event) {
+      this.eventListeners.delete(event);
+    } else {
+      this.eventListeners.clear();
+    }
   }
 
   /**
@@ -990,10 +1091,240 @@ export class TonConnectMobile {
     }
 
     this.statusChangeCallbacks.clear();
+    this.eventListeners.clear();
     this.connectionPromise = null;
     this.transactionPromise = null;
     this.signDataPromise = null;
   }
+
+  /**
+   * Get current network
+   */
+  getNetwork(): Network {
+    return this.config.network;
+  }
+
+  /**
+   * Set network (mainnet/testnet)
+   */
+  setNetwork(network: Network): void {
+    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?: string): Promise<BalanceResponse> {
+    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: any) {
+      if (error instanceof TonConnectError) {
+        throw error;
+      }
+      throw new TonConnectError(`Failed to get balance: ${error?.message || String(error)}`);
+    }
+  }
+
+  /**
+   * Get transaction status
+   */
+  async getTransactionStatus(boc: string, maxAttempts: number = 10, intervalMs: number = 2000): Promise<TransactionStatusResponse> {
+    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: Error | null = 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<void>((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: any) {
+          lastError = error;
+          attempts++;
+          if (attempts < maxAttempts) {
+            await new Promise<void>((resolve) => setTimeout(() => resolve(), intervalMs));
+          }
+        }
+      }
+
+      return {
+        status: 'failed',
+        error: lastError?.message || 'Failed to check transaction status',
+      };
+    } catch (error: any) {
+      throw new TonConnectError(`Failed to get transaction status: ${error?.message || String(error)}`);
+    }
+  }
+
+  /**
+   * Get transaction status by hash (more reliable than BOC)
+   */
+  async getTransactionStatusByHash(txHash: string, address: string): Promise<TransactionStatusResponse> {
+    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: any) => 
+        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: any) {
+      if (error instanceof TonConnectError) {
+        throw error;
+      }
+      return {
+        status: 'failed',
+        error: error?.message || 'Failed to check transaction status',
+      };
+    }
+  }
 }
 
 // Export types

package/src/react/TonConnectUIProvider.tsx

@@ -4,8 +4,8 @@
  */
 
 import React, { createContext, useContext, useState, useEffect, useCallback, ReactNode } from 'react';
-import { TonConnectMobile, ConnectionStatus, WalletInfo, SendTransactionRequest } from '../index';
-import type { TonConnectMobileConfig } from '../types';
+import { TonConnectMobile, ConnectionStatus, WalletInfo, SendTransactionRequest, WalletDefinition, Network, BalanceResponse, TransactionStatusResponse } from '../index';
+import type { TonConnectMobileConfig, TonConnectEventType, TonConnectEventListener } from '../types';
 import { WalletSelectionModal } from './WalletSelectionModal';
 
 /**
@@ -54,6 +54,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 */
@@ -68,6 +69,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 */
@@ -124,14 +143,23 @@ export function TonConnectUIProvider({
   const [walletState, setWalletState] = useState<WalletState | null>(null);
   const [modalOpen, setModalOpen] = useState(false);
   const [isConnecting, setIsConnecting] = useState(false);
+  const [customWalletList, setCustomWalletList] = useState<WalletDefinition[] | null>(null);
+
+  // Get chain ID based on network
+  const getChainId = useCallback((network: Network): number => {
+    // TON mainnet chain ID: -239
+    // TON testnet chain ID: -3
+    return network === 'testnet' ? -3 : -239;
+  }, []);
 
   // Update wallet state from SDK status
   const updateWalletState = useCallback((status: ConnectionStatus) => {
     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,
@@ -144,7 +172,7 @@ export function TonConnectUIProvider({
         connected: false,
       });
     }
-  }, []);
+  }, [sdk, getChainId]);
 
   // Subscribe to SDK status changes
   useEffect(() => {
@@ -257,6 +285,73 @@ export function TonConnectUIProvider({
     [sdk]
   );
 
+  // Restore connection from stored session
+  const restoreConnection = useCallback(async (): Promise<void> => {
+    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 = useCallback((wallets: WalletDefinition[]): void => {
+    if (!wallets || !Array.isArray(wallets)) {
+      throw new Error('Wallet list must be an array');
+    }
+    setCustomWalletList(wallets);
+  }, []);
+
+  // Get network
+  const getNetwork = useCallback((): Network => {
+    return sdk.getNetwork();
+  }, [sdk]);
+
+  // Set network
+  const setNetwork = useCallback((network: Network): void => {
+    sdk.setNetwork(network);
+    // Update wallet state to reflect new chain ID
+    const status = sdk.getStatus();
+    updateWalletState(status);
+  }, [sdk, updateWalletState]);
+
+  // Get balance
+  const getBalance = useCallback(async (address?: string): Promise<BalanceResponse> => {
+    return await sdk.getBalance(address);
+  }, [sdk]);
+
+  // Get transaction status
+  const getTransactionStatus = useCallback(async (
+    boc: string,
+    maxAttempts: number = 10,
+    intervalMs: number = 2000
+  ): Promise<TransactionStatusResponse> => {
+    return await sdk.getTransactionStatus(boc, maxAttempts, intervalMs);
+  }, [sdk]);
+
+  // Get transaction status by hash
+  const getTransactionStatusByHash = useCallback(async (
+    txHash: string,
+    address: string
+  ): Promise<TransactionStatusResponse> => {
+    return await sdk.getTransactionStatusByHash(txHash, address);
+  }, [sdk]);
+
+  // Event listeners
+  const on = useCallback(<T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>): (() => void) => {
+    return sdk.on(event, listener);
+  }, [sdk]);
+
+  const off = useCallback(<T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>): void => {
+    sdk.off(event, listener);
+  }, [sdk]);
+
   // Create TonConnectUI instance
   const tonConnectUI: TonConnectUI = {
     openModal,
@@ -265,6 +360,15 @@ export function TonConnectUIProvider({
     disconnect,
     sendTransaction,
     signData,
+    restoreConnection,
+    setWalletList,
+    getNetwork,
+    setNetwork,
+    getBalance,
+    getTransactionStatus,
+    getTransactionStatusByHash,
+    on,
+    off,
     wallet: walletState,
     modalState: {
       open: modalOpen,
@@ -284,6 +388,7 @@ export function TonConnectUIProvider({
       <WalletSelectionModal
         visible={modalOpen && !walletState?.connected}
         onClose={closeModal}
+        wallets={customWalletList || undefined}
       />
     </TonConnectUIContext.Provider>
   );