@blazium/ton-connect-mobile 1.1.1 → 1.1.2

package/dist/react/TonConnectUIProvider.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * React integration layer for @tonconnect/ui-react compatibility
+ * Provides TonConnectUIProvider, hooks, and components compatible with @tonconnect/ui-react API
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonConnectUIProvider = TonConnectUIProvider;
+exports.useTonConnectUI = useTonConnectUI;
+exports.useTonWallet = useTonWallet;
+exports.useTonConnectModal = useTonConnectModal;
+exports.useTonConnectSDK = useTonConnectSDK;
+const react_1 = __importStar(require("react"));
+const index_1 = require("../index");
+const TonConnectUIContext = (0, react_1.createContext)(null);
+/**
+ * TonConnectUIProvider - React context provider for TON Connect
+ * Compatible with @tonconnect/ui-react API
+ */
+function TonConnectUIProvider({ config, children, sdkInstance, }) {
+    const [sdk] = (0, react_1.useState)(() => sdkInstance || new index_1.TonConnectMobile(config));
+    const [walletState, setWalletState] = (0, react_1.useState)(null);
+    const [modalOpen, setModalOpen] = (0, react_1.useState)(false);
+    const [isConnecting, setIsConnecting] = (0, react_1.useState)(false);
+    // Update wallet state from SDK status
+    const updateWalletState = (0, react_1.useCallback)((status) => {
+        if (status.connected && status.wallet) {
+            setWalletState({
+                account: {
+                    address: status.wallet.address,
+                    chain: -239, // TON mainnet chain ID
+                    publicKey: status.wallet.publicKey,
+                },
+                wallet: status.wallet,
+                connected: true,
+            });
+        }
+        else {
+            setWalletState({
+                account: null,
+                wallet: null,
+                connected: false,
+            });
+        }
+    }, []);
+    // Subscribe to SDK status changes
+    (0, react_1.useEffect)(() => {
+        // Set initial state
+        const initialStatus = sdk.getStatus();
+        updateWalletState(initialStatus);
+        // Subscribe to changes
+        const unsubscribe = sdk.onStatusChange((status) => {
+            updateWalletState(status);
+            // Close modal when connected
+            if (status.connected) {
+                setModalOpen(false);
+                setIsConnecting(false);
+            }
+        });
+        return () => {
+            unsubscribe();
+            // CRITICAL FIX: Cleanup SDK on unmount to prevent memory leaks
+            // Note: SDK has its own cleanup via destroy(), but we don't call it here
+            // to allow SDK to persist across component remounts (e.g., navigation)
+        };
+    }, [sdk, updateWalletState]);
+    // Open modal
+    const openModal = (0, react_1.useCallback)(async () => {
+        setModalOpen(true);
+    }, []);
+    // Close modal
+    const closeModal = (0, react_1.useCallback)(() => {
+        setModalOpen(false);
+        setIsConnecting(false);
+    }, []);
+    // Connect wallet
+    const connectWallet = (0, react_1.useCallback)(async () => {
+        // CRITICAL FIX: Use functional update to avoid race condition
+        setIsConnecting((prev) => {
+            if (prev) {
+                // Already connecting, return early
+                return prev;
+            }
+            return true;
+        });
+        // Wait for connection
+        try {
+            await sdk.connect();
+            // Status update will be handled by the subscription
+        }
+        catch (error) {
+            setIsConnecting(false);
+            throw error;
+        }
+    }, [sdk]);
+    // Disconnect
+    const disconnect = (0, react_1.useCallback)(async () => {
+        await sdk.disconnect();
+        setModalOpen(false);
+    }, [sdk]);
+    // Send transaction
+    const sendTransaction = (0, react_1.useCallback)(async (transaction) => {
+        const response = await sdk.sendTransaction(transaction);
+        return {
+            boc: response.boc,
+            signature: response.signature,
+        };
+    }, [sdk]);
+    // Sign data
+    const signData = (0, react_1.useCallback)(async (request) => {
+        const response = await sdk.signData(request.data, request.version);
+        return {
+            signature: response.signature,
+            timestamp: response.timestamp,
+        };
+    }, [sdk]);
+    // Create TonConnectUI instance
+    const tonConnectUI = {
+        openModal,
+        closeModal,
+        connectWallet,
+        disconnect,
+        sendTransaction,
+        signData,
+        wallet: walletState,
+        modalState: {
+            open: modalOpen,
+        },
+        uiVersion: '1.0.0',
+    };
+    const contextValue = {
+        tonConnectUI,
+        sdk,
+    };
+    return react_1.default.createElement(TonConnectUIContext.Provider, { value: contextValue }, children);
+}
+/**
+ * Hook to access TonConnectUI instance
+ * Compatible with @tonconnect/ui-react useTonConnectUI hook
+ */
+function useTonConnectUI() {
+    const context = (0, react_1.useContext)(TonConnectUIContext);
+    if (!context) {
+        throw new Error('useTonConnectUI must be used within TonConnectUIProvider');
+    }
+    return context.tonConnectUI;
+}
+/**
+ * Hook to access wallet state
+ * Compatible with @tonconnect/ui-react useTonWallet hook
+ */
+function useTonWallet() {
+    const tonConnectUI = useTonConnectUI();
+    return tonConnectUI.wallet;
+}
+/**
+ * Hook to access modal state
+ * Compatible with @tonconnect/ui-react useTonConnectModal hook
+ */
+function useTonConnectModal() {
+    const tonConnectUI = useTonConnectUI();
+    return {
+        open: tonConnectUI.modalState.open,
+        close: tonConnectUI.closeModal,
+        openModal: tonConnectUI.openModal,
+    };
+}
+/**
+ * Hook to access SDK instance (for advanced usage)
+ */
+function useTonConnectSDK() {
+    const context = (0, react_1.useContext)(TonConnectUIContext);
+    if (!context) {
+        throw new Error('useTonConnectSDK must be used within TonConnectUIProvider');
+    }
+    return context.sdk;
+}

