@blazium/ton-connect-mobile 1.1.5 → 1.2.1

package/dist/react/WalletSelectionModal.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * WalletSelectionModal component
+ * Provides a beautiful wallet selection UI compatible with @tonconnect/ui-react
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletSelectionModal = WalletSelectionModal;
+const react_1 = __importDefault(require("react"));
+const react_native_1 = require("react-native");
+const index_1 = require("./index");
+/**
+ * WalletSelectionModal - Beautiful wallet selection modal
+ * Compatible with @tonconnect/ui-react modal behavior
+ */
+function WalletSelectionModal({ visible, onClose, wallets: customWallets, style, }) {
+    const tonConnectUI = (0, index_1.useTonConnectUI)();
+    const sdk = (0, index_1.useTonConnectSDK)();
+    const [wallets, setWallets] = react_1.default.useState([]);
+    const [connectingWallet, setConnectingWallet] = react_1.default.useState(null);
+    // Load wallets
+    react_1.default.useEffect(() => {
+        if (customWallets) {
+            setWallets(customWallets);
+        }
+        else {
+            const supportedWallets = sdk.getSupportedWallets();
+            // CRITICAL FIX: On web, show all wallets with universalLink (they can open in new tab)
+            // On mobile, filter by platform
+            const platform = react_native_1.Platform.OS === 'ios' ? 'ios' : react_native_1.Platform.OS === 'android' ? 'android' : 'web';
+            let platformWallets;
+            if (platform === 'web') {
+                // On web, show all wallets with universalLink (they can open in new tab)
+                platformWallets = supportedWallets.filter((w) => w.platforms.includes('web') || !!w.universalLink);
+            }
+            else {
+                platformWallets = supportedWallets.filter((w) => w.platforms.includes(platform));
+            }
+            setWallets(platformWallets);
+        }
+    }, [sdk, customWallets]);
+    // Handle wallet selection
+    const handleSelectWallet = async (wallet) => {
+        // Prevent multiple simultaneous connection attempts
+        if (connectingWallet) {
+            return;
+        }
+        try {
+            setConnectingWallet(wallet.name);
+            // Set preferred wallet
+            try {
+                sdk.setPreferredWallet(wallet.name);
+            }
+            catch (error) {
+                console.error('[WalletSelectionModal] Failed to set preferred wallet:', error);
+                // Continue anyway - SDK will use default wallet
+            }
+            // Close modal
+            onClose();
+            // Small delay to ensure modal closes
+            await new Promise((resolve) => setTimeout(() => resolve(), 100));
+            // Connect
+            await tonConnectUI.connectWallet();
+        }
+        catch (error) {
+            console.error('[WalletSelectionModal] Wallet connection error:', error);
+            setConnectingWallet(null);
+            // Error is handled by SDK/UI, just reset connecting state
+        }
+    };
+    return (react_1.default.createElement(react_native_1.Modal, { visible: visible, animationType: "slide", transparent: true, onRequestClose: onClose },
+        react_1.default.createElement(react_native_1.View, { style: [styles.overlay, style] },
+            react_1.default.createElement(react_native_1.View, { style: styles.modalContainer },
+                react_1.default.createElement(react_native_1.View, { style: styles.header },
+                    react_1.default.createElement(react_native_1.Text, { style: styles.title }, "Connect your TON wallet"),
+                    react_1.default.createElement(react_native_1.Text, { style: styles.subtitle }, "Choose a wallet to connect to this app"),
+                    react_1.default.createElement(react_native_1.TouchableOpacity, { style: styles.closeButton, onPress: onClose },
+                        react_1.default.createElement(react_native_1.Text, { style: styles.closeButtonText }, "\u2715"))),
+                react_1.default.createElement(react_native_1.ScrollView, { style: styles.walletList, showsVerticalScrollIndicator: false }, wallets.length === 0 ? (react_1.default.createElement(react_native_1.View, { style: styles.emptyState },
+                    react_1.default.createElement(react_native_1.Text, { style: styles.emptyStateText }, "No wallets available"),
+                    react_1.default.createElement(react_native_1.Text, { style: styles.emptyStateSubtext }, "Please install a TON wallet app to continue"))) : (wallets.map((wallet) => {
+                    const isConnecting = connectingWallet === wallet.name;
+                    return (react_1.default.createElement(react_native_1.TouchableOpacity, { key: wallet.name, style: [styles.walletItem, isConnecting && styles.walletItemConnecting], onPress: () => handleSelectWallet(wallet), disabled: isConnecting },
+                        react_1.default.createElement(react_native_1.View, { style: styles.walletIconContainer },
+                            react_1.default.createElement(react_native_1.View, { style: styles.walletIconPlaceholder },
+                                react_1.default.createElement(react_native_1.Text, { style: styles.walletIconText }, wallet.name.charAt(0).toUpperCase()))),
+                        react_1.default.createElement(react_native_1.View, { style: styles.walletInfo },
+                            react_1.default.createElement(react_native_1.Text, { style: styles.walletName }, wallet.name),
+                            react_1.default.createElement(react_native_1.Text, { style: styles.walletAppName }, wallet.appName)),
+                        isConnecting && (react_1.default.createElement(react_native_1.View, { style: styles.connectingIndicator },
+                            react_1.default.createElement(react_native_1.Text, { style: styles.connectingText }, "Connecting...")))));
+                }))),
+                react_1.default.createElement(react_native_1.View, { style: styles.footer },
+                    react_1.default.createElement(react_native_1.Text, { style: styles.footerText }, "By connecting, you agree to the app's Terms of Service and Privacy Policy"))))));
+}
+const styles = react_native_1.StyleSheet.create({
+    overlay: {
+        flex: 1,
+        backgroundColor: 'rgba(0, 0, 0, 0.5)',
+        justifyContent: 'flex-end',
+    },
+    modalContainer: {
+        backgroundColor: '#1a1a1a',
+        borderTopLeftRadius: 24,
+        borderTopRightRadius: 24,
+        maxHeight: '85%',
+        paddingBottom: react_native_1.Platform.OS === 'ios' ? 34 : 20,
+    },
+    header: {
+        padding: 24,
+        borderBottomWidth: 1,
+        borderBottomColor: '#2a2a2a',
+        position: 'relative',
+    },
+    title: {
+        fontSize: 28,
+        fontWeight: 'bold',
+        color: '#ffffff',
+        marginBottom: 8,
+    },
+    subtitle: {
+        fontSize: 15,
+        color: '#999999',
+        lineHeight: 20,
+    },
+    closeButton: {
+        position: 'absolute',
+        top: 24,
+        right: 24,
+        width: 32,
+        height: 32,
+        borderRadius: 16,
+        backgroundColor: '#2a2a2a',
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    closeButtonText: {
+        color: '#ffffff',
+        fontSize: 18,
+        fontWeight: '600',
+    },
+    walletList: {
+        padding: 16,
+        maxHeight: 400,
+    },
+    walletItem: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        padding: 16,
+        backgroundColor: '#2a2a2a',
+        borderRadius: 16,
+        marginBottom: 12,
+        minHeight: 72,
+    },
+    walletItemConnecting: {
+        opacity: 0.7,
+    },
+    walletIconContainer: {
+        marginRight: 16,
+    },
+    walletIcon: {
+        width: 48,
+        height: 48,
+        borderRadius: 12,
+    },
+    walletIconPlaceholder: {
+        width: 48,
+        height: 48,
+        borderRadius: 12,
+        backgroundColor: '#3a3a3a',
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    walletIconText: {
+        color: '#ffffff',
+        fontSize: 20,
+        fontWeight: 'bold',
+    },
+    walletInfo: {
+        flex: 1,
+    },
+    walletName: {
+        fontSize: 17,
+        fontWeight: '600',
+        color: '#ffffff',
+        marginBottom: 4,
+    },
+    walletAppName: {
+        fontSize: 14,
+        color: '#999999',
+    },
+    connectingIndicator: {
+        marginLeft: 12,
+    },
+    connectingText: {
+        fontSize: 14,
+        color: '#0088cc',
+        fontWeight: '500',
+    },
+    emptyState: {
+        padding: 40,
+        alignItems: 'center',
+    },
+    emptyStateText: {
+        fontSize: 18,
+        fontWeight: '600',
+        color: '#ffffff',
+        marginBottom: 8,
+    },
+    emptyStateSubtext: {
+        fontSize: 14,
+        color: '#999999',
+        textAlign: 'center',
+    },
+    footer: {
+        padding: 16,
+        borderTopWidth: 1,
+        borderTopColor: '#2a2a2a',
+    },
+    footerText: {
+        fontSize: 12,
+        color: '#666666',
+        textAlign: 'center',
+        lineHeight: 16,
+    },
+});

package/dist/react/index.d.ts

@@ -6,3 +6,5 @@ export { TonConnectUIProvider, useTonConnectUI, useTonWallet, useTonConnectModal
 export type { TonConnectUIProviderProps, TonConnectUI, WalletState, Account, TransactionResponse, SignDataRequest, SignDataResponse, } from './TonConnectUIProvider';
 export { TonConnectButton } from './TonConnectButton';
 export type { TonConnectButtonProps } from './TonConnectButton';
+export { WalletSelectionModal } from './WalletSelectionModal';
+export type { WalletSelectionModalProps } from './WalletSelectionModal';

package/dist/react/index.js

@@ -4,7 +4,7 @@
  * 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;
+exports.WalletSelectionModal = 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; } });
@@ -13,3 +13,5 @@ Object.defineProperty(exports, "useTonConnectModal", { enumerable: true, get: fu
 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; } });
+var WalletSelectionModal_1 = require("./WalletSelectionModal");
+Object.defineProperty(exports, "WalletSelectionModal", { enumerable: true, get: function () { return WalletSelectionModal_1.WalletSelectionModal; } });

package/dist/utils/retry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Retry Utilities
+ * Helper functions for retrying operations with exponential backoff
+ */
+export interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    initialDelay?: number;
+    /** Maximum delay in milliseconds (default: 10000) */
+    maxDelay?: number;
+    /** Multiplier for exponential backoff (default: 2) */
+    multiplier?: number;
+    /** Function to determine if error should be retried (default: retry all errors) */
+    shouldRetry?: (error: Error) => boolean;
+}
+/**
+ * Retry a function with exponential backoff
+ * @param fn - Function to retry
+ * @param options - Retry options
+ * @returns Promise that resolves with the function result
+ */
+export declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Retry with custom delay function
+ * @param fn - Function to retry
+ * @param getDelay - Function that returns delay for each attempt (attempt number, last error)
+ * @param maxAttempts - Maximum number of attempts
+ * @returns Promise that resolves with the function result
+ */
+export declare function retryWithCustomDelay<T>(fn: () => Promise<T>, getDelay: (attempt: number, error: Error | null) => number, maxAttempts?: number): Promise<T>;

package/dist/utils/retry.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Retry Utilities
+ * Helper functions for retrying operations with exponential backoff
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retry = retry;
+exports.retryWithCustomDelay = retryWithCustomDelay;
+/**
+ * Retry a function with exponential backoff
+ * @param fn - Function to retry
+ * @param options - Retry options
+ * @returns Promise that resolves with the function result
+ */
+async function retry(fn, options = {}) {
+    const { maxAttempts = 3, initialDelay = 1000, maxDelay = 10000, multiplier = 2, shouldRetry = () => true, } = options;
+    let lastError = null;
+    let delay = initialDelay;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Don't retry if shouldRetry returns false
+            if (!shouldRetry(lastError)) {
+                throw lastError;
+            }
+            // Don't retry on last attempt
+            if (attempt === maxAttempts) {
+                throw lastError;
+            }
+            // Wait before retrying
+            await new Promise((resolve) => setTimeout(() => resolve(), delay));
+            // Increase delay for next attempt (exponential backoff)
+            delay = Math.min(delay * multiplier, maxDelay);
+        }
+    }
+    // This should never be reached, but TypeScript needs it
+    throw lastError || new Error('Retry failed');
+}
+/**
+ * Retry with custom delay function
+ * @param fn - Function to retry
+ * @param getDelay - Function that returns delay for each attempt (attempt number, last error)
+ * @param maxAttempts - Maximum number of attempts
+ * @returns Promise that resolves with the function result
+ */
+async function retryWithCustomDelay(fn, getDelay, maxAttempts = 3) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Don't retry on last attempt
+            if (attempt === maxAttempts) {
+                throw lastError;
+            }
+            // Wait before retrying
+            const delay = getDelay(attempt, lastError);
+            await new Promise((resolve) => setTimeout(() => resolve(), delay));
+        }
+    }
+    throw lastError || new Error('Retry failed');
+}

package/dist/utils/transactionBuilder.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Transaction Builder Utilities
+ * Helper functions for building TON Connect transaction requests
+ */
+import type { SendTransactionRequest } from '../types';
+/**
+ * Convert TON amount to nanotons
+ * @param tonAmount - Amount in TON (e.g., 1.5 for 1.5 TON)
+ * @returns Amount in nanotons as string
+ */
+export declare function tonToNano(tonAmount: number | string): string;
+/**
+ * Convert nanotons to TON
+ * @param nanotons - Amount in nanotons as string
+ * @returns Amount in TON as number
+ */
+export declare function nanoToTon(nanotons: string): number;
+/**
+ * Build a simple TON transfer transaction
+ * @param to - Recipient address (EQ... format)
+ * @param amount - Amount in TON (will be converted to nanotons)
+ * @param validUntil - Optional expiration timestamp (default: 5 minutes from now)
+ * @returns Transaction request
+ */
+export declare function buildTransferTransaction(to: string, amount: number | string, validUntil?: number): SendTransactionRequest;
+/**
+ * Build a transaction with multiple recipients
+ * @param transfers - Array of {to, amount} transfers
+ * @param validUntil - Optional expiration timestamp (default: 5 minutes from now)
+ * @returns Transaction request
+ */
+export declare function buildMultiTransferTransaction(transfers: Array<{
+    to: string;
+    amount: number | string;
+}>, validUntil?: number): SendTransactionRequest;
+/**
+ * Build a transaction with custom payload
+ * @param to - Recipient address
+ * @param amount - Amount in TON
+ * @param payload - Base64 encoded payload
+ * @param validUntil - Optional expiration timestamp
+ * @returns Transaction request
+ */
+export declare function buildTransactionWithPayload(to: string, amount: number | string, payload: string, validUntil?: number): SendTransactionRequest;
+/**
+ * Build a transaction with state init (for contract deployment)
+ * @param to - Recipient address
+ * @param amount - Amount in TON
+ * @param stateInit - Base64 encoded state init
+ * @param validUntil - Optional expiration timestamp
+ * @returns Transaction request
+ */
+export declare function buildTransactionWithStateInit(to: string, amount: number | string, stateInit: string, validUntil?: number): SendTransactionRequest;
+/**
+ * Validate TON address format
+ * @param address - Address to validate
+ * @returns true if address is valid
+ */
+export declare function isValidTonAddress(address: string): boolean;
+/**
+ * Format TON address for display (with ellipsis)
+ * @param address - Full address
+ * @param startLength - Characters to show at start (default: 6)
+ * @param endLength - Characters to show at end (default: 4)
+ * @returns Formatted address
+ */
+export declare function formatTonAddress(address: string, startLength?: number, endLength?: number): string;

package/dist/utils/transactionBuilder.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Transaction Builder Utilities
+ * Helper functions for building TON Connect transaction requests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tonToNano = tonToNano;
+exports.nanoToTon = nanoToTon;
+exports.buildTransferTransaction = buildTransferTransaction;
+exports.buildMultiTransferTransaction = buildMultiTransferTransaction;
+exports.buildTransactionWithPayload = buildTransactionWithPayload;
+exports.buildTransactionWithStateInit = buildTransactionWithStateInit;
+exports.isValidTonAddress = isValidTonAddress;
+exports.formatTonAddress = formatTonAddress;
+/**
+ * Convert TON amount to nanotons
+ * @param tonAmount - Amount in TON (e.g., 1.5 for 1.5 TON)
+ * @returns Amount in nanotons as string
+ */
+function tonToNano(tonAmount) {
+    const amount = typeof tonAmount === 'string' ? parseFloat(tonAmount) : tonAmount;
+    if (isNaN(amount) || amount < 0) {
+        throw new Error('Invalid TON amount');
+    }
+    const nanotons = Math.floor(amount * 1000000000);
+    return nanotons.toString();
+}
+/**
+ * Convert nanotons to TON
+ * @param nanotons - Amount in nanotons as string
+ * @returns Amount in TON as number
+ */
+function nanoToTon(nanotons) {
+    const nano = BigInt(nanotons);
+    return Number(nano) / 1000000000;
+}
+/**
+ * Build a simple TON transfer transaction
+ * @param to - Recipient address (EQ... format)
+ * @param amount - Amount in TON (will be converted to nanotons)
+ * @param validUntil - Optional expiration timestamp (default: 5 minutes from now)
+ * @returns Transaction request
+ */
+function buildTransferTransaction(to, amount, validUntil) {
+    // Validate address
+    if (!to || typeof to !== 'string') {
+        throw new Error('Recipient address is required');
+    }
+    if (!isValidTonAddress(to)) {
+        throw new Error(`Invalid TON address format: ${to}`);
+    }
+    // Validate amount
+    const nanoAmount = tonToNano(amount);
+    if (BigInt(nanoAmount) <= 0n) {
+        throw new Error('Transaction amount must be greater than 0');
+    }
+    // Validate validUntil
+    const expiration = validUntil || Date.now() + 5 * 60 * 1000; // 5 minutes default
+    if (expiration <= Date.now()) {
+        throw new Error('Transaction expiration must be in the future');
+    }
+    return {
+        validUntil: expiration,
+        messages: [
+            {
+                address: to,
+                amount: nanoAmount,
+            },
+        ],
+    };
+}
+/**
+ * Build a transaction with multiple recipients
+ * @param transfers - Array of {to, amount} transfers
+ * @param validUntil - Optional expiration timestamp (default: 5 minutes from now)
+ * @returns Transaction request
+ */
+function buildMultiTransferTransaction(transfers, validUntil) {
+    // Validate transfers array
+    if (!transfers || !Array.isArray(transfers) || transfers.length === 0) {
+        throw new Error('Transfers array is required and cannot be empty');
+    }
+    if (transfers.length > 255) {
+        throw new Error('Maximum 255 transfers allowed per transaction');
+    }
+    // Validate each transfer
+    const messages = transfers.map((transfer, index) => {
+        if (!transfer.to || typeof transfer.to !== 'string') {
+            throw new Error(`Transfer ${index + 1}: Recipient address is required`);
+        }
+        if (!isValidTonAddress(transfer.to)) {
+            throw new Error(`Transfer ${index + 1}: Invalid TON address format: ${transfer.to}`);
+        }
+        const nanoAmount = tonToNano(transfer.amount);
+        if (BigInt(nanoAmount) <= 0n) {
+            throw new Error(`Transfer ${index + 1}: Amount must be greater than 0`);
+        }
+        return {
+            address: transfer.to,
+            amount: nanoAmount,
+        };
+    });
+    // Validate validUntil
+    const expiration = validUntil || Date.now() + 5 * 60 * 1000;
+    if (expiration <= Date.now()) {
+        throw new Error('Transaction expiration must be in the future');
+    }
+    return {
+        validUntil: expiration,
+        messages,
+    };
+}
+/**
+ * Build a transaction with custom payload
+ * @param to - Recipient address
+ * @param amount - Amount in TON
+ * @param payload - Base64 encoded payload
+ * @param validUntil - Optional expiration timestamp
+ * @returns Transaction request
+ */
+function buildTransactionWithPayload(to, amount, payload, validUntil) {
+    return {
+        validUntil: validUntil || Date.now() + 5 * 60 * 1000,
+        messages: [
+            {
+                address: to,
+                amount: tonToNano(amount),
+                payload,
+            },
+        ],
+    };
+}
+/**
+ * Build a transaction with state init (for contract deployment)
+ * @param to - Recipient address
+ * @param amount - Amount in TON
+ * @param stateInit - Base64 encoded state init
+ * @param validUntil - Optional expiration timestamp
+ * @returns Transaction request
+ */
+function buildTransactionWithStateInit(to, amount, stateInit, validUntil) {
+    return {
+        validUntil: validUntil || Date.now() + 5 * 60 * 1000,
+        messages: [
+            {
+                address: to,
+                amount: tonToNano(amount),
+                stateInit,
+            },
+        ],
+    };
+}
+/**
+ * Validate TON address format
+ * @param address - Address to validate
+ * @returns true if address is valid
+ */
+function isValidTonAddress(address) {
+    // TON addresses start with EQ or 0Q and are 48 characters long (base64)
+    return /^(EQ|0Q)[A-Za-z0-9_-]{46}$/.test(address);
+}
+/**
+ * Format TON address for display (with ellipsis)
+ * @param address - Full address
+ * @param startLength - Characters to show at start (default: 6)
+ * @param endLength - Characters to show at end (default: 4)
+ * @returns Formatted address
+ */
+function formatTonAddress(address, startLength = 6, endLength = 4) {
+    if (address.length <= startLength + endLength) {
+        return address;
+    }
+    return `${address.substring(0, startLength)}...${address.substring(address.length - endLength)}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blazium/ton-connect-mobile",
-  "version": "1.1.5",
+  "version": "1.2.1",
   "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",

package/src/adapters/expo.ts

@@ -78,14 +78,14 @@ export class ExpoAdapter implements PlatformAdapter {
         console.log('[ExpoAdapter] Skipping canOpenURL check (Android compatibility)');
       }
       
-      // CRITICAL FIX: Android'de canOpenURL() tonconnect:// protokolünü tanımayabilir
-      // Bu yüzden direkt openURL() çağırıyoruz. Eğer açılamazsa hata fırlatır.
+      // CRITICAL FIX: On Android, canOpenURL() may not recognize tonconnect:// protocol
+      // So we call openURL() directly. If it fails, it will throw an error.
       await Linking.openURL(url);
       console.log('[ExpoAdapter] URL opened successfully');
       return true;
     } catch (error: any) {
       console.error('[ExpoAdapter] Error in openURL:', error);
-      // Android'de tonconnect:// protokolü tanınmıyorsa veya cüzdan yüklü değilse hata verir
+      // On Android, if tonconnect:// protocol is not recognized or wallet is not installed, it will throw an error
       const errorMessage = error?.message || String(error);
       if (errorMessage.includes('No Activity found') || errorMessage.includes('No app found') || errorMessage.includes('Cannot open URL')) {
         throw new Error(

package/src/adapters/react-native.ts

@@ -67,14 +67,14 @@ export class ReactNativeAdapter implements PlatformAdapter {
         console.log('[ReactNativeAdapter] Skipping canOpenURL check (Android compatibility)');
       }
       
-      // CRITICAL FIX: Android'de canOpenURL() tonconnect:// protokolünü tanımayabilir
-      // Bu yüzden direkt openURL() çağırıyoruz. Eğer açılamazsa hata fırlatır.
+      // CRITICAL FIX: On Android, canOpenURL() may not recognize tonconnect:// protocol
+      // So we call openURL() directly. If it fails, it will throw an error.
       await Linking.openURL(url);
       console.log('[ReactNativeAdapter] URL opened successfully');
       return true;
     } catch (error: any) {
       console.error('[ReactNativeAdapter] Error in openURL:', error);
-      // Android'de tonconnect:// protokolü tanınmıyorsa veya cüzdan yüklü değilse hata verir
+      // On Android, if tonconnect:// protocol is not recognized or wallet is not installed, it will throw an error
       const errorMessage = error?.message || String(error);
       if (errorMessage.includes('No Activity found') || errorMessage.includes('No app found') || errorMessage.includes('Cannot open URL')) {
         throw new Error(