@blazium/ton-connect-mobile 1.2.5 → 1.2.6

package/dist/core/session.js

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * Session crypto for TON Connect v2 protocol
+ * Uses X25519 (NaCl box) for key exchange and message encryption
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionCrypto = void 0;
+exports.bytesToHex = bytesToHex;
+exports.hexToBytes = hexToBytes;
+exports.bytesToBase64 = bytesToBase64;
+exports.base64ToBytes = base64ToBytes;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const nacl = require('tweetnacl');
+/**
+ * Convert Uint8Array to hex string
+ */
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * Convert hex string to Uint8Array
+ */
+function hexToBytes(hex) {
+    const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
+    const padded = clean.length % 2 === 0 ? clean : '0' + clean;
+    const bytes = new Uint8Array(padded.length / 2);
+    for (let i = 0; i < padded.length; i += 2) {
+        bytes[i / 2] = parseInt(padded.substring(i, i + 2), 16);
+    }
+    return bytes;
+}
+/**
+ * Convert Uint8Array to base64
+ */
+function bytesToBase64(bytes) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    let result = '';
+    const len = bytes.length;
+    for (let i = 0; i < len; i += 3) {
+        const a = bytes[i];
+        const b = i + 1 < len ? bytes[i + 1] : 0;
+        const c = i + 2 < len ? bytes[i + 2] : 0;
+        const bitmap = (a << 16) | (b << 8) | c;
+        result += chars.charAt((bitmap >> 18) & 63);
+        result += chars.charAt((bitmap >> 12) & 63);
+        result += i + 1 < len ? chars.charAt((bitmap >> 6) & 63) : '=';
+        result += i + 2 < len ? chars.charAt(bitmap & 63) : '=';
+    }
+    return result;
+}
+/**
+ * Convert base64 to Uint8Array
+ */
+function base64ToBytes(base64) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const bytes = [];
+    let buffer = 0;
+    let bitsCollected = 0;
+    for (let i = 0; i < base64.length; i++) {
+        const ch = base64[i];
+        if (ch === '=')
+            break;
+        // Also handle URL-safe base64
+        let index;
+        if (ch === '-') {
+            index = 62;
+        }
+        else if (ch === '_') {
+            index = 63;
+        }
+        else {
+            index = chars.indexOf(ch);
+        }
+        if (index === -1)
+            continue;
+        buffer = (buffer << 6) | index;
+        bitsCollected += 6;
+        if (bitsCollected >= 8) {
+            bitsCollected -= 8;
+            bytes.push((buffer >> bitsCollected) & 0xff);
+            buffer &= (1 << bitsCollected) - 1;
+        }
+    }
+    return new Uint8Array(bytes);
+}
+/**
+ * Session crypto for TON Connect v2
+ * Handles X25519 key exchange and NaCl box encryption/decryption
+ */
+class SessionCrypto {
+    constructor(existingSecretKey) {
+        if (existingSecretKey) {
+            this.keypair = nacl.box.keyPair.fromSecretKey(existingSecretKey);
+        }
+        else {
+            this.keypair = nacl.box.keyPair();
+        }
+    }
+    /**
+     * Session ID = hex-encoded public key (used as client_id in bridge)
+     */
+    get sessionId() {
+        return bytesToHex(this.keypair.publicKey);
+    }
+    /**
+     * Public key bytes
+     */
+    get publicKey() {
+        return this.keypair.publicKey;
+    }
+    /**
+     * Secret key bytes (for persistence)
+     */
+    get secretKey() {
+        return this.keypair.secretKey;
+    }
+    /**
+     * Encrypt a message for a recipient
+     * Format: nonce (24 bytes) + ciphertext
+     */
+    encrypt(message, receiverPublicKey) {
+        const msgBytes = encodeUTF8(message);
+        const nonce = nacl.randomBytes(nacl.box.nonceLength); // 24 bytes
+        const encrypted = nacl.box(msgBytes, nonce, receiverPublicKey, this.keypair.secretKey);
+        if (!encrypted) {
+            throw new Error('Encryption failed');
+        }
+        // Prepend nonce to ciphertext
+        const result = new Uint8Array(nonce.length + encrypted.length);
+        result.set(nonce);
+        result.set(encrypted, nonce.length);
+        return result;
+    }
+    /**
+     * Decrypt a message from a sender
+     * Input format: nonce (24 bytes) + ciphertext
+     */
+    decrypt(encryptedMessage, senderPublicKey) {
+        if (encryptedMessage.length < nacl.box.nonceLength) {
+            throw new Error('Encrypted message too short');
+        }
+        const nonce = encryptedMessage.slice(0, nacl.box.nonceLength);
+        const ciphertext = encryptedMessage.slice(nacl.box.nonceLength);
+        const decrypted = nacl.box.open(ciphertext, nonce, senderPublicKey, this.keypair.secretKey);
+        if (!decrypted) {
+            throw new Error('Decryption failed — invalid key or corrupted message');
+        }
+        return decodeUTF8(decrypted);
+    }
+    /**
+     * Serialize session for persistence
+     */
+    serialize() {
+        return {
+            secretKey: bytesToHex(this.keypair.secretKey),
+        };
+    }
+    /**
+     * Restore session from persisted state
+     */
+    static fromState(state) {
+        return new SessionCrypto(hexToBytes(state.secretKey));
+    }
+}
+exports.SessionCrypto = SessionCrypto;
+/**
+ * Encode string to UTF-8 Uint8Array
+ */
+function encodeUTF8(str) {
+    // eslint-disable-next-line no-undef
+    if (typeof globalThis !== 'undefined' && globalThis.TextEncoder) {
+        // eslint-disable-next-line no-undef
+        return new globalThis.TextEncoder().encode(str);
+    }
+    // Fallback for older environments
+    const bytes = [];
+    for (let i = 0; i < str.length; i++) {
+        let charCode = str.charCodeAt(i);
+        if (charCode < 0x80) {
+            bytes.push(charCode);
+        }
+        else if (charCode < 0x800) {
+            bytes.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f));
+        }
+        else if (charCode >= 0xd800 && charCode < 0xdc00) {
+            // Surrogate pair
+            i++;
+            const low = str.charCodeAt(i);
+            charCode = ((charCode - 0xd800) << 10) + (low - 0xdc00) + 0x10000;
+            bytes.push(0xf0 | (charCode >> 18), 0x80 | ((charCode >> 12) & 0x3f), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));
+        }
+        else {
+            bytes.push(0xe0 | (charCode >> 12), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));
+        }
+    }
+    return new Uint8Array(bytes);
+}
+/**
+ * Decode UTF-8 Uint8Array to string
+ */
+function decodeUTF8(bytes) {
+    // eslint-disable-next-line no-undef
+    if (typeof globalThis !== 'undefined' && globalThis.TextDecoder) {
+        // eslint-disable-next-line no-undef
+        return new globalThis.TextDecoder().decode(bytes);
+    }
+    // Fallback
+    let result = '';
+    let i = 0;
+    while (i < bytes.length) {
+        const byte = bytes[i];
+        if (byte < 0x80) {
+            result += String.fromCharCode(byte);
+            i++;
+        }
+        else if ((byte & 0xe0) === 0xc0) {
+            result += String.fromCharCode(((byte & 0x1f) << 6) | (bytes[i + 1] & 0x3f));
+            i += 2;
+        }
+        else if ((byte & 0xf0) === 0xe0) {
+            result += String.fromCharCode(((byte & 0x0f) << 12) | ((bytes[i + 1] & 0x3f) << 6) | (bytes[i + 2] & 0x3f));
+            i += 3;
+        }
+        else {
+            const codePoint = ((byte & 0x07) << 18) | ((bytes[i + 1] & 0x3f) << 12) | ((bytes[i + 2] & 0x3f) << 6) | (bytes[i + 3] & 0x3f);
+            // Convert to surrogate pair
+            const offset = codePoint - 0x10000;
+            result += String.fromCharCode(0xd800 + (offset >> 10), 0xdc00 + (offset & 0x3ff));
+            i += 4;
+        }
+    }
+    return result;
+}