package/dist/react/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * React integration exports
+ * Re-export all React components and hooks
+ */
+export { TonConnectUIProvider, useTonConnectUI, useTonWallet, useTonConnectModal, useTonConnectSDK, } from './TonConnectUIProvider';
+export type { TonConnectUIProviderProps, TonConnectUI, WalletState, Account, TransactionResponse, SignDataRequest, SignDataResponse, } from './TonConnectUIProvider';
+export { TonConnectButton } from './TonConnectButton';
+export type { TonConnectButtonProps } from './TonConnectButton';

package/dist/react/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * React integration exports
+ * Re-export all React components and hooks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonConnectButton = exports.useTonConnectSDK = exports.useTonConnectModal = exports.useTonWallet = exports.useTonConnectUI = exports.TonConnectUIProvider = void 0;
+var TonConnectUIProvider_1 = require("./TonConnectUIProvider");
+Object.defineProperty(exports, "TonConnectUIProvider", { enumerable: true, get: function () { return TonConnectUIProvider_1.TonConnectUIProvider; } });
+Object.defineProperty(exports, "useTonConnectUI", { enumerable: true, get: function () { return TonConnectUIProvider_1.useTonConnectUI; } });
+Object.defineProperty(exports, "useTonWallet", { enumerable: true, get: function () { return TonConnectUIProvider_1.useTonWallet; } });
+Object.defineProperty(exports, "useTonConnectModal", { enumerable: true, get: function () { return TonConnectUIProvider_1.useTonConnectModal; } });
+Object.defineProperty(exports, "useTonConnectSDK", { enumerable: true, get: function () { return TonConnectUIProvider_1.useTonConnectSDK; } });
+var TonConnectButton_1 = require("./TonConnectButton");
+Object.defineProperty(exports, "TonConnectButton", { enumerable: true, get: function () { return TonConnectButton_1.TonConnectButton; } });

package/dist/types/index.d.ts

@@ -76,7 +76,9 @@ export interface ConnectionRequestPayload {
         name: 'ton_addr';
     }>;
     /** Return strategy - how wallet should return to the app */
