@blazium/ton-connect-mobile 1.1.1 → 1.1.3

package/dist/core/protocol.d.ts

@@ -17,14 +17,14 @@ export declare function decodeBase64URL<T>(encoded: string): T;
  * Or universal link: https://app.tonkeeper.com/ton-connect?<base64_encoded_payload>
  * Or custom wallet universal link
  */
-export declare function buildConnectionRequest(manifestUrl: string, returnScheme: string, walletUniversalLink?: string): string;
+export declare function buildConnectionRequest(manifestUrl: string, returnScheme: string, walletUniversalLink?: string, returnStrategy?: 'back' | 'post_redirect' | 'none', requiresReturnScheme?: boolean): string;
 /**
  * Build transaction request URL
  * Format: tonconnect://send-transaction?<base64_encoded_payload>
  * Or universal link: https://app.tonkeeper.com/ton-connect/send-transaction?<base64_encoded_payload>
  * Or custom wallet universal link
  */
-export declare function buildTransactionRequest(manifestUrl: string, request: SendTransactionRequest, returnScheme: string, walletUniversalLink?: string): string;
+export declare function buildTransactionRequest(manifestUrl: string, request: SendTransactionRequest, returnScheme: string, walletUniversalLink?: string, returnStrategy?: 'back' | 'post_redirect' | 'none', requiresReturnScheme?: boolean): string;
 /**
  * Parse callback URL
  * Format: <scheme>://tonconnect?<base64_encoded_response>

package/dist/core/protocol.js

@@ -105,17 +105,20 @@ function decodeBase64URL(encoded) {
  * Or universal link: https://app.tonkeeper.com/ton-connect?<base64_encoded_payload>
  * Or custom wallet universal link
  */
-function buildConnectionRequest(manifestUrl, returnScheme, walletUniversalLink) {
-    // TON Connect protocol: payload should only contain manifestUrl, items, and returnStrategy
-    // returnScheme is NOT part of the official protocol payload
-    // For mobile apps, wallets should infer the callback scheme from the manifest or use a default
+function buildConnectionRequest(manifestUrl, returnScheme, walletUniversalLink, returnStrategy, requiresReturnScheme) {
+    // Build payload with required fields
     const payload = {
         manifestUrl,
         items: [{ name: 'ton_addr' }],
-        returnStrategy: 'back',
-        // NOTE: returnScheme is NOT in the official TON Connect protocol
-        // Wallets should handle mobile app callbacks differently
+        returnStrategy: returnStrategy || 'back',
     };
+    // CRITICAL FIX: Many wallets (Tonhub, MyTonWallet, Telegram Wallet) require returnScheme
+    // in the payload to properly handle mobile app callbacks. While not in the official
+    // protocol spec, it's a de-facto requirement for mobile apps.
+    if (requiresReturnScheme !== false) {
+        // Default to true if not specified - safer to include it
+        payload.returnScheme = returnScheme;
+    }
     const encoded = encodeBase64URL(payload);
     // Use custom wallet universal link if provided
     if (walletUniversalLink) {
@@ -130,7 +133,7 @@ function buildConnectionRequest(manifestUrl, returnScheme, walletUniversalLink)
  * Or universal link: https://app.tonkeeper.com/ton-connect/send-transaction?<base64_encoded_payload>
  * Or custom wallet universal link
  */
-function buildTransactionRequest(manifestUrl, request, returnScheme, walletUniversalLink) {
+function buildTransactionRequest(manifestUrl, request, returnScheme, walletUniversalLink, returnStrategy, requiresReturnScheme) {
     const payload = {
         manifestUrl,
         request: {
@@ -144,10 +147,12 @@ function buildTransactionRequest(manifestUrl, request, returnScheme, walletUnive
             network: request.network,
             from: request.from,
         },
-        returnStrategy: 'back',
-        // NOTE: returnScheme is NOT in the official TON Connect protocol
-        // Wallets should handle mobile app callbacks differently
+        returnStrategy: returnStrategy || 'back',
     };
+    // CRITICAL FIX: Include returnScheme for mobile wallets that require it
+    if (requiresReturnScheme !== false) {
+        payload.returnScheme = returnScheme;
+    }
     const encoded = encodeBase64URL(payload);
     // Use custom wallet universal link if provided
     if (walletUniversalLink) {

package/dist/core/wallets.d.ts

@@ -15,6 +15,10 @@ export interface WalletDefinition {
     iconUrl?: string;
     /** Platform support */
     platforms: ('ios' | 'android' | 'web')[];
+    /** Preferred return strategy for this wallet */
+    preferredReturnStrategy?: 'back' | 'post_redirect' | 'none';
+    /** Whether this wallet requires returnScheme in payload */
+    requiresReturnScheme?: boolean;
 }
 /**
  * List of supported TON Connect wallets

package/dist/core/wallets.js

@@ -18,6 +18,8 @@ exports.SUPPORTED_WALLETS = [
         universalLink: 'https://app.tonkeeper.com/ton-connect',
         deepLink: 'tonkeeper://',
         platforms: ['ios', 'android'],
+        preferredReturnStrategy: 'back',
+        requiresReturnScheme: true, // CRITICAL FIX: Mobile apps need returnScheme for proper callback handling
     },
     {
         name: 'MyTonWallet',
@@ -25,6 +27,8 @@ exports.SUPPORTED_WALLETS = [
         universalLink: 'https://connect.mytonwallet.org',
         deepLink: 'mytonwallet://',
         platforms: ['ios', 'android', 'web'],
+        preferredReturnStrategy: 'post_redirect',
+        requiresReturnScheme: true, // MyTonWallet requires explicit returnScheme
     },
     {
         name: 'Wallet in Telegram',
@@ -32,6 +36,8 @@ exports.SUPPORTED_WALLETS = [
         universalLink: 'https://wallet.tonapi.io/ton-connect',
         deepLink: 'tg://',
         platforms: ['ios', 'android'],
+        preferredReturnStrategy: 'post_redirect',
+        requiresReturnScheme: true, // Telegram Wallet requires explicit returnScheme
     },
     {
         name: 'Tonhub',
@@ -39,6 +45,8 @@ exports.SUPPORTED_WALLETS = [
         universalLink: 'https://tonhub.com/ton-connect',
         deepLink: 'tonhub://',
         platforms: ['ios', 'android'],
+        preferredReturnStrategy: 'post_redirect',
+        requiresReturnScheme: true, // Tonhub requires explicit returnScheme for proper callback
     },
 ];
 /**

package/dist/index.d.ts

@@ -38,6 +38,7 @@ export declare class TonConnectMobile {
     private currentWallet;
     private connectionPromise;
     private transactionPromise;
+    private signDataPromise;
     constructor(config: TonConnectMobileConfig);
     /**
      * Create platform adapter based on available modules
@@ -74,6 +75,14 @@ export declare class TonConnectMobile {
         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
      */

package/dist/index.js

@@ -81,6 +81,7 @@ class TonConnectMobile {
         this.urlUnsubscribe = null;
         this.connectionPromise = null;
         this.transactionPromise = null;
+        this.signDataPromise = null;
         // Validate config
         if (!config.manifestUrl) {
             throw new TonConnectError('manifestUrl is required');
@@ -188,6 +189,40 @@ class TonConnectMobile {
         }
         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)
+        if (this.signDataPromise && !this.signDataPromise.timeout) {
+            // Sign data request is pending
+            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;
+                }
+            }
+            // 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;
+                }
+            }
+        }
+        // Handle connection responses
         if (parsed.type === 'connect' && parsed.data) {
             this.handleConnectionResponse(parsed.data);
         }
@@ -306,10 +341,27 @@ class TonConnectMobile {
         // Build connection request URL (use wallet's universal link)
         console.log('[TON Connect] Building connection request URL for wallet:', this.currentWallet.name);
         console.log('[TON Connect] Using universal link:', this.currentWallet.universalLink);
-        const url = (0, protocol_1.buildConnectionRequest)(this.config.manifestUrl, this.config.scheme, 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) + '...');
-        // DEBUG: Log the URL being opened
-        console.log('[TON Connect] Opening URL:', url);
+        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);
@@ -381,7 +433,7 @@ class TonConnectMobile {
             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);
+        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;
@@ -424,6 +476,140 @@ class TonConnectMobile {
             });
         });
     }
+    /**
+     * 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
+        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);
+                },
+                reject: (error) => {
+                    if (timeout !== null) {
+                        clearTimeout(timeout);
+                    }
+                    resolved = true;
+                    if (this.signDataPromise === signDataPromise) {
+                        this.signDataPromise = null;
+                    }
+                    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)}`));
+            });
+        });
+    }
     /**
      * Disconnect from wallet
      */
@@ -601,6 +787,7 @@ class TonConnectMobile {
         this.statusChangeCallbacks.clear();
         this.connectionPromise = null;
         this.transactionPromise = null;
+        this.signDataPromise = null;
     }
 }
 exports.TonConnectMobile = TonConnectMobile;

package/dist/react/TonConnectButton.d.ts

@@ -0,0 +1,22 @@
+/**
+ * TonConnectButton component
+ * Compatible with @tonconnect/ui-react TonConnectButton
+ */
+import { ViewStyle, TextStyle } from 'react-native';
+export interface TonConnectButtonProps {
+    /** Button text when disconnected */
+    text?: string;
+    /** Button text when connected */
+    connectedText?: string;
+    /** Custom styles */
+    style?: ViewStyle;
+    /** Custom text styles */
+    textStyle?: TextStyle;
+    /** Callback when button is pressed */
+    onPress?: () => void;
+}
+/**
+ * TonConnectButton - Button component for connecting/disconnecting wallet
+ * Compatible with @tonconnect/ui-react TonConnectButton
+ */
+export declare function TonConnectButton({ text, connectedText, style, textStyle, onPress, }: TonConnectButtonProps): JSX.Element;

package/dist/react/TonConnectButton.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * TonConnectButton component
+ * Compatible with @tonconnect/ui-react TonConnectButton
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonConnectButton = TonConnectButton;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const index_1 = require("./index");
+/**
+ * TonConnectButton - Button component for connecting/disconnecting wallet
+ * Compatible with @tonconnect/ui-react TonConnectButton
+ */
+function TonConnectButton({ text = 'Connect Wallet', connectedText = 'Disconnect', style, textStyle, onPress, }) {
+    const tonConnectUI = (0, index_1.useTonConnectUI)();
+    const wallet = (0, index_1.useTonWallet)();
+    const isConnected = wallet?.connected || false;
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const handlePress = async () => {
+        // CRITICAL FIX: Prevent multiple simultaneous presses
+        if (isLoading) {
+            return;
+        }
+        if (onPress) {
+            onPress();
+            return;
+        }
+        setIsLoading(true);
+        try {
+            if (isConnected) {
+                await tonConnectUI.disconnect();
+            }
+            else {
+                // CRITICAL FIX: Only open modal, don't auto-connect
+                // The modal should handle wallet selection and connection
+                // This allows users to choose which wallet to connect
+                await tonConnectUI.openModal();
+                // Note: connectWallet() should be called by the modal/wallet selection UI
+                // Not automatically here, to allow wallet selection
+            }
+        }
+        catch (error) {
+            // CRITICAL FIX: Handle errors gracefully
+            console.error('TonConnectButton error:', error);
+            // Error is already handled by the SDK/UI, just reset loading state
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return (react_1.default.createElement(react_native_1.TouchableOpacity, { style: [styles.button, style, isLoading && styles.buttonDisabled], onPress: handlePress, disabled: isLoading }, isLoading ? (react_1.default.createElement(react_native_1.ActivityIndicator, { color: "#ffffff" })) : (react_1.default.createElement(react_native_1.Text, { style: [styles.buttonText, textStyle] }, isConnected ? connectedText : text))));
+}
+const styles = react_native_1.StyleSheet.create({
+    button: {
+        backgroundColor: '#0088cc',
+        paddingHorizontal: 24,
+        paddingVertical: 12,
+        borderRadius: 8,
+        alignItems: 'center',
+        justifyContent: 'center',
+        minHeight: 44,
+    },
+    buttonDisabled: {
+        opacity: 0.6,
+    },
+    buttonText: {
+        color: '#ffffff',
+        fontSize: 16,
+        fontWeight: '600',
+    },
+});

package/dist/react/TonConnectUIProvider.d.ts

@@ -0,0 +1,110 @@
+/**
+ * React integration layer for @tonconnect/ui-react compatibility
+ * Provides TonConnectUIProvider, hooks, and components compatible with @tonconnect/ui-react API
+ */
+import { ReactNode } from 'react';
+import { TonConnectMobile, WalletInfo, SendTransactionRequest } from '../index';
+import type { TonConnectMobileConfig } from '../types';
+/**
+ * Account information (compatible with @tonconnect/ui-react)
+ */
+export interface Account {
+    address: string;
+    chain: number;
+    publicKey?: string;
+}
+/**
+ * Wallet state (compatible with @tonconnect/ui-react)
+ */
+export interface WalletState {
+    account: Account | null;
+    wallet: WalletInfo | null;
+    connected: boolean;
+}
+/**
+ * Transaction response (compatible with @tonconnect/ui-react)
+ */
+export interface TransactionResponse {
+    boc: string;
+    signature: string;
+}
+/**
+ * Sign data request
+ */
+export interface SignDataRequest {
+    /** Data to sign (will be base64 encoded) */
+    data: string | Uint8Array;
+    /** Optional version */
+    version?: string;
+}
+/**
+ * Sign data response
+ */
+export interface SignDataResponse {
+    signature: string;
+    timestamp: number;
+}
+/**
+ * TonConnect UI instance interface (compatible with @tonconnect/ui-react)
+ */
+export interface TonConnectUI {
+    /** Open connection modal */
+    openModal: () => Promise<void>;
+    /** Close connection modal */
+    closeModal: () => void;
+    /** Connect to wallet */
+    connectWallet: () => Promise<void>;
+    /** Disconnect from wallet */
+    disconnect: () => Promise<void>;
+    /** Send transaction */
+    sendTransaction: (transaction: SendTransactionRequest) => Promise<TransactionResponse>;
+    /** Sign data */
+    signData: (request: SignDataRequest) => Promise<SignDataResponse>;
+    /** Current wallet state */
+    wallet: WalletState | null;
+    /** Modal open state */
+    modalState: {
+        open: boolean;
+    };
+    /** UI kit version */
+    uiVersion: string;
+}
+/**
+ * TonConnectUIProvider props
+ */
+export interface TonConnectUIProviderProps {
+    /** SDK configuration */
+    config: TonConnectMobileConfig;
+    /** Children */
+    children: ReactNode;
+    /** Optional SDK instance (for testing or custom instances) */
+    sdkInstance?: TonConnectMobile;
+}
+/**
+ * TonConnectUIProvider - React context provider for TON Connect
+ * Compatible with @tonconnect/ui-react API
+ */
+export declare function TonConnectUIProvider({ config, children, sdkInstance, }: TonConnectUIProviderProps): JSX.Element;
+/**
+ * Hook to access TonConnectUI instance
+ * Compatible with @tonconnect/ui-react useTonConnectUI hook
+ */
+export declare function useTonConnectUI(): TonConnectUI;
+/**
+ * Hook to access wallet state
+ * Compatible with @tonconnect/ui-react useTonWallet hook
+ */
+export declare function useTonWallet(): WalletState | null;
+/**
+ * Hook to access modal state
+ * Compatible with @tonconnect/ui-react useTonConnectModal hook
+ */
+export declare function useTonConnectModal(): {
+    open: boolean;
+    close: () => void;
+    openModal: () => Promise<void>;
+};
+/**
+ * Hook to access SDK instance (for advanced usage)
+ */
+export declare function useTonConnectSDK(): TonConnectMobile;