package/dist/core/wallets.d.ts

@@ -1,27 +1,27 @@
 /**
  * TON Connect compatible wallet definitions
- * Each wallet has its own universal link format
+ * Each wallet has its own universal link and bridge URL
+ * Data sourced from official https://github.com/ton-connect/wallets-list
  */
 export interface WalletDefinition {
     /** Wallet name for display */
     name: string;
-    /** Wallet app name */
+    /** Wallet app name (identifier) */
     appName: string;
     /** Universal link base URL for this wallet */
     universalLink: string;
+    /** HTTP Bridge URL for SSE communication */
+    bridgeUrl: string;
     /** Deep link scheme (if supported) */
     deepLink?: string;
     /** Wallet icon URL (optional) */
     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;
 }
 /**
  * List of supported TON Connect wallets
+ * Bridge URLs from official wallets-v2.json
  */
 export declare const SUPPORTED_WALLETS: WalletDefinition[];
 /**

package/dist/core/wallets.js

@@ -1,7 +1,8 @@
 "use strict";
 /**
  * TON Connect compatible wallet definitions
- * Each wallet has its own universal link format
+ * Each wallet has its own universal link and bridge URL
+ * Data sourced from official https://github.com/ton-connect/wallets-list
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SUPPORTED_WALLETS = void 0;
@@ -10,54 +11,52 @@ exports.getDefaultWallet = getDefaultWallet;
 exports.getWalletsForPlatform = getWalletsForPlatform;
 /**
  * List of supported TON Connect wallets
+ * Bridge URLs from official wallets-v2.json
  */
 exports.SUPPORTED_WALLETS = [
     {
         name: 'Tonkeeper',
-        appName: 'Tonkeeper',
+        appName: 'tonkeeper',
         universalLink: 'https://app.tonkeeper.com/ton-connect',
-        deepLink: 'tonkeeper://',
+        bridgeUrl: 'https://bridge.tonapi.io/bridge',
+        deepLink: 'tonkeeper-tc://',
         iconUrl: 'https://tonkeeper.com/assets/tonconnect-icon.png',
-        platforms: ['ios', 'android', 'web'], // CRITICAL FIX: Tonkeeper Web is supported
-        preferredReturnStrategy: 'post_redirect', // CRITICAL FIX: 'back' strategy may not send callback properly, use 'post_redirect'
-        requiresReturnScheme: true, // CRITICAL FIX: Mobile apps need returnScheme for proper callback handling
+        platforms: ['ios', 'android', 'web'],
     },
     {
         name: 'MyTonWallet',
-        appName: 'MyTonWallet',
+        appName: 'mytonwallet',
         universalLink: 'https://connect.mytonwallet.org',
-        deepLink: 'mytonwallet://',
+        bridgeUrl: 'https://tonconnectbridge.mytonwallet.org/bridge/',
+        deepLink: 'mytonwallet-tc://',
         iconUrl: 'https://static.mytonwallet.io/icon-256.png',
         platforms: ['ios', 'android', 'web'],
-        preferredReturnStrategy: 'post_redirect',
-        requiresReturnScheme: true, // MyTonWallet requires explicit returnScheme
     },
     {
         name: 'Wallet in Telegram',
-        appName: 'Wallet',
-        universalLink: 'https://wallet.tg/ton-connect',
+        appName: 'telegram-wallet',
+        universalLink: 'https://t.me/wallet?attach=wallet',
+        bridgeUrl: 'https://walletbot.me/tonconnect-bridge/bridge',
         deepLink: 'tg://',
         iconUrl: 'https://wallet.tg/images/logo-288.png',
         platforms: ['ios', 'android'],
-        preferredReturnStrategy: 'post_redirect',
-        requiresReturnScheme: true, // Telegram Wallet requires explicit returnScheme
     },
     {
         name: 'Tonhub',
-        appName: 'Tonhub',
+        appName: 'tonhub',
         universalLink: 'https://tonhub.com/ton-connect',
+        bridgeUrl: 'https://connect.tonhubapi.com/tonconnect',
         deepLink: 'tonhub://',
         iconUrl: 'https://tonhub.com/tonconnect_logo.png',
         platforms: ['ios', 'android'],
-        preferredReturnStrategy: 'post_redirect',
-        requiresReturnScheme: true, // Tonhub requires explicit returnScheme for proper callback
     },
 ];
 /**
  * Get wallet definition by name
  */
 function getWalletByName(name) {
-    return exports.SUPPORTED_WALLETS.find((wallet) => wallet.name.toLowerCase() === name.toLowerCase() || wallet.appName.toLowerCase() === name.toLowerCase());
+    return exports.SUPPORTED_WALLETS.find((wallet) => wallet.name.toLowerCase() === name.toLowerCase() ||
+        wallet.appName.toLowerCase() === name.toLowerCase());
 }
 /**
  * Get default wallet (Tonkeeper)

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * TON Connect Mobile SDK
- * Production-ready implementation for React Native and Expo
+ * Production-ready implementation using TON Connect v2 bridge protocol
  */
 import { TonConnectMobileConfig, ConnectionStatus, WalletInfo, SendTransactionRequest, StatusChangeCallback, Network, TonConnectEventType, TonConnectEventListener, TransactionStatusResponse, BalanceResponse } from './types';
 import { type WalletDefinition } from './core/wallets';
@@ -29,6 +29,7 @@ export declare class TransactionInProgressError extends TonConnectError {
 }
 /**
  * Main TON Connect Mobile SDK class
+ * Implements the real TON Connect v2 bridge protocol
  */
 export declare class TonConnectMobile {
     private adapter;
@@ -36,54 +37,55 @@ export declare class TonConnectMobile {
     private statusChangeCallbacks;
     private eventListeners;
     private currentStatus;
-    private urlUnsubscribe;
     private currentWallet;
+    private session;
+    private bridge;
+    private walletBridgePublicKey;
     private connectionPromise;
-    private transactionPromise;
-    private signDataPromise;
+    private pendingRpcRequests;
+    private rpcIdCounter;
     constructor(config: TonConnectMobileConfig);
     /**
-     * Create platform adapter based on available modules
+     * Create platform adapter
      */
     private createAdapter;
     /**
-     * Set up URL listener for wallet callbacks
+     * Handle incoming bridge message from wallet
      */
-    private setupURLListener;
+    private handleBridgeMessage;
     /**
-     * Handle callback from wallet
+     * Handle successful wallet connection
      */
-    private handleCallback;
+    private handleConnectSuccess;
     /**
-     * Handle connection response from wallet
+     * Handle connect error from wallet
      */
-    private handleConnectionResponse;
+    private handleConnectError;
     /**
-     * Handle transaction response from wallet
+     * Handle remote disconnect from wallet
      */
-    private handleTransactionResponse;
+    private handleRemoteDisconnect;
     /**
-     * Reject current promise with error
+     * Handle RPC success result
      */
-    private rejectWithError;
+    private handleRpcResult;
     /**
-     * Connect to wallet
+     * Handle RPC error result
+     */
+    private handleRpcError;
+    /**
+     * Reject pending connection promise
+     */
+    private rejectConnection;
+    /**
+     * Connect to wallet using TON Connect v2 bridge protocol
      */
     connect(): Promise<WalletInfo>;
     /**
-     * Send transaction
+     * Send transaction via TON Connect v2 bridge protocol
      */
     sendTransaction(request: SendTransactionRequest): Promise<{
         boc: string;
-        signature: string;
-    }>;
-    /**
-     * Sign data (for authentication, etc.)
-     * Note: Not all wallets support signData. This is a TON Connect extension.
-     */
-    signData(data: string | Uint8Array, version?: string): Promise<{
-        signature: string;
-        timestamp: number;
     }>;
     /**
      * Disconnect from wallet
@@ -103,79 +105,38 @@ export declare class TonConnectMobile {
     getCurrentWallet(): WalletDefinition;
     /**
      * Check if a wallet is available on the current platform
-     * Note: This is a best-effort check and may not be 100% accurate
-     * CRITICAL FIX: On web, if wallet has universalLink, it's considered available
-     * because universal links can open in new tabs/windows
      */
     isWalletAvailable(walletName?: string): Promise<boolean>;
     /**
-     * Set preferred wallet for connections
+     * Set preferred wallet
      */
     setPreferredWallet(walletName: string): void;
     /**
      * Subscribe to status changes
      */
     onStatusChange(callback: StatusChangeCallback): () => void;
-    /**
-     * Notify all status change callbacks
-     */
     private notifyStatusChange;
-    /**
-     * Emit event to all listeners
-     */
     private emit;
-    /**
-     * Add event listener
-     */
     on<T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>): () => void;
-    /**
-     * Remove event listener
-     */
     off<T = any>(event: TonConnectEventType, listener: TonConnectEventListener<T>): void;
-    /**
-     * Remove all listeners for an event
-     */
     removeAllListeners(event?: TonConnectEventType): void;
-    /**
-     * Validate session ID format
-     */
-    private validateSessionId;
-    /**
-     * Save session to storage
-     */
-    private saveSession;
-    /**
-     * Load session from storage
-     */
-    private loadSession;
-    /**
-     * Clear session from storage
-     */
-    private clearSession;
     /**
      * Cleanup resources
      */
     destroy(): void;
-    /**
-     * Get current network
-     */
     getNetwork(): Network;
-    /**
-     * Set network (mainnet/testnet)
-     */
     setNetwork(network: Network): void;
     /**
      * Get wallet balance
      */
     getBalance(address?: string): Promise<BalanceResponse>;
     /**
-     * Get transaction status
-     */
-    getTransactionStatus(boc: string, maxAttempts?: number, intervalMs?: number): Promise<TransactionStatusResponse>;
-    /**
-     * Get transaction status by hash (more reliable than BOC)
+     * Get transaction status by hash
      */
     getTransactionStatusByHash(txHash: string, address: string): Promise<TransactionStatusResponse>;
+    private saveSession;
+    private loadSession;
+    private clearSession;
 }
 export * from './types';
 export type { WalletDefinition } from './core/wallets';