-    returnStrategy?: 'back' | 'none';
+    returnStrategy?: 'back' | 'post_redirect' | 'none';
+    /** Return scheme for mobile apps (required by many wallets for proper callback handling) */
+    returnScheme?: string;
 }
 /**
  * Connection response payload (received from wallet)
@@ -133,7 +135,7 @@ export interface TransactionRequestPayload {
     /** Return URL scheme (for mobile apps) */
     returnScheme?: string;
     /** Return strategy */
-    returnStrategy?: 'back' | 'none';
+    returnStrategy?: 'back' | 'post_redirect' | 'none';
 }
 /**
  * Transaction response payload (received from wallet)

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "@blazium/ton-connect-mobile",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Production-ready TON Connect Mobile SDK for React Native and Expo. Implements the real TonConnect protocol for mobile applications using deep links and callbacks.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "default": "./dist/react/index.js"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/blaziumdev/ton-connect-mobile.git"
@@ -31,6 +41,7 @@
     "react-native-get-random-values": "^1.9.0"
   },
   "peerDependencies": {
+    "react": "*",
     "react-native": "*"
   },
   "peerDependenciesMeta": {

package/src/core/protocol.ts

@@ -130,19 +130,25 @@ export function decodeBase64URL<T>(encoded: string): T {
 export function buildConnectionRequest(
   manifestUrl: string,
   returnScheme: string,
-  walletUniversalLink?: string
+  walletUniversalLink?: string,
+  returnStrategy?: 'back' | 'post_redirect' | 'none',
+  requiresReturnScheme?: boolean
 ): string {
-  // TON Connect protocol: payload should only contain manifestUrl, items, and returnStrategy
-  // returnScheme is NOT part of the official protocol payload
-  // For mobile apps, wallets should infer the callback scheme from the manifest or use a default
+  // Build payload with required fields
   const payload: ConnectionRequestPayload = {
     manifestUrl,
     items: [{ name: 'ton_addr' }],
-    returnStrategy: 'back',
-    // NOTE: returnScheme is NOT in the official TON Connect protocol
-    // Wallets should handle mobile app callbacks differently
+    returnStrategy: returnStrategy || 'back',
   };
 
+  // CRITICAL FIX: Many wallets (Tonhub, MyTonWallet, Telegram Wallet) require returnScheme
+  // in the payload to properly handle mobile app callbacks. While not in the official
+  // protocol spec, it's a de-facto requirement for mobile apps.
+  if (requiresReturnScheme !== false) {
+    // Default to true if not specified - safer to include it
+    payload.returnScheme = returnScheme;
+  }
+
   const encoded = encodeBase64URL(payload);
   
   // Use custom wallet universal link if provided
@@ -164,7 +170,9 @@ export function buildTransactionRequest(
   manifestUrl: string,
   request: SendTransactionRequest,
   returnScheme: string,
-  walletUniversalLink?: string
+  walletUniversalLink?: string,
+  returnStrategy?: 'back' | 'post_redirect' | 'none',
+  requiresReturnScheme?: boolean
 ): string {
   const payload: TransactionRequestPayload = {
     manifestUrl,
@@ -179,11 +187,14 @@ export function buildTransactionRequest(
       network: request.network,
       from: request.from,
     },
-    returnStrategy: 'back',
-    // NOTE: returnScheme is NOT in the official TON Connect protocol
-    // Wallets should handle mobile app callbacks differently
+    returnStrategy: returnStrategy || 'back',
   };
 
+  // CRITICAL FIX: Include returnScheme for mobile wallets that require it
+  if (requiresReturnScheme !== false) {
+    payload.returnScheme = returnScheme;
+  }
+
   const encoded = encodeBase64URL(payload);
   
   // Use custom wallet universal link if provided

package/src/core/wallets.ts

@@ -16,6 +16,10 @@ export interface WalletDefinition {
   iconUrl?: string;
   /** Platform support */
   platforms: ('ios' | 'android' | 'web')[];
+  /** Preferred return strategy for this wallet */
+  preferredReturnStrategy?: 'back' | 'post_redirect' | 'none';
+  /** Whether this wallet requires returnScheme in payload */
+  requiresReturnScheme?: boolean;
 }
 
 /**
@@ -28,6 +32,8 @@ export const SUPPORTED_WALLETS: WalletDefinition[] = [
     universalLink: 'https://app.tonkeeper.com/ton-connect',
     deepLink: 'tonkeeper://',
     platforms: ['ios', 'android'],
+    preferredReturnStrategy: 'back',
+    requiresReturnScheme: false, // Tonkeeper can infer from manifest
   },
   {
     name: 'MyTonWallet',
@@ -35,6 +41,8 @@ export const SUPPORTED_WALLETS: WalletDefinition[] = [
     universalLink: 'https://connect.mytonwallet.org',
     deepLink: 'mytonwallet://',
     platforms: ['ios', 'android', 'web'],
+    preferredReturnStrategy: 'post_redirect',
+    requiresReturnScheme: true, // MyTonWallet requires explicit returnScheme
   },
   {
     name: 'Wallet in Telegram',
@@ -42,6 +50,8 @@ export const SUPPORTED_WALLETS: WalletDefinition[] = [
     universalLink: 'https://wallet.tonapi.io/ton-connect',
     deepLink: 'tg://',
     platforms: ['ios', 'android'],
+    preferredReturnStrategy: 'post_redirect',
+    requiresReturnScheme: true, // Telegram Wallet requires explicit returnScheme
   },
   {
     name: 'Tonhub',
@@ -49,6 +59,8 @@ export const SUPPORTED_WALLETS: WalletDefinition[] = [
     universalLink: 'https://tonhub.com/ton-connect',
     deepLink: 'tonhub://',
     platforms: ['ios', 'android'],
+    preferredReturnStrategy: 'post_redirect',
+    requiresReturnScheme: true, // Tonhub requires explicit returnScheme for proper callback
   },
 ];
 

package/src/index.ts

@@ -22,11 +22,13 @@ import {
   validateConnectionResponse,
   validateTransactionRequest,
   validateTransactionResponse,
+  decodeBase64URL,
 } from './core/protocol';
 import type {
   ConnectionResponsePayload,
   TransactionResponsePayload,
   ErrorResponse,
+  ConnectionRequestPayload,
 } from './types';
 import { verifyConnectionProof, generateSessionId } from './core/crypto';
 import { ExpoAdapter } from './adapters/expo';
@@ -99,6 +101,11 @@ export class TonConnectMobile {
     reject: (error: Error) => void;
     timeout: number | null;
   } | null = null;
+  private signDataPromise: {
+    resolve: (response: { signature: string; timestamp: number }) => void;
+    reject: (error: Error) => void;
+    timeout: number | null;
+  } | null = null;
 
   constructor(config: TonConnectMobileConfig) {
     // Validate config
@@ -219,6 +226,41 @@ export class TonConnectMobile {
     const parsed = 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
+      if (parsed.type === 'error' && parsed.data) {
+        const errorData = parsed.data as ErrorResponse;
+        if (errorData?.error) {
+          const promise = this.signDataPromise;
+          this.signDataPromise = null;
+          if (errorData.error.code === 300) {
+            promise.reject(new UserRejectedError());
+          } else {
+            promise.reject(new TonConnectError(errorData.error.message || 'Sign data failed'));
+          }
+          return;
+        }
+      }
+
+      // Check for sign data response format
+      // Note: TON Connect protocol may return sign data in different format
+      // We check for signature field in the response
+      if (parsed.data && typeof parsed.data === 'object') {
+        const data = parsed.data as any;
+        if (data.signature && typeof data.signature === 'string') {
+          const promise = this.signDataPromise;
+          this.signDataPromise = null;
+          promise.resolve({
+            signature: data.signature,
+            timestamp: data.timestamp || Date.now(),
+          });
+          return;
+        }
+      }
+    }
+
+    // Handle connection responses
     if (parsed.type === 'connect' && parsed.data) {
       this.handleConnectionResponse(parsed.data as ConnectionResponsePayload);
     } else if (parsed.type === 'transaction' && parsed.data) {
@@ -349,11 +391,32 @@ export class TonConnectMobile {
     // Build connection request URL (use wallet's universal link)
     console.log('[TON Connect] Building connection request URL for wallet:', this.currentWallet.name);
     console.log('[TON Connect] Using universal link:', this.currentWallet.universalLink);
-    const url = buildConnectionRequest(this.config.manifestUrl, this.config.scheme, this.currentWallet.universalLink);
-    console.log('[TON Connect] Built URL:', url.substring(0, 100) + '...');
+    console.log('[TON Connect] Wallet return strategy:', this.currentWallet.preferredReturnStrategy || 'back');
+    console.log('[TON Connect] Wallet requires returnScheme:', this.currentWallet.requiresReturnScheme !== false);
+    
+    const url = buildConnectionRequest(
+      this.config.manifestUrl,
+      this.config.scheme,
+      this.currentWallet.universalLink,
+      this.currentWallet.preferredReturnStrategy,
+      this.currentWallet.requiresReturnScheme
+    );
     
-    // DEBUG: Log the URL being opened
-    console.log('[TON Connect] Opening URL:', url);
+    // DEBUG: Decode and log the payload for debugging
+    try {
+      const urlParts = url.split('?');
+      if (urlParts.length > 1) {
+        const payload = urlParts[1];
+        const decoded = decodeBase64URL<ConnectionRequestPayload>(payload);
+        console.log('[TON Connect] Connection request payload:', JSON.stringify(decoded, null, 2));
+      }
+    } catch (e) {
+      // Ignore decode errors in logging
+      console.log('[TON Connect] Could not decode payload for logging:', e);
+    }
+    
+    console.log('[TON Connect] Built URL:', url.substring(0, 100) + '...');
+    console.log('[TON Connect] Full URL:', url);
     console.log('[TON Connect] Manifest URL:', this.config.manifestUrl);
     console.log('[TON Connect] Return scheme:', this.config.scheme);
     console.log('[TON Connect] Adapter type:', this.adapter.constructor.name);
@@ -437,7 +500,14 @@ export class TonConnectMobile {
     }
 
     // Build transaction request URL (use universal link for Android compatibility)
-    const url = buildTransactionRequest(this.config.manifestUrl, request, this.config.scheme, this.currentWallet.universalLink);
+    const url = buildTransactionRequest(
+      this.config.manifestUrl,
+      request,
+      this.config.scheme,
+      this.currentWallet.universalLink,
+      this.currentWallet.preferredReturnStrategy,
+      this.currentWallet.requiresReturnScheme
+    );
 
     // Create promise for transaction
     return new Promise<{ boc: string; signature: string }>((resolve, reject) => {
@@ -490,6 +560,156 @@ export class TonConnectMobile {
     });
   }
 
+  /**
+   * Sign data (for authentication, etc.)
+   * Note: Not all wallets support signData. This is a TON Connect extension.
+   */
+  async signData(data: string | Uint8Array, version: string = '1.0'): Promise<{ signature: string; timestamp: number }> {
+    // Check if connected
+    if (!this.currentStatus.connected || !this.currentStatus.wallet) {
+      throw new TonConnectError('Not connected to wallet. Call connect() first.');
+    }
+
+    // Helper function to encode bytes to base64
+    const base64EncodeBytes = (bytes: Uint8Array): string => {
+      const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+      let result = '';
+      let i = 0;
+      
+      while (i < bytes.length) {
+        const a = bytes[i++];
+        const b = i < bytes.length ? bytes[i++] : 0;
+        const c = i < bytes.length ? bytes[i++] : 0;
+        
+        const bitmap = (a << 16) | (b << 8) | c;
+        
+        result += chars.charAt((bitmap >> 18) & 63);
+        result += chars.charAt((bitmap >> 12) & 63);
+        result += i - 2 < bytes.length ? chars.charAt((bitmap >> 6) & 63) : '=';
+        result += i - 1 < bytes.length ? chars.charAt(bitmap & 63) : '=';
+      }
+      
+      return result;
+    };
+
+    // Helper function to get TextEncoder
+    const getTextEncoder = (): { encode(input: string): Uint8Array } => {
+      // eslint-disable-next-line no-undef
+      if (typeof globalThis !== 'undefined' && (globalThis as any).TextEncoder) {
+        // eslint-disable-next-line no-undef
+        return new (globalThis as any).TextEncoder();
+      }
+      // Fallback: manual encoding
+      return {
+        encode(input: string): Uint8Array {
+          const bytes = new Uint8Array(input.length);
+          for (let i = 0; i < input.length; i++) {
+            bytes[i] = input.charCodeAt(i);
+          }
+          return bytes;
+        },
+      };
+    };
+
+    // Convert data to base64
+    let dataBase64: string;
+    if (typeof data === 'string') {
+      // Check if it's already base64
+      const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+      if (base64Regex.test(data) && data.length % 4 === 0) {
+        // Likely base64, use as-is
+        dataBase64 = data;
+      } else {
+        // Not base64, encode it
+        const encoder = getTextEncoder();
+        const bytes = encoder.encode(data);
+        dataBase64 = base64EncodeBytes(bytes);
+      }
+    } else {
+      // Uint8Array - convert to base64
+      dataBase64 = base64EncodeBytes(data);
+    }
+
+    // Build sign data request
+    const payload = {
+      manifestUrl: this.config.manifestUrl,
+      data: dataBase64,
+      version,
+      returnStrategy: this.currentWallet.preferredReturnStrategy || 'back',
+      returnScheme: this.currentWallet.requiresReturnScheme !== false ? this.config.scheme : undefined,
+    };
+
+    // Encode payload
+    const { encodeBase64URL } = require('./core/protocol');
+    const encoded = encodeBase64URL(payload);
+
+    // Build URL
+    const baseUrl = this.currentWallet.universalLink.endsWith('/ton-connect')
+      ? this.currentWallet.universalLink
+      : `${this.currentWallet.universalLink}/ton-connect`;
+    const url = `${baseUrl}/sign-data?${encoded}`;
+
+    // Open wallet app and wait for response
+    return new Promise<{ signature: string; timestamp: number }>((resolve, reject) => {
+      let timeout: number | null = null;
+      let resolved = false;
+
+      // CRITICAL FIX: Check if sign data is already in progress
+      if (this.signDataPromise) {
+        throw new TonConnectError('Sign data request already in progress');
+      }
+
+      // Create promise for sign data
+      const signDataPromise = {
+        resolve: (response: { signature: string; timestamp: number }) => {
+          if (timeout !== null) {
+            clearTimeout(timeout);
+          }
+          resolved = true;
+          if (this.signDataPromise === signDataPromise) {
+            this.signDataPromise = null;
+          }
+          resolve(response);
+        },
+        reject: (error: Error) => {
+          if (timeout !== null) {
+            clearTimeout(timeout);
+          }
+          resolved = true;
+          if (this.signDataPromise === signDataPromise) {
+            this.signDataPromise = null;
+          }
+          reject(error);
+        },
+        timeout: null as number | null,
+      };
+
+      // Set timeout
+      timeout = setTimeout(() => {
+        if (!resolved && this.signDataPromise === signDataPromise) {
+          this.signDataPromise = null;
+          signDataPromise.reject(new TonConnectError('Sign data request timed out'));
+        }
+      }, this.config.transactionTimeout) as unknown as number;
+
+      signDataPromise.timeout = timeout;
+
+      // Store promise for callback handling
+      // CRITICAL FIX: Don't mutate handleCallback method - use a separate tracking mechanism
+      this.signDataPromise = signDataPromise;
+
+      // Open URL
+      this.adapter.openURL(url, this.config.skipCanOpenURLCheck).then(() => {
+        // URL opened, wait for callback
+        // Callback will be handled by handleCallback method checking signDataPromise
+      }).catch((error: Error) => {
+        // Clear promise on error
+        this.signDataPromise = null;
+        signDataPromise.reject(new TonConnectError(`Failed to open wallet: ${error?.message || String(error)}`));
+      });
+    });
+  }
+
   /**
    * Disconnect from wallet
    */
@@ -688,6 +908,7 @@ export class TonConnectMobile {
     this.statusChangeCallbacks.clear();
     this.connectionPromise = null;
     this.transactionPromise = null;
+    this.signDataPromise = null;
   }
 }