@blazium/ton-connect-mobile 1.2.4 → 1.2.6

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * TON Connect Mobile SDK
- * Production-ready implementation for React Native and Expo
+ * Production-ready implementation using TON Connect v2 bridge protocol
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -20,7 +20,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWalletsForPlatform = exports.getDefaultWallet = exports.getWalletByName = exports.SUPPORTED_WALLETS = exports.TonConnectMobile = exports.TransactionInProgressError = exports.ConnectionInProgressError = exports.UserRejectedError = exports.TransactionTimeoutError = exports.ConnectionTimeoutError = exports.TonConnectError = void 0;
 const protocol_1 = require("./core/protocol");
-const crypto_1 = require("./core/crypto");
+const session_1 = require("./core/session");
+const bridge_1 = require("./core/bridge");
 const expo_1 = require("./adapters/expo");
 const react_native_1 = require("./adapters/react-native");
 const web_1 = require("./adapters/web");
@@ -39,623 +40,353 @@ class TonConnectError extends Error {
 exports.TonConnectError = TonConnectError;
 class ConnectionTimeoutError extends TonConnectError {
     constructor() {
-        super('Connection request timed out. The wallet did not respond in time.', 'CONNECTION_TIMEOUT', 'Please make sure the wallet app is installed and try again. If the issue persists, check your internet connection.');
+        super('Connection request timed out. The wallet did not respond in time.', 'CONNECTION_TIMEOUT', 'Make sure the wallet app is installed and try again.');
         this.name = 'ConnectionTimeoutError';
     }
 }
 exports.ConnectionTimeoutError = ConnectionTimeoutError;
 class TransactionTimeoutError extends TonConnectError {
     constructor() {
-        super('Transaction request timed out. The wallet did not respond in time.', 'TRANSACTION_TIMEOUT', 'Please check the wallet app and try again. Make sure you approve or reject the transaction in the wallet.');
+        super('Transaction request timed out.', 'TRANSACTION_TIMEOUT', 'Check the wallet app and try again.');
         this.name = 'TransactionTimeoutError';
     }
 }
 exports.TransactionTimeoutError = TransactionTimeoutError;
 class UserRejectedError extends TonConnectError {
     constructor(message) {
-        super(message || 'User rejected the request', 'USER_REJECTED', 'The user cancelled the operation in the wallet app.');
+        super(message || 'User rejected the request', 'USER_REJECTED');
         this.name = 'UserRejectedError';
     }
 }
 exports.UserRejectedError = UserRejectedError;
 class ConnectionInProgressError extends TonConnectError {
     constructor() {
-        super('Connection request already in progress', 'CONNECTION_IN_PROGRESS', 'Please wait for the current connection attempt to complete before trying again.');
+        super('Connection request already in progress', 'CONNECTION_IN_PROGRESS');
         this.name = 'ConnectionInProgressError';
     }
 }
 exports.ConnectionInProgressError = ConnectionInProgressError;
 class TransactionInProgressError extends TonConnectError {
     constructor() {
-        super('Transaction request already in progress', 'TRANSACTION_IN_PROGRESS', 'Please wait for the current transaction to complete before sending another one.');
+        super('Transaction request already in progress', 'TRANSACTION_IN_PROGRESS');
         this.name = 'TransactionInProgressError';
     }
 }
 exports.TransactionInProgressError = TransactionInProgressError;
 /**
  * Main TON Connect Mobile SDK class
+ * Implements the real TON Connect v2 bridge protocol
  */
 class TonConnectMobile {
     constructor(config) {
         this.statusChangeCallbacks = new Set();
         this.eventListeners = new Map();
         this.currentStatus = { connected: false, wallet: null };
-        this.urlUnsubscribe = null;
+        // TON Connect v2 protocol state
+        this.session = null;
+        this.bridge = new bridge_1.BridgeGateway();
+        this.walletBridgePublicKey = null; // hex wallet public key from bridge
+        // Pending promises
         this.connectionPromise = null;
-        this.transactionPromise = null;
-        this.signDataPromise = null;
-        // Validate config
+        this.pendingRpcRequests = new Map();
+        this.rpcIdCounter = 1;
         if (!config.manifestUrl) {
             throw new TonConnectError('manifestUrl is required');
         }
         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)
+            connectionTimeout: 300000,
+            transactionTimeout: 300000,
+            skipCanOpenURLCheck: true,
             preferredWallet: config.preferredWallet,
             network,
             tonApiEndpoint: config.tonApiEndpoint || defaultTonApiEndpoint,
             ...config,
         };
-        // Determine which wallet to use
+        // Determine wallet
         if (this.config.preferredWallet) {
             const wallet = (0, wallets_1.getWalletByName)(this.config.preferredWallet);
-            if (wallet) {
-                this.currentWallet = wallet;
-                console.log('[TON Connect] Using preferred wallet:', wallet.name);
-            }
-            else {
-                console.warn('[TON Connect] Preferred wallet not found, using default');
-                this.currentWallet = (0, wallets_1.getDefaultWallet)();
-            }
+            this.currentWallet = wallet || (0, wallets_1.getDefaultWallet)();
         }
         else {
             this.currentWallet = (0, wallets_1.getDefaultWallet)();
         }
-        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,
-        });
+        console.log('[TON Connect] Initializing SDK v2 with wallet:', this.currentWallet.name);
+        console.log('[TON Connect] Bridge URL:', this.currentWallet.bridgeUrl);
         // Initialize platform adapter
         this.adapter = this.createAdapter();
-        console.log('[TON Connect] Adapter initialized:', this.adapter.constructor.name);
-        // Set up URL listener
-        this.setupURLListener();
         // Load persisted session
         this.loadSession();
     }
     /**
-     * Create platform adapter based on available modules
+     * Create platform adapter
      */
     createAdapter() {
-        // Check if we're in a web environment
         // eslint-disable-next-line no-undef
         if (typeof globalThis !== 'undefined' && globalThis.window && globalThis.document) {
-            // Web platform
-            console.log('[TON Connect] Using WebAdapter');
             return new web_1.WebAdapter();
         }
-        // Try to detect Expo environment
         try {
-            // Check if expo-linking is available
             if (typeof require !== 'undefined') {
                 const expoLinking = require('expo-linking');
                 if (expoLinking) {
-                    console.log('[TON Connect] Using ExpoAdapter');
                     return new expo_1.ExpoAdapter();
                 }
             }
         }
-        catch (error) {
-            console.log('[TON Connect] ExpoAdapter not available:', error);
-            // expo-linking not available, continue to React Native adapter
+        catch {
+            // Not Expo
         }
-        // Fall back to React Native adapter
-        // This will work for both React Native CLI and Expo (since Expo also has react-native)
-        console.log('[TON Connect] Using ReactNativeAdapter');
         return new react_native_1.ReactNativeAdapter();
     }
     /**
-     * Set up URL listener for wallet callbacks
-     */
-    setupURLListener() {
-        console.log('[TON Connect] Setting up URL listener...');
-        this.urlUnsubscribe = this.adapter.addURLListener((url) => {
-            console.log('[TON Connect] URL callback received:', url);
-            this.handleCallback(url);
-        });
-        // Also check initial URL (when app was opened via deep link)
-        this.adapter.getInitialURL().then((url) => {
-            if (url) {
-                console.log('[TON Connect] Initial URL found:', url);
-                this.handleCallback(url);
-            }
-            else {
-                console.log('[TON Connect] No initial URL');
-            }
-        });
-    }
-    /**
-     * Handle callback from wallet
+     * Handle incoming bridge message from wallet
      */
-    handleCallback(url) {
-        console.log('[TON Connect] handleCallback called with URL:', url);
-        console.log('[TON Connect] Expected scheme:', this.config.scheme);
-        console.log('[TON Connect] URL starts with scheme?', url?.startsWith(`${this.config.scheme}://`));
-        // CRITICAL FIX: Check if URL matches our scheme
-        if (!url || typeof url !== 'string') {
-            console.log('[TON Connect] Invalid URL, ignoring:', url);
+    handleBridgeMessage(msg) {
+        if (!this.session) {
+            console.error('[TON Connect] Received bridge message but no session');
             return;
         }
-        if (!url.startsWith(`${this.config.scheme}://`)) {
-            console.log('[TON Connect] Callback URL does not match scheme, ignoring:', url);
-            console.log('[TON Connect] Expected prefix:', `${this.config.scheme}://`);
-            return;
-        }
-        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)
-        // 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) {
-                    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;
+        try {
+            // Decode base64 encrypted message
+            const encryptedBytes = (0, session_1.base64ToBytes)(msg.message);
+            const senderPublicKey = (0, session_1.hexToBytes)(msg.from);
+            // Decrypt
+            const decrypted = this.session.decrypt(encryptedBytes, senderPublicKey);
+            console.log('[TON Connect] Decrypted bridge message');
+            // Store wallet's bridge public key for future communication
+            this.walletBridgePublicKey = msg.from;
+            // Try to parse as connect response first
+            const connectResult = (0, protocol_1.parseConnectResponse)(decrypted);
+            if (connectResult) {
+                if (connectResult.type === 'connect') {
+                    this.handleConnectSuccess(connectResult.data);
+                }
+                else if (connectResult.type === 'error') {
+                    this.handleConnectError(connectResult.data);
                 }
+                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;
-                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;
+            // Try to parse as RPC response
+            const rpcResult = (0, protocol_1.parseRpcResponse)(decrypted);
+            if (rpcResult) {
+                if (rpcResult.type === 'event' && rpcResult.event === 'disconnect') {
+                    this.handleRemoteDisconnect();
+                }
+                else if (rpcResult.type === 'result') {
+                    this.handleRpcResult(rpcResult.data);
                 }
+                else if (rpcResult.type === 'error') {
+                    this.handleRpcError(rpcResult.data);
+                }
+                return;
             }
+            console.warn('[TON Connect] Unknown bridge message format');
         }
-        // Handle connection responses
-        if (parsed.type === 'connect' && parsed.data) {
-            this.handleConnectionResponse(parsed.data);
-        }
-        else if (parsed.type === 'transaction' && parsed.data) {
-            this.handleTransactionResponse(parsed.data);
+        catch (error) {
+            console.error('[TON Connect] Error handling bridge message:', error);
         }
-        else if (parsed.type === 'error' && parsed.data) {
-            const errorData = parsed.data;
-            if (errorData?.error) {
-                if (errorData.error.code === 300 || errorData.error.message?.toLowerCase().includes('reject')) {
-                    this.rejectWithError(new UserRejectedError());
-                }
-                else {
-                    this.rejectWithError(new TonConnectError(errorData.error.message || 'Unknown error', String(errorData.error.code)));
+    }
+    /**
+     * Handle successful wallet connection
+     */
+    handleConnectSuccess(event) {
+        try {
+            const wallet = (0, protocol_1.extractWalletInfoFromEvent)(event);
+            // Save session for persistence
+            this.saveSession(wallet).catch((err) => {
+                console.error('[TON Connect] Failed to save session:', err);
+            });
+            // Update status
+            this.currentStatus = { connected: true, wallet };
+            this.notifyStatusChange();
+            this.emit('connect', wallet);
+            // Resolve pending connection promise
+            if (this.connectionPromise) {
+                if (this.connectionPromise.timeout) {
+                    clearTimeout(this.connectionPromise.timeout);
                 }
+                const promise = this.connectionPromise;
+                this.connectionPromise = null;
+                promise.resolve(wallet);
             }
         }
+        catch (error) {
+            console.error('[TON Connect] Error processing connect response:', error);
+            this.rejectConnection(new TonConnectError(error?.message || 'Invalid connect response'));
+        }
     }
     /**
-     * Handle connection response from wallet
+     * Handle connect error from wallet
      */
-    handleConnectionResponse(response) {
-        if (!(0, protocol_1.validateConnectionResponse)(response)) {
-            this.rejectWithError(new TonConnectError('Invalid connection response'));
-            return;
-        }
-        // Verify proof if present
-        if (response.proof) {
-            const isValid = (0, crypto_1.verifyConnectionProof)(response, this.config.manifestUrl);
-            if (!isValid) {
-                this.rejectWithError(new TonConnectError('Connection proof verification failed'));
-                return;
-            }
+    handleConnectError(event) {
+        const code = event.payload?.code;
+        const message = event.payload?.message || 'Connection rejected';
+        let error;
+        if (code === 300) {
+            error = new UserRejectedError(message);
         }
         else {
-            // Log warning if proof is missing (security consideration)
-            console.warn('TON Connect: Connection proof missing - wallet may not support proof verification');
-        }
-        const wallet = (0, protocol_1.extractWalletInfo)(response);
-        // Validate session ID before saving
-        if (!this.validateSessionId(response.session)) {
-            this.rejectWithError(new TonConnectError('Invalid session ID format'));
-            return;
+            error = new TonConnectError(message, String(code));
         }
-        // Save session
-        this.saveSession(response.session, wallet).catch((error) => {
-            console.error('TON Connect: Failed to save session:', error);
-            // Continue anyway - connection is still valid
-        });
-        // Update status
-        this.currentStatus = { connected: true, wallet };
+        this.rejectConnection(error);
+    }
+    /**
+     * Handle remote disconnect from wallet
+     */
+    handleRemoteDisconnect() {
+        console.log('[TON Connect] Wallet disconnected remotely');
+        this.currentStatus = { connected: false, wallet: null };
+        this.clearSession().catch(() => { });
         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);
-            }
-            // Store reference before clearing to prevent race conditions
-            const promise = this.connectionPromise;
-            // Clear promise first
-            this.connectionPromise = null;
-            // Then resolve
-            promise.resolve(wallet);
-        }
+        this.emit('disconnect', null);
     }
     /**
-     * Handle transaction response from wallet
+     * Handle RPC success result
      */
-    handleTransactionResponse(response) {
-        if (!(0, protocol_1.validateTransactionResponse)(response)) {
-            this.rejectWithError(new TonConnectError('Invalid transaction response'));
-            return;
+    handleRpcResult(response) {
+        const pending = this.pendingRpcRequests.get(response.id);
+        if (pending) {
+            if (pending.timeout)
+                clearTimeout(pending.timeout);
+            this.pendingRpcRequests.delete(response.id);
+            pending.resolve(response.result);
         }
-        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);
+    }
+    /**
+     * Handle RPC error result
+     */
+    handleRpcError(response) {
+        const pending = this.pendingRpcRequests.get(response.id);
+        if (pending) {
+            if (pending.timeout)
+                clearTimeout(pending.timeout);
+            this.pendingRpcRequests.delete(response.id);
+            let error;
+            if (response.error.code === 300) {
+                error = new UserRejectedError(response.error.message);
             }
-            // Store reference before clearing
-            const promise = this.transactionPromise;
-            // Clear promise first to prevent race conditions
-            this.transactionPromise = null;
-            // Then resolve
-            promise.resolve(transactionResult);
+            else {
+                error = new TonConnectError(response.error.message, String(response.error.code));
+            }
+            pending.reject(error);
         }
     }
     /**
-     * Reject current promise with error
+     * Reject pending connection promise
      */
-    rejectWithError(error) {
-        // Emit error event
+    rejectConnection(error) {
         this.emit('error', error);
         if (this.connectionPromise) {
-            if (this.connectionPromise.timeout !== null) {
+            if (this.connectionPromise.timeout) {
                 clearTimeout(this.connectionPromise.timeout);
             }
-            this.connectionPromise.reject(error);
+            const promise = this.connectionPromise;
             this.connectionPromise = null;
-        }
-        if (this.transactionPromise) {
-            if (this.transactionPromise.timeout !== null) {
-                clearTimeout(this.transactionPromise.timeout);
-            }
-            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;
+            promise.reject(error);
         }
     }
     /**
-     * Connect to wallet
+     * Connect to wallet using TON Connect v2 bridge protocol
      */
     async connect() {
-        console.log('[TON Connect] connect() called');
         // If already connected, return current wallet
         if (this.currentStatus.connected && this.currentStatus.wallet) {
-            console.log('[TON Connect] Already connected, returning existing wallet');
             return this.currentStatus.wallet;
         }
-        // CRITICAL FIX: Check if connection is already in progress
         if (this.connectionPromise) {
-            console.log('[TON Connect] Connection already in progress');
             throw new ConnectionInProgressError();
         }
-        // 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);
-        console.log('[TON Connect] Wallet return strategy:', this.currentWallet.preferredReturnStrategy || 'back');
-        console.log('[TON Connect] Wallet requires returnScheme:', this.currentWallet.requiresReturnScheme !== false);
-        const url = (0, protocol_1.buildConnectionRequest)(this.config.manifestUrl, this.config.scheme, this.currentWallet.universalLink, this.currentWallet.preferredReturnStrategy, this.currentWallet.requiresReturnScheme);
-        // DEBUG: Decode and log the payload for debugging
-        try {
-            const urlParts = url.split('?');
-            if (urlParts.length > 1) {
-                const payload = urlParts[1];
-                // CRITICAL FIX: Handle URL encoding - payload might have additional encoding
-                const cleanPayload = decodeURIComponent(payload);
-                const decoded = (0, protocol_1.decodeBase64URL)(cleanPayload);
-                console.log('[TON Connect] Connection request payload:', JSON.stringify(decoded, null, 2));
-            }
-        }
-        catch (e) {
-            // Log decode errors for debugging but don't fail
-            console.log('[TON Connect] Could not decode payload for logging:', e?.message || e);
-            // This is just for logging, the actual URL is correct
-        }
-        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);
-        // Create promise for connection
+        console.log('[TON Connect] Starting connection to', this.currentWallet.name);
+        // 1. Create new session (X25519 keypair)
+        this.session = new session_1.SessionCrypto();
+        console.log('[TON Connect] Session ID:', this.session.sessionId.substring(0, 16) + '...');
+        // 2. Connect to bridge SSE
+        this.bridge.close(); // Close any existing connection
+        this.bridge.connect(this.currentWallet.bridgeUrl, this.session.sessionId, (msg) => this.handleBridgeMessage(msg), (error) => console.error('[TON Connect] Bridge error:', error));
+        console.log('[TON Connect] Bridge SSE connection initiated');
+        // 3. Build universal link
+        const universalLink = (0, protocol_1.buildConnectUniversalLink)(this.currentWallet.universalLink, this.session.sessionId, this.config.manifestUrl, 'back');
+        console.log('[TON Connect] Universal link built');
+        // 4. Return promise that resolves when wallet responds via bridge
         return new Promise((resolve, reject) => {
-            let timeout = null;
-            this.connectionPromise = {
-                resolve: (wallet) => {
-                    if (timeout !== null) {
-                        clearTimeout(timeout);
-                    }
-                    this.connectionPromise = null;
-                    resolve(wallet);
-                },
-                reject: (error) => {
-                    if (timeout !== null) {
-                        clearTimeout(timeout);
-                    }
-                    this.connectionPromise = null;
-                    reject(error);
-                },
-                timeout: null,
-            };
-            // Set timeout
-            timeout = setTimeout(() => {
+            const timeout = setTimeout(() => {
                 if (this.connectionPromise) {
-                    console.log('[TON Connect] Connection timeout after', this.config.connectionTimeout, 'ms');
-                    this.connectionPromise.reject(new ConnectionTimeoutError());
+                    this.connectionPromise = null;
+                    this.bridge.close();
+                    reject(new ConnectionTimeoutError());
                 }
             }, this.config.connectionTimeout);
-            this.connectionPromise.timeout = timeout;
-            // Open wallet app
-            console.log('[TON Connect] Attempting to open wallet app...');
-            this.adapter.openURL(url, this.config.skipCanOpenURLCheck).then((success) => {
-                console.log('[TON Connect] openURL result:', success);
-                // URL opened successfully, wait for callback
-                // If success is false, it should have thrown an error
+            this.connectionPromise = { resolve, reject, timeout };
+            // 5. Open wallet app
+            console.log('[TON Connect] Opening wallet app...');
+            this.adapter.openURL(universalLink, this.config.skipCanOpenURLCheck).then((success) => {
                 if (!success && this.connectionPromise) {
-                    console.log('[TON Connect] openURL returned false, rejecting promise');
-                    this.connectionPromise.reject(new TonConnectError('Failed to open wallet app. Please make sure a TON wallet is installed.'));
-                }
-                else {
-                    console.log('[TON Connect] URL opened successfully, waiting for wallet callback...');
+                    this.connectionPromise = null;
+                    this.bridge.close();
+                    reject(new TonConnectError('Failed to open wallet app'));
                 }
+                console.log('[TON Connect] Wallet app opened, waiting for bridge response...');
             }).catch((error) => {
-                // Error opening URL - reject the promise
-                console.error('[TON Connect] Error opening URL:', error);
                 if (this.connectionPromise) {
-                    this.connectionPromise.reject(new TonConnectError(`Failed to open wallet: ${error?.message || String(error)}`));
+                    if (this.connectionPromise.timeout)
+                        clearTimeout(this.connectionPromise.timeout);
+                    this.connectionPromise = null;
+                    this.bridge.close();
+                    reject(new TonConnectError(`Failed to open wallet: ${error?.message || String(error)}`));
                 }
             });
         });
     }
     /**
-     * Send transaction
+     * Send transaction via TON Connect v2 bridge protocol
      */
     async sendTransaction(request) {
-        // Validate request
         const validation = (0, protocol_1.validateTransactionRequest)(request);
         if (!validation.valid) {
             throw new TonConnectError(validation.error || 'Invalid transaction request');
         }
-        // Check if connected
         if (!this.currentStatus.connected || !this.currentStatus.wallet) {
             throw new TonConnectError('Not connected to wallet. Call connect() first.');
         }
-        // CRITICAL FIX: Check if transaction is already in progress
-        if (this.transactionPromise) {
-            throw new TransactionInProgressError();
-        }
-        // Build transaction request URL (use universal link for Android compatibility)
-        const url = (0, protocol_1.buildTransactionRequest)(this.config.manifestUrl, request, this.config.scheme, this.currentWallet.universalLink, this.currentWallet.preferredReturnStrategy, this.currentWallet.requiresReturnScheme);
-        // Create promise for transaction
-        return new Promise((resolve, reject) => {
-            let timeout = null;
-            this.transactionPromise = {
-                resolve: (response) => {
-                    if (timeout !== null) {
-                        clearTimeout(timeout);
-                    }
-                    this.transactionPromise = null;
-                    resolve(response);
-                },
-                reject: (error) => {
-                    if (timeout !== null) {
-                        clearTimeout(timeout);
-                    }
-                    this.transactionPromise = null;
-                    reject(error);
-                },
-                timeout: null,
-            };
-            // Set timeout
-            timeout = setTimeout(() => {
-                if (this.transactionPromise) {
-                    this.transactionPromise.reject(new TransactionTimeoutError());
-                }
-            }, this.config.transactionTimeout);
-            this.transactionPromise.timeout = timeout;
-            // Open wallet app
-            this.adapter.openURL(url, this.config.skipCanOpenURLCheck).then((success) => {
-                // URL opened successfully, wait for callback
-                // If success is false, it should have thrown an error
-                if (!success && this.transactionPromise) {
-                    this.transactionPromise.reject(new TonConnectError('Failed to open wallet app. Please make sure a TON wallet is installed.'));
-                }
-            }).catch((error) => {
-                // Error opening URL - reject the promise
-                if (this.transactionPromise) {
-                    this.transactionPromise.reject(new TonConnectError(`Failed to open wallet: ${error?.message || String(error)}`));
-                }
-            });
+        if (!this.session || !this.walletBridgePublicKey) {
+            throw new TonConnectError('Session not established. Please reconnect.');
+        }
+        // Build JSON-RPC request
+        const rpcId = this.rpcIdCounter++;
+        const rpcRequest = (0, protocol_1.buildSendTransactionRpcRequest)(request, rpcId);
+        // Encrypt and send via bridge
+        const walletPubKeyBytes = (0, session_1.hexToBytes)(this.walletBridgePublicKey);
+        const encrypted = this.session.encrypt(rpcRequest, walletPubKeyBytes);
+        await this.bridge.send(this.currentWallet.bridgeUrl, this.session.sessionId, this.walletBridgePublicKey, encrypted);
+        // Open wallet to foreground
+        const returnLink = (0, protocol_1.buildReturnUniversalLink)(this.currentWallet.universalLink, 'back');
+        this.adapter.openURL(returnLink, this.config.skipCanOpenURLCheck).catch(() => {
+            // Non-critical — wallet may already be in foreground
         });
-    }
-    /**
-     * Sign data (for authentication, etc.)
-     * Note: Not all wallets support signData. This is a TON Connect extension.
-     */
-    async signData(data, version = '1.0') {
-        // 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) => {
-            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 = () => {
-            // eslint-disable-next-line no-undef
-            if (typeof globalThis !== 'undefined' && globalThis.TextEncoder) {
-                // eslint-disable-next-line no-undef
-                return new globalThis.TextEncoder();
-            }
-            // Fallback: manual encoding
-            return {
-                encode(input) {
-                    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;
-        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
+        // Wait for response via bridge
         return new Promise((resolve, reject) => {
-            let timeout = 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) => {
-                    if (timeout !== null) {
-                        clearTimeout(timeout);
-                    }
-                    resolved = true;
-                    if (this.signDataPromise === signDataPromise) {
-                        this.signDataPromise = null;
-                    }
-                    resolve(response);
+            const timeout = setTimeout(() => {
+                this.pendingRpcRequests.delete(rpcId);
+                reject(new TransactionTimeoutError());
+            }, this.config.transactionTimeout);
+            this.pendingRpcRequests.set(rpcId, {
+                resolve: (result) => {
+                    this.emit('transaction', { boc: result });
+                    resolve({ boc: result });
                 },
                 reject: (error) => {
-                    if (timeout !== null) {
-                        clearTimeout(timeout);
-                    }
-                    resolved = true;
-                    if (this.signDataPromise === signDataPromise) {
-                        this.signDataPromise = null;
-                    }
+                    this.emit('error', error);
                     reject(error);
                 },
-                timeout: 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);
-            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) => {
-                // Clear promise on error
-                this.signDataPromise = null;
-                signDataPromise.reject(new TonConnectError(`Failed to open wallet: ${error?.message || String(error)}`));
+                timeout,
             });
         });
     }
@@ -663,12 +394,28 @@ class TonConnectMobile {
      * Disconnect from wallet
      */
     async disconnect() {
+        // Send disconnect event via bridge if connected
+        if (this.session && this.walletBridgePublicKey) {
+            try {
+                const rpcId = this.rpcIdCounter++;
+                const disconnectRequest = (0, protocol_1.buildDisconnectRpcRequest)(rpcId);
+                const walletPubKeyBytes = (0, session_1.hexToBytes)(this.walletBridgePublicKey);
+                const encrypted = this.session.encrypt(disconnectRequest, walletPubKeyBytes);
+                await this.bridge.send(this.currentWallet.bridgeUrl, this.session.sessionId, this.walletBridgePublicKey, encrypted);
+            }
+            catch (error) {
+                console.warn('[TON Connect] Failed to send disconnect to wallet:', error);
+            }
+        }
+        // Close bridge
+        this.bridge.close();
         // Clear session
+        this.session = null;
+        this.walletBridgePublicKey = null;
         await this.clearSession();
         // Update status
         this.currentStatus = { connected: false, wallet: null };
         this.notifyStatusChange();
-        // Emit disconnect event
         this.emit('disconnect', null);
     }
     /**
@@ -691,25 +438,15 @@ 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) {
+        if (!wallet)
             return false;
-        }
-        // 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
         // eslint-disable-next-line no-undef
         const platform = typeof globalThis !== 'undefined' && globalThis.Platform
             ? globalThis.Platform.OS === 'ios' ? 'ios' : 'android'
@@ -717,20 +454,12 @@ class TonConnectMobile {
         return wallet.platforms.includes(platform);
     }
     /**
-     * Set preferred wallet for connections
+     * Set preferred wallet
      */
     setPreferredWallet(walletName) {
         const wallet = (0, wallets_1.getWalletByName)(walletName);
         if (!wallet) {
-            throw new TonConnectError(`Wallet "${walletName}" not found. Available wallets: ${wallets_1.SUPPORTED_WALLETS.map(w => w.name).join(', ')}`);
-        }
-        // CRITICAL FIX: Clear any pending connection when wallet changes
-        if (this.connectionPromise) {
-            console.log('[TON Connect] Clearing pending connection due to wallet change');
-            if (this.connectionPromise.timeout !== null) {
-                clearTimeout(this.connectionPromise.timeout);
-            }
-            this.connectionPromise = null;
+            throw new TonConnectError(`Wallet "${walletName}" not found. Available: ${wallets_1.SUPPORTED_WALLETS.map((w) => w.name).join(', ')}`);
         }
         this.currentWallet = wallet;
         console.log('[TON Connect] Preferred wallet changed to:', wallet.name);
@@ -740,32 +469,21 @@ class TonConnectMobile {
      */
     onStatusChange(callback) {
         this.statusChangeCallbacks.add(callback);
-        // Immediately call with current status
         callback(this.getStatus());
-        // Return unsubscribe function
         return () => {
             this.statusChangeCallbacks.delete(callback);
         };
     }
-    /**
-     * Notify all status change callbacks
-     */
     notifyStatusChange() {
         const status = this.getStatus();
-        this.statusChangeCallbacks.forEach((callback) => {
+        this.statusChangeCallbacks.forEach((cb) => {
             try {
-                callback(status);
-            }
-            catch (error) {
-                // Ignore errors in callbacks
+                cb(status);
             }
+            catch { /* ignore */ }
         });
-        // Emit statusChange event
         this.emit('statusChange', status);
     }
-    /**
-     * Emit event to all listeners
-     */
     emit(event, data) {
         const listeners = this.eventListeners.get(event);
         if (listeners) {
@@ -773,40 +491,26 @@ class TonConnectMobile {
                 try {
                     listener(data);
                 }
-                catch (error) {
-                    console.error(`[TON Connect] Error in event listener for ${event}:`, error);
-                }
+                catch { /* ignore */ }
             });
         }
     }
-    /**
-     * 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) {
+            if (listeners)
                 listeners.delete(listener);
-            }
         };
     }
-    /**
-     * Remove event listener
-     */
     off(event, listener) {
         const listeners = this.eventListeners.get(event);
-        if (listeners) {
+        if (listeners)
             listeners.delete(listener);
-        }
     }
-    /**
-     * Remove all listeners for an event
-     */
     removeAllListeners(event) {
         if (event) {
             this.eventListeners.delete(event);
@@ -815,143 +519,35 @@ class TonConnectMobile {
             this.eventListeners.clear();
         }
     }
-    /**
-     * Validate session ID format
-     */
-    validateSessionId(sessionId) {
-        if (!sessionId || typeof sessionId !== 'string') {
-            return false;
-        }
-        // Session ID should be reasonable length (1-200 characters)
-        if (sessionId.length === 0 || sessionId.length > 200) {
-            return false;
-        }
-        // Basic validation: should not contain control characters
-        if (/[\x00-\x1F\x7F]/.test(sessionId)) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Save session to storage
-     */
-    async saveSession(sessionId, wallet) {
-        // Validate inputs
-        if (!this.validateSessionId(sessionId)) {
-            throw new TonConnectError('Invalid session ID format');
-        }
-        if (!wallet || !wallet.address || !wallet.publicKey) {
-            throw new TonConnectError('Invalid wallet data');
-        }
-        try {
-            const sessionKey = `${this.config.storageKeyPrefix}session`;
-            const walletKey = `${this.config.storageKeyPrefix}wallet`;
-            await this.adapter.setItem(sessionKey, sessionId);
-            await this.adapter.setItem(walletKey, JSON.stringify(wallet));
-        }
-        catch (error) {
-            // Log error but don't throw - connection is still valid
-            console.error('TON Connect: Failed to save session to storage:', error);
-        }
-    }
-    /**
-     * Load session from storage
-     */
-    async loadSession() {
-        try {
-            const sessionKey = `${this.config.storageKeyPrefix}session`;
-            const walletKey = `${this.config.storageKeyPrefix}wallet`;
-            const sessionId = await this.adapter.getItem(sessionKey);
-            const walletJson = await this.adapter.getItem(walletKey);
-            if (sessionId && walletJson) {
-                try {
-                    // Validate session ID
-                    if (!this.validateSessionId(sessionId)) {
-                        await this.clearSession();
-                        return;
-                    }
-                    const wallet = JSON.parse(walletJson);
-                    // Validate wallet data
-                    if (!wallet || !wallet.address || !wallet.publicKey) {
-                        await this.clearSession();
-                        return;
-                    }
-                    this.currentStatus = { connected: true, wallet };
-                    this.notifyStatusChange();
-                }
-                catch (error) {
-                    // Invalid wallet data, clear it
-                    console.error('TON Connect: Invalid session data, clearing:', error);
-                    await this.clearSession();
-                }
-            }
-        }
-        catch (error) {
-            // Log storage errors for debugging
-            console.error('TON Connect: Failed to load session from storage:', error);
-        }
-    }
-    /**
-     * Clear session from storage
-     */
-    async clearSession() {
-        try {
-            const sessionKey = `${this.config.storageKeyPrefix}session`;
-            const walletKey = `${this.config.storageKeyPrefix}wallet`;
-            await this.adapter.removeItem(sessionKey);
-            await this.adapter.removeItem(walletKey);
-        }
-        catch (error) {
-            // Ignore storage errors
-        }
-    }
     /**
      * Cleanup resources
      */
     destroy() {
-        if (this.urlUnsubscribe) {
-            this.urlUnsubscribe();
-            this.urlUnsubscribe = null;
-        }
-        if ('destroy' in this.adapter && typeof this.adapter.destroy === 'function') {
-            this.adapter.destroy();
-        }
+        this.bridge.close();
         this.statusChangeCallbacks.clear();
         this.eventListeners.clear();
         this.connectionPromise = null;
-        this.transactionPromise = null;
-        this.signDataPromise = null;
+        this.pendingRpcRequests.forEach((req) => {
+            if (req.timeout)
+                clearTimeout(req.timeout);
+        });
+        this.pendingRpcRequests.clear();
     }
-    /**
-     * 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"');
+            throw new TonConnectError('Network must be "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();
     }
     /**
@@ -960,159 +556,116 @@ class TonConnectMobile {
     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.');
+            throw new TonConnectError('Address required. Connect a wallet or provide an address.');
+        }
+        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}`);
+        }
+        const data = await response.json();
+        if (data.ok === false) {
+            throw new TonConnectError(data.error || 'Failed to fetch balance');
+        }
+        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,
+        };
+    }
+    /**
+     * Get transaction status by hash
+     */
+    async getTransactionStatusByHash(txHash, address) {
+        if (!txHash)
+            throw new TonConnectError('Transaction hash is required');
+        if (!address)
+            throw new TonConnectError('Address is required');
+        const apiEndpoint = this.config.tonApiEndpoint ||
+            (this.config.network === 'testnet'
+                ? 'https://testnet.toncenter.com/api/v2'
+                : 'https://toncenter.com/api/v2');
+        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}`);
         }
-        // Validate address format
-        if (!/^[0-9A-Za-z_-]{48}$/.test(targetAddress)) {
-            throw new TonConnectError('Invalid TON address format');
+        const data = await response.json();
+        if (data.ok === false) {
+            throw new TonConnectError(data.error || 'Failed to fetch transactions');
         }
-        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+$/, '');
+        const transactions = data.result || [];
+        const transaction = transactions.find((tx) => tx.transaction_id?.hash === txHash ||
+            tx.transaction_id?.lt === txHash);
+        if (transaction) {
             return {
-                balance,
-                balanceTon: balanceTon === '0.' ? '0' : balanceTon,
-                network: this.config.network,
+                status: 'confirmed',
+                hash: transaction.transaction_id?.hash || txHash,
+                blockNumber: transaction.transaction_id?.lt,
             };
         }
-        catch (error) {
-            if (error instanceof TonConnectError) {
-                throw error;
-            }
-            throw new TonConnectError(`Failed to get balance: ${error?.message || String(error)}`);
-        }
+        return { status: 'pending', hash: txHash };
     }
-    /**
-     * 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
+    // ─── Session Persistence ───
+    async saveSession(wallet) {
+        if (!this.session || !this.walletBridgePublicKey)
+            return;
+        const sessionData = {
+            sessionSecretKey: (0, session_1.bytesToHex)(this.session.secretKey),
+            walletPublicKey: this.walletBridgePublicKey,
+            bridgeUrl: this.currentWallet.bridgeUrl,
+            wallet,
+        };
+        const key = `${this.config.storageKeyPrefix}session_v2`;
+        await this.adapter.setItem(key, JSON.stringify(sessionData));
+    }
+    async loadSession() {
         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));
-                    }
-                }
+            const key = `${this.config.storageKeyPrefix}session_v2`;
+            const json = await this.adapter.getItem(key);
+            if (!json)
+                return;
+            const data = JSON.parse(json);
+            if (!data.sessionSecretKey || !data.walletPublicKey || !data.wallet) {
+                await this.clearSession();
+                return;
             }
-            return {
-                status: 'failed',
-                error: lastError?.message || 'Failed to check transaction status',
-            };
+            // Restore session
+            this.session = session_1.SessionCrypto.fromState({ secretKey: data.sessionSecretKey });
+            this.walletBridgePublicKey = data.walletPublicKey;
+            // Reconnect to bridge
+            this.bridge.connect(data.bridgeUrl, this.session.sessionId, (msg) => this.handleBridgeMessage(msg), (error) => console.error('[TON Connect] Bridge error:', error));
+            // Restore status
+            this.currentStatus = { connected: true, wallet: data.wallet };
+            this.notifyStatusChange();
+            console.log('[TON Connect] Session restored for wallet:', data.wallet.name);
         }
         catch (error) {
-            throw new TonConnectError(`Failed to get transaction status: ${error?.message || String(error)}`);
+            console.error('[TON Connect] Failed to load session:', error);
+            await this.clearSession();
         }
     }
-    /**
-     * 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');
-        }
+    async clearSession() {
         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,
-            };
+            const key = `${this.config.storageKeyPrefix}session_v2`;
+            await this.adapter.removeItem(key);
         }
-        catch (error) {
-            if (error instanceof TonConnectError) {
-                throw error;
-            }
-            return {
-                status: 'failed',
-                error: error?.message || 'Failed to check transaction status',
-            };
+        catch {
+            // Ignore
         }
     }
 }