@blazium/ton-connect-mobile 1.2.5 → 1.2.6

package/dist/core/bridge.d.ts

@@ -0,0 +1,61 @@
+/**
+ * TON Connect v2 Bridge Gateway
+ * Handles SSE connection for receiving wallet responses and POST for sending messages
+ */
+/**
+ * Bridge message received from wallet
+ */
+export interface BridgeIncomingMessage {
+    from: string;
+    message: string;
+}
+/**
+ * Bridge Gateway for TON Connect v2 HTTP Bridge
+ */
+export declare class BridgeGateway {
+    private xhr;
+    private lastEventId;
+    private active;
+    private reconnectTimer;
+    private bridgeUrl;
+    private clientId;
+    private onMessageCallback;
+    private onErrorCallback;
+    /**
+     * Connect to the bridge SSE endpoint
+     * Listens for incoming messages from the wallet
+     */
+    connect(bridgeUrl: string, clientId: string, onMessage: (msg: BridgeIncomingMessage) => void, onError?: (error: Error) => void): void;
+    /**
+     * Open SSE connection using XMLHttpRequest (works in React Native)
+     */
+    private openSSE;
+    /**
+     * Fallback: poll bridge with fetch (for environments without XMLHttpRequest streaming)
+     */
+    private pollWithFetch;
+    /**
+     * Handle a single SSE event data
+     */
+    private handleEventData;
+    /**
+     * Schedule reconnection after a delay
+     */
+    private scheduleReconnect;
+    /**
+     * Send an encrypted message via the bridge
+     */
+    send(bridgeUrl: string, fromClientId: string, toClientId: string, encryptedMessage: Uint8Array, ttl?: number): Promise<void>;
+    /**
+     * Close the bridge connection
+     */
+    close(): void;
+    /**
+     * Check if bridge is currently connected/active
+     */
+    get isConnected(): boolean;
+    /**
+     * Parse SSE text into events
+     */
+    private parseSSE;
+}

package/dist/core/bridge.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * TON Connect v2 Bridge Gateway
+ * Handles SSE connection for receiving wallet responses and POST for sending messages
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeGateway = void 0;
+const session_1 = require("./session");
+/**
+ * Bridge Gateway for TON Connect v2 HTTP Bridge
+ */
+class BridgeGateway {
+    constructor() {
+        this.xhr = null;
+        this.lastEventId = '';
+        this.active = false;
+        this.reconnectTimer = null;
+        this.bridgeUrl = '';
+        this.clientId = '';
+        this.onMessageCallback = null;
+        this.onErrorCallback = null;
+    }
+    /**
+     * Connect to the bridge SSE endpoint
+     * Listens for incoming messages from the wallet
+     */
+    connect(bridgeUrl, clientId, onMessage, onError) {
+        this.bridgeUrl = bridgeUrl;
+        this.clientId = clientId;
+        this.onMessageCallback = onMessage;
+        this.onErrorCallback = onError || null;
+        this.active = true;
+        this.openSSE();
+    }
+    /**
+     * Open SSE connection using XMLHttpRequest (works in React Native)
+     */
+    openSSE() {
+        if (!this.active)
+            return;
+        // Build URL
+        let url = `${this.bridgeUrl}/events?client_id=${this.clientId}`;
+        if (this.lastEventId) {
+            url += `&last_event_id=${this.lastEventId}`;
+        }
+        console.log('[Bridge] Opening SSE connection:', url);
+        // Use XMLHttpRequest for SSE (available in React Native)
+        if (typeof XMLHttpRequest === 'undefined') {
+            // Fallback: use fetch-based polling
+            this.pollWithFetch(url);
+            return;
+        }
+        const xhr = new XMLHttpRequest();
+        this.xhr = xhr;
+        let processedLength = 0;
+        let buffer = '';
+        xhr.onreadystatechange = () => {
+            // LOADING (3) or DONE (4) — process incoming data
+            if (xhr.readyState >= 3) {
+                try {
+                    const newData = xhr.responseText.substring(processedLength);
+                    processedLength = xhr.responseText.length;
+                    if (newData) {
+                        buffer += newData;
+                        const parsed = this.parseSSE(buffer);
+                        buffer = parsed.remaining;
+                        for (const event of parsed.events) {
+                            if (event.id) {
+                                this.lastEventId = event.id;
+                            }
+                            if (event.data) {
+                                this.handleEventData(event.data);
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    // Ignore parse errors, continue listening
+                    console.warn('[Bridge] SSE parse error:', e);
+                }
+            }
+            // Connection closed (readyState 4) — reconnect if still active
+            if (xhr.readyState === 4 && this.active) {
+                console.log('[Bridge] SSE connection closed, reconnecting...');
+                this.scheduleReconnect();
+            }
+        };
+        xhr.onerror = () => {
+            console.error('[Bridge] SSE connection error');
+            if (this.active) {
+                this.scheduleReconnect();
+            }
+        };
+        xhr.open('GET', url, true);
+        xhr.setRequestHeader('Accept', 'text/event-stream');
+        xhr.send();
+    }
+    /**
+     * Fallback: poll bridge with fetch (for environments without XMLHttpRequest streaming)
+     */
+    async pollWithFetch(url) {
+        while (this.active) {
+            try {
+                let pollUrl = `${this.bridgeUrl}/events?client_id=${this.clientId}`;
+                if (this.lastEventId) {
+                    pollUrl += `&last_event_id=${this.lastEventId}`;
+                }
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 25000);
+                const response = await fetch(pollUrl, {
+                    headers: { 'Accept': 'text/event-stream' },
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                const text = await response.text();
+                const parsed = this.parseSSE(text);
+                for (const event of parsed.events) {
+                    if (event.id) {
+                        this.lastEventId = event.id;
+                    }
+                    if (event.data) {
+                        this.handleEventData(event.data);
+                    }
+                }
+            }
+            catch (error) {
+                if (error?.name === 'AbortError') {
+                    // Timeout — reconnect
+                    continue;
+                }
+                console.error('[Bridge] Fetch poll error:', error);
+                // Wait before retrying
+                await new Promise((resolve) => setTimeout(() => resolve(), 2000));
+            }
+        }
+    }
+    /**
+     * Handle a single SSE event data
+     */
+    handleEventData(data) {
+        try {
+            const parsed = JSON.parse(data);
+            if (parsed.from && parsed.message) {
+                console.log('[Bridge] Received message from:', parsed.from.substring(0, 16) + '...');
+                if (this.onMessageCallback) {
+                    this.onMessageCallback(parsed);
+                }
+            }
+        }
+        catch (e) {
+            // Might be a heartbeat or other non-JSON data — ignore
+            console.log('[Bridge] Non-message event:', data.substring(0, 50));
+        }
+    }
+    /**
+     * Schedule reconnection after a delay
+     */
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        this.reconnectTimer = setTimeout(() => {
+            if (this.active) {
+                this.openSSE();
+            }
+        }, 1500);
+    }
+    /**
+     * Send an encrypted message via the bridge
+     */
+    async send(bridgeUrl, fromClientId, toClientId, encryptedMessage, ttl = 300) {
+        const base64Message = (0, session_1.bytesToBase64)(encryptedMessage);
+        const url = `${bridgeUrl}/message?client_id=${fromClientId}&to=${toClientId}&ttl=${ttl}`;
+        console.log('[Bridge] Sending message to:', toClientId.substring(0, 16) + '...');
+        const response = await fetch(url, {
+            method: 'POST',
+            body: base64Message,
+            headers: {
+                'Content-Type': 'text/plain',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Bridge send failed: ${response.status} ${response.statusText}`);
+        }
+        console.log('[Bridge] Message sent successfully');
+    }
+    /**
+     * Close the bridge connection
+     */
+    close() {
+        console.log('[Bridge] Closing connection');
+        this.active = false;
+        if (this.xhr) {
+            this.xhr.abort();
+            this.xhr = null;
+        }
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.onMessageCallback = null;
+        this.onErrorCallback = null;
+    }
+    /**
+     * Check if bridge is currently connected/active
+     */
+    get isConnected() {
+        return this.active;
+    }
+    /**
+     * Parse SSE text into events
+     */
+    parseSSE(text) {
+        const events = [];
+        const parts = text.split('\n\n');
+        const remaining = parts.pop() || '';
+        for (const part of parts) {
+            if (!part.trim())
+                continue;
+            const event = {};
+            const lines = part.split('\n');
+            for (const line of lines) {
+                if (line.startsWith('id:')) {
+                    event.id = line.substring(3).trim();
+                }
+                else if (line.startsWith('data:')) {
+                    event.data = (event.data || '') + line.substring(5).trim();
+                }
+            }
+            if (event.data || event.id) {
+                events.push(event);
+            }
+        }
+        return { events, remaining };
+    }
+}
+exports.BridgeGateway = BridgeGateway;

package/dist/core/crypto.d.ts

@@ -1,28 +1,17 @@
 /**
  * Cryptographic utilities for TonConnect
- * Uses tweetnacl for signature verification
+ * Legacy module — primary crypto is now in session.ts
+ * This module provides helper functions that may be used externally
  */
-import { ConnectionResponsePayload } from '../types';
 /**
- * Verify connection proof signature
- * The proof is signed by the wallet to verify authenticity
+ * Convert hex string to Uint8Array
  */
-export declare function verifyConnectionProof(response: ConnectionResponsePayload, manifestUrl: string): boolean;
-/**
- * Verify transaction signature
- *
- * WARNING: This function only performs basic format validation.
- * Full signature verification requires parsing the BOC (Bag of Cells) and
- * verifying the signature against the transaction hash, which requires
- * TON library integration (@ton/core or @ton/crypto).
- *
- * For production use, transaction signatures should be verified server-side
- * using proper TON libraries.
- *
- * @returns false - Always returns false to be safe until proper implementation
- */
-export declare function verifyTransactionSignature(boc: string, signature: string, publicKey: string): boolean;
+export declare function hexToBytes(hex: string): Uint8Array;
 /**
  * Generate random session ID
  */
 export declare function generateSessionId(): string;
+/**
+ * Verify Ed25519 signature
+ */
+export declare function verifySignature(message: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean;

package/dist/core/crypto.js

@@ -1,153 +1,20 @@
 "use strict";
 /**
  * Cryptographic utilities for TonConnect
- * Uses tweetnacl for signature verification
+ * Legacy module — primary crypto is now in session.ts
+ * This module provides helper functions that may be used externally
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyConnectionProof = verifyConnectionProof;
-exports.verifyTransactionSignature = verifyTransactionSignature;
+exports.hexToBytes = hexToBytes;
 exports.generateSessionId = generateSessionId;
+exports.verifySignature = verifySignature;
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const nacl = require('tweetnacl');
-/**
- * Decode base64 string to Uint8Array
- */
-function decodeBase64(base64) {
-    // Remove padding and convert URL-safe to standard base64
-    const cleanBase64 = base64.replace(/-/g, '+').replace(/_/g, '/');
-    const padded = cleanBase64 + '='.repeat((4 - (cleanBase64.length % 4)) % 4);
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-    const bytes = [];
-    let buffer = 0;
-    let bitsCollected = 0;
-    for (let i = 0; i < padded.length; i++) {
-        const ch = padded[i];
-        if (ch === '=')
-            break;
-        const 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);
-}
-/**
- * Get TextEncoder with fallback
- */
-function getTextEncoder() {
-    if (typeof TextEncoder !== 'undefined') {
-        return new TextEncoder();
-    }
-    // Fallback implementation for older React Native
-    throw new Error('TextEncoder is not available. Please use React Native 0.59+ or add a polyfill.');
-}
-/**
- * Verify connection proof signature
- * The proof is signed by the wallet to verify authenticity
- */
-function verifyConnectionProof(response, manifestUrl) {
-    // HIGH FIX: Log warning if proof is missing but allow for compatibility
-    if (!response.proof) {
-        console.warn('TON Connect: Connection proof missing - wallet may not support proof verification');
-        // Allow connection for compatibility, but log warning
-        return true;
-    }
-    try {
-        const { timestamp, domain, signature } = response.proof;
-        // Validate proof structure
-        if (typeof timestamp !== 'number' || !domain || typeof domain.lengthBytes !== 'number' || typeof domain.value !== 'string' || typeof signature !== 'string') {
-            return false;
-        }
-        // Build the message that was signed
-        // Format: <timestamp>.<domain_length>.<domain_value>.<address>.<publicKey>
-        const domainLength = domain.lengthBytes;
-        const message = `${timestamp}.${domainLength}.${domain.value}.${response.address}.${response.publicKey}`;
-        // Convert public key from hex to Uint8Array
-        const publicKeyBytes = hexToBytes(response.publicKey);
-        if (publicKeyBytes.length !== 32) {
-            return false;
-        }
-        // Convert signature from base64 to Uint8Array
-        const signatureBytes = decodeBase64(signature);
-        if (signatureBytes.length !== 64) {
-            return false;
-        }
-        // Verify signature using nacl
-        const encoder = getTextEncoder();
-        const messageBytes = encoder.encode(message);
-        return nacl.sign.detached.verify(messageBytes, signatureBytes, publicKeyBytes);
-    }
-    catch (error) {
-        // If verification fails, return false
-        console.error('TON Connect: Proof verification error:', error);
-        return false;
-    }
-}
-/**
- * Verify transaction signature
- *
- * WARNING: This function only performs basic format validation.
- * Full signature verification requires parsing the BOC (Bag of Cells) and
- * verifying the signature against the transaction hash, which requires
- * TON library integration (@ton/core or @ton/crypto).
- *
- * For production use, transaction signatures should be verified server-side
- * using proper TON libraries.
- *
- * @returns false - Always returns false to be safe until proper implementation
- */
-function verifyTransactionSignature(boc, signature, publicKey) {
-    // CRITICAL FIX: This function does not actually verify signatures
-    // It only checks format. For security, we return false until proper implementation.
-    try {
-        // Basic format validation
-        if (!boc || typeof boc !== 'string' || boc.length === 0) {
-            return false;
-        }
-        if (!signature || typeof signature !== 'string' || signature.length === 0) {
-            return false;
-        }
-        if (!publicKey || typeof publicKey !== 'string' || publicKey.length === 0) {
-            return false;
-        }
-        // Convert public key from hex to Uint8Array
-        const publicKeyBytes = hexToBytes(publicKey);
-        if (publicKeyBytes.length !== 32) {
-            return false;
-        }
-        // Convert signature from base64 to Uint8Array
-        const signatureBytes = decodeBase64(signature);
-        if (signatureBytes.length !== 64) {
-            return false;
-        }
-        // Convert BOC from base64 to Uint8Array
-        const bocBytes = decodeBase64(boc);
-        if (bocBytes.length === 0) {
-            return false;
-        }
-        // CRITICAL: Return false - actual signature verification requires TON library
-        // TODO: Integrate @ton/core or @ton/crypto for proper BOC parsing and signature verification
-        console.warn('TON Connect: Transaction signature verification not fully implemented. Signature format is valid but not cryptographically verified. Verify server-side using @ton/core.');
-        return false; // Fail-safe: reject until properly implemented
-    }
-    catch (error) {
-        console.error('TON Connect: Transaction signature verification error:', error);
-        return false;
-    }
-}
 /**
  * Convert hex string to Uint8Array
  */
 function hexToBytes(hex) {
-    // Remove 0x prefix if present
     const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
-    // Handle odd-length hex strings
     const paddedHex = cleanHex.length % 2 === 0 ? cleanHex : '0' + cleanHex;
     const bytes = new Uint8Array(paddedHex.length / 2);
     for (let i = 0; i < paddedHex.length; i += 2) {
@@ -160,13 +27,11 @@ function hexToBytes(hex) {
  */
 function getSecureRandomBytes(length) {
     const bytes = new Uint8Array(length);
-    // Try to use crypto.getRandomValues (available in React Native with polyfill)
     // eslint-disable-next-line no-undef
     if (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.getRandomValues) {
         globalThis.crypto.getRandomValues(bytes);
         return bytes;
     }
-    // HIGH FIX: Throw error instead of using insecure Math.random()
     throw new Error('Cryptographically secure random number generation not available. ' +
         'Please install react-native-get-random-values or use React Native 0.59+');
 }
@@ -174,10 +39,19 @@ function getSecureRandomBytes(length) {
  * Generate random session ID
  */
 function generateSessionId() {
-    // HIGH FIX: Use secure random bytes
     const bytes = getSecureRandomBytes(32);
-    // Convert to hex string
     return Array.from(bytes)
         .map((b) => b.toString(16).padStart(2, '0'))
         .join('');
 }
+/**
+ * Verify Ed25519 signature
+ */
+function verifySignature(message, signature, publicKey) {
+    try {
+        return nacl.sign.detached.verify(message, signature, publicKey);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/index.d.ts

@@ -1,5 +1,7 @@
 /**
- * Core protocol exports
+ * Core module exports
  */
-export * from './protocol';
-export * from './crypto';
+export { SessionCrypto } from './session';
+export { BridgeGateway } from './bridge';
+export { buildConnectUniversalLink, buildReturnUniversalLink, buildSendTransactionRpcRequest, buildDisconnectRpcRequest, parseConnectResponse, parseRpcResponse, extractWalletInfoFromEvent, validateTransactionRequest, } from './protocol';
+export { SUPPORTED_WALLETS, getWalletByName, getDefaultWallet, getWalletsForPlatform } from './wallets';

package/dist/core/index.js

@@ -1,21 +1,24 @@
 "use strict";
 /**
- * Core protocol exports
+ * Core module exports
  */
-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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./protocol"), exports);
-__exportStar(require("./crypto"), exports);
+exports.getWalletsForPlatform = exports.getDefaultWallet = exports.getWalletByName = exports.SUPPORTED_WALLETS = exports.validateTransactionRequest = exports.extractWalletInfoFromEvent = exports.parseRpcResponse = exports.parseConnectResponse = exports.buildDisconnectRpcRequest = exports.buildSendTransactionRpcRequest = exports.buildReturnUniversalLink = exports.buildConnectUniversalLink = exports.BridgeGateway = exports.SessionCrypto = void 0;
+var session_1 = require("./session");
+Object.defineProperty(exports, "SessionCrypto", { enumerable: true, get: function () { return session_1.SessionCrypto; } });
+var bridge_1 = require("./bridge");
+Object.defineProperty(exports, "BridgeGateway", { enumerable: true, get: function () { return bridge_1.BridgeGateway; } });
+var protocol_1 = require("./protocol");
+Object.defineProperty(exports, "buildConnectUniversalLink", { enumerable: true, get: function () { return protocol_1.buildConnectUniversalLink; } });
+Object.defineProperty(exports, "buildReturnUniversalLink", { enumerable: true, get: function () { return protocol_1.buildReturnUniversalLink; } });
+Object.defineProperty(exports, "buildSendTransactionRpcRequest", { enumerable: true, get: function () { return protocol_1.buildSendTransactionRpcRequest; } });
+Object.defineProperty(exports, "buildDisconnectRpcRequest", { enumerable: true, get: function () { return protocol_1.buildDisconnectRpcRequest; } });
+Object.defineProperty(exports, "parseConnectResponse", { enumerable: true, get: function () { return protocol_1.parseConnectResponse; } });
+Object.defineProperty(exports, "parseRpcResponse", { enumerable: true, get: function () { return protocol_1.parseRpcResponse; } });
+Object.defineProperty(exports, "extractWalletInfoFromEvent", { enumerable: true, get: function () { return protocol_1.extractWalletInfoFromEvent; } });
+Object.defineProperty(exports, "validateTransactionRequest", { enumerable: true, get: function () { return protocol_1.validateTransactionRequest; } });
+var wallets_1 = require("./wallets");
+Object.defineProperty(exports, "SUPPORTED_WALLETS", { enumerable: true, get: function () { return wallets_1.SUPPORTED_WALLETS; } });
+Object.defineProperty(exports, "getWalletByName", { enumerable: true, get: function () { return wallets_1.getWalletByName; } });
+Object.defineProperty(exports, "getDefaultWallet", { enumerable: true, get: function () { return wallets_1.getDefaultWallet; } });
+Object.defineProperty(exports, "getWalletsForPlatform", { enumerable: true, get: function () { return wallets_1.getWalletsForPlatform; } });

package/dist/core/protocol.d.ts

@@ -1,53 +1,54 @@
 /**
- * Core TonConnect protocol implementation
- * Pure TypeScript, no platform dependencies
+ * TON Connect v2 Protocol Implementation
+ * Builds correct universal links and parses bridge responses
  */
-import { ConnectionResponsePayload, TransactionResponsePayload, ErrorResponse, WalletInfo, SendTransactionRequest } from '../types';
+import type { SendTransactionRequest, WalletInfo, ConnectEvent, ConnectErrorEvent, RpcResponse, RpcErrorResponse } from '../types';
 /**
- * Encode JSON to base64 URL-safe string
+ * Build a TON Connect v2 universal link for wallet connection
+ * Format: {universalLink}?v=2&id={sessionId}&r={connectRequest}&ret={returnStrategy}
  */
-export declare function encodeBase64URL(data: unknown): string;
+export declare function buildConnectUniversalLink(universalLink: string, sessionId: string, manifestUrl: string, returnStrategy?: string): string;
 /**
- * Decode base64 URL-safe string to JSON
+ * Build a universal link to bring wallet to foreground (for pending transactions)
+ * Format: {universalLink}?ret={returnStrategy}
  */
-export declare function decodeBase64URL<T>(encoded: string): T;
+export declare function buildReturnUniversalLink(universalLink: string, returnStrategy?: string): string;
 /**
- * Build connection request URL
- * Format: tonconnect://connect?<base64_encoded_payload>
- * Or universal link: https://app.tonkeeper.com/ton-connect?<base64_encoded_payload>
- * Or custom wallet universal link
+ * Build a JSON-RPC request for sendTransaction
  */
-export declare function buildConnectionRequest(manifestUrl: string, returnScheme: string, walletUniversalLink?: string, returnStrategy?: 'back' | 'post_redirect' | 'none', requiresReturnScheme?: boolean): string;
+export declare function buildSendTransactionRpcRequest(request: SendTransactionRequest, id: number): 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
+ * Build a JSON-RPC request for disconnect
  */
-export declare function buildTransactionRequest(manifestUrl: string, request: SendTransactionRequest, returnScheme: string, walletUniversalLink?: string, returnStrategy?: 'back' | 'post_redirect' | 'none', requiresReturnScheme?: boolean): string;
+export declare function buildDisconnectRpcRequest(id: number): string;
 /**
- * Parse callback URL
- * Format: <scheme>://tonconnect?<base64_encoded_response>
+ * Parse a connect response from the wallet (received via bridge, after decryption)
  */
-export declare function parseCallbackURL(url: string, scheme: string): {
-    type: 'connect' | 'transaction' | 'error' | 'unknown';
-    data: ConnectionResponsePayload | TransactionResponsePayload | ErrorResponse | null;
-};
-/**
- * Extract wallet info from connection response
- * CRITICAL: This function assumes response has been validated by validateConnectionResponse
- */
-export declare function extractWalletInfo(response: ConnectionResponsePayload): WalletInfo;
+export declare function parseConnectResponse(decrypted: string): {
+    type: 'connect';
+    data: ConnectEvent;
+} | {
+    type: 'error';
+    data: ConnectErrorEvent;
+} | null;
 /**
- * Validate connection response
- * CRITICAL FIX: Only validate truly required fields (session, address, publicKey, name)
- * appName and version are optional - extractWalletInfo has fallbacks for them
+ * Parse an RPC response from the wallet (for sendTransaction, disconnect, etc.)
  */
-export declare function validateConnectionResponse(response: ConnectionResponsePayload): boolean;
+export declare function parseRpcResponse(decrypted: string): {
+    type: 'result';
+    data: RpcResponse;
+} | {
+    type: 'error';
+    data: RpcErrorResponse;
+} | {
+    type: 'event';
+    event: string;
+    data: any;
+} | null;
 /**
- * Validate transaction response
+ * Extract wallet info from a connect event
  */
-export declare function validateTransactionResponse(response: TransactionResponsePayload): boolean;
+export declare function extractWalletInfoFromEvent(event: ConnectEvent): WalletInfo;
 /**
  * Validate transaction request
  */