@blazium/ton-connect-mobile 1.2.5 → 1.2.6

package/dist/types/index.d.ts

@@ -1,23 +1,27 @@
 /**
  * Core types for TON Connect Mobile SDK
- * These types define the protocol structure for TonConnect
+ * Types for TON Connect v2 protocol
  */
 /**
  * Wallet information returned after successful connection
  */
 export interface WalletInfo {
-    /** Wallet name (e.g., "Tonkeeper", "MyTonWallet") */
+    /** Wallet name (e.g., "Tonkeeper") */
     name: string;
     /** Wallet app name */
     appName: string;
     /** Wallet app version */
     version: string;
-    /** Platform (ios/android) */
+    /** Platform */
     platform: 'ios' | 'android' | 'unknown';
-    /** TON address of the connected wallet */
+    /** TON address (raw format: workchain:hash) */
     address: string;
     /** Public key in hex format */
     publicKey: string;
+    /** Network identifier ("-239" = mainnet, "-3" = testnet) */
+    network?: string;
+    /** Wallet state init (base64) */
+    walletStateInit?: string;
     /** Wallet icon URL */
     icon?: string;
 }
@@ -25,18 +29,16 @@ export interface WalletInfo {
  * Connection status
  */
 export interface ConnectionStatus {
-    /** Whether a wallet is currently connected */
     connected: boolean;
-    /** Wallet information if connected, null otherwise */
     wallet: WalletInfo | null;
 }
 /**
  * Transaction message to send
  */
 export interface TransactionMessage {
-    /** Recipient address in TON format (EQ...) */
+    /** Recipient address */
     address: string;
-    /** Amount in nanotons (1 TON = 1,000,000,000 nanotons) */
+    /** Amount in nanotons */
     amount: string;
     /** Optional message payload (base64 encoded) */
     payload?: string;
@@ -51,128 +53,21 @@ export interface SendTransactionRequest {
     validUntil: number;
     /** Array of messages to send */
     messages: TransactionMessage[];
-    /** Optional network (mainnet/testnet) */
+    /** Optional network */
     network?: 'mainnet' | 'testnet';
     /** Optional from address */
     from?: string;
 }
 /**
- * Transaction response from wallet
- */
-export interface TransactionResponse {
-    /** Base64 encoded BOC of the transaction */
-    boc: string;
-    /** Transaction signature */
-    signature: string;
-}
-/**
- * Connection request payload (sent to wallet)
- */
-export interface ConnectionRequestPayload {
-    /** Manifest URL for the app */
-    manifestUrl: string;
-    /** Items requested from wallet */
-    items: Array<{
-        name: 'ton_addr';
-    }>;
-    /** Return strategy - how wallet should return to the app */
-    returnStrategy?: 'back' | 'post_redirect' | 'none';
-    /** Return scheme for mobile apps (required by many wallets for proper callback handling) */
-    returnScheme?: string;
-}
-/**
- * Connection response payload (received from wallet)
- */
-export interface ConnectionResponsePayload {
-    /** Session ID */
-    session: string;
-    /** Wallet information */
-    name: string;
-    /** Wallet app name */
-    appName: string;
-    /** Wallet version */
-    version: string;
-    /** Platform */
-    platform: 'ios' | 'android' | 'unknown';
-    /** TON address */
-    address: string;
-    /** Public key in hex */
-    publicKey: string;
-    /** Wallet icon URL */
-    icon?: string;
-    /** Proof (signature) for verification */
-    proof?: {
-        timestamp: number;
-        domain: {
-            lengthBytes: number;
-            value: string;
-        };
-        signature: string;
-    };
-}
-/**
- * Transaction request payload (sent to wallet)
- */
-export interface TransactionRequestPayload {
-    /** Manifest URL */
-    manifestUrl: string;
-    /** Transaction request */
-    request: {
-        /** Unix timestamp (ms) when request expires */
-        validUntil: number;
-        /** Array of messages */
-        messages: Array<{
-            address: string;
-            amount: string;
-            payload?: string;
-            stateInit?: string;
-        }>;
-        /** Optional network */
-        network?: 'mainnet' | 'testnet';
-        /** Optional from address */
-        from?: string;
-    };
-    /** Return URL scheme (for mobile apps) */
-    returnScheme?: string;
-    /** Return strategy */
-    returnStrategy?: 'back' | 'post_redirect' | 'none';
-}
-/**
- * Transaction response payload (received from wallet)
- */
-export interface TransactionResponsePayload {
-    /** Base64 encoded BOC */
-    boc: string;
-    /** Transaction signature */
-    signature: string;
-}
-/**
- * Error response from wallet
- */
-export interface ErrorResponse {
-    /** Error code */
-    error: {
-        code: number;
-        message: string;
-    };
-}
-/**
- * Platform adapter interface for deep linking and storage
+ * Platform adapter interface
  */
 export interface PlatformAdapter {
-    /** Open a deep link URL */
     openURL(url: string, skipCanOpenURLCheck?: boolean): Promise<boolean>;
-    /** Get initial URL when app was opened via deep link */
     getInitialURL(): Promise<string | null>;
-    /** Add listener for URL changes */
     addURLListener(callback: (url: string) => void): () => void;
-    /** Store data */
     setItem(key: string, value: string): Promise<void>;
-    /** Retrieve data */
     getItem(key: string): Promise<string | null>;
-    /** Remove data */
     removeItem(key: string): Promise<void>;
-    /** Generate random bytes */
     randomBytes(length: number): Promise<Uint8Array>;
 }
 /**
@@ -185,7 +80,7 @@ export type Network = 'mainnet' | 'testnet';
 export interface TonConnectMobileConfig {
     /** Manifest URL (required) */
     manifestUrl: string;
-    /** Deep link scheme for callbacks (required) */
+    /** Deep link scheme for callbacks (required for return strategy) */
     scheme: string;
     /** Optional storage key prefix */
     storageKeyPrefix?: string;
@@ -193,29 +88,21 @@ export interface TonConnectMobileConfig {
     connectionTimeout?: number;
     /** Optional transaction timeout in ms (default: 300000 = 5 minutes) */
     transactionTimeout?: number;
-    /** Skip canOpenURL check before opening URL (optional, default: true)
-     * Set to false if you want to check if URL can be opened before attempting to open it.
-     * Note: On Android, canOpenURL may return false for tonconnect:// even if wallet is installed.
-     */
+    /** Skip canOpenURL check (default: true) */
     skipCanOpenURLCheck?: boolean;
-    /** Preferred wallet name (optional)
-     * If not specified, will use default wallet (Tonkeeper)
-     * Available: 'Tonkeeper', 'MyTonWallet', 'Wallet in Telegram', 'Tonhub'
-     */
+    /** Preferred wallet name */
     preferredWallet?: string;
-    /** Network (mainnet/testnet) - default: 'mainnet' */
+    /** Network (default: 'mainnet') */
     network?: Network;
-    /** TON API endpoint for balance checking (optional)
-     * Default: 'https://toncenter.com/api/v2' for mainnet, 'https://testnet.toncenter.com/api/v2' for testnet
-     */
+    /** Custom TON API endpoint */
     tonApiEndpoint?: string;
 }
 /**
- * Event listener callback type
+ * Status change callback
  */
 export type StatusChangeCallback = (status: ConnectionStatus) => void;
 /**
- * Event types for TonConnectMobile
+ * Event types
  */
 export type TonConnectEventType = 'connect' | 'disconnect' | 'transaction' | 'error' | 'statusChange';
 /**
@@ -230,23 +117,81 @@ export type TransactionStatus = 'pending' | 'confirmed' | 'failed' | 'unknown';
  * Transaction status response
  */
 export interface TransactionStatusResponse {
-    /** Transaction status */
     status: TransactionStatus;
-    /** Transaction hash (if available) */
     hash?: string;
-    /** Block number (if confirmed) */
     blockNumber?: number;
-    /** Error message (if failed) */
     error?: string;
 }
 /**
  * Balance response
  */
 export interface BalanceResponse {
-    /** Balance in nanotons */
     balance: string;
-    /** Balance in TON (formatted) */
     balanceTon: string;
-    /** Network */
     network: Network;
 }
+/**
+ * Connect event from wallet (received via bridge after decryption)
+ */
+export interface ConnectEvent {
+    event: 'connect';
+    id: number;
+    payload: {
+        items: Array<{
+            name: string;
+            address: string;
+            network: string;
+            publicKey: string;
+            walletStateInit?: string;
+            [key: string]: any;
+        }>;
+        device: {
+            platform: string;
+            appName: string;
+            appVersion: string;
+            maxProtocolVersion: number;
+            features: any[];
+        };
+    };
+}
+/**
+ * Connect error event from wallet
+ */
+export interface ConnectErrorEvent {
+    event: 'connect_error';
+    id: number;
+    payload: {
+        code: number;
+        message: string;
+    };
+}
+/**
+ * JSON-RPC response (success)
+ */
+export interface RpcResponse {
+    result: string;
+    id: number;
+}
+/**
+ * JSON-RPC response (error)
+ */
+export interface RpcErrorResponse {
+    error: {
+        code: number;
+        message: string;
+    };
+    id: number;
+}
+/**
+ * Persisted session data
+ */
+export interface PersistedSession {
+    /** Hex-encoded session secret key */
+    sessionSecretKey: string;
+    /** Hex-encoded wallet public key (from bridge "from" field) */
+    walletPublicKey: string;
+    /** Wallet bridge URL */
+    bridgeUrl: string;
+    /** Wallet info */
+    wallet: WalletInfo;
+}

package/dist/types/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
  * Core types for TON Connect Mobile SDK
- * These types define the protocol structure for TonConnect
+ * Types for TON Connect v2 protocol
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blazium/ton-connect-mobile",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "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",
@@ -66,5 +66,4 @@
     "dist",
     "src"
   ]
-}
-
+}

package/src/core/bridge.ts

@@ -0,0 +1,307 @@
+/**
+ * TON Connect v2 Bridge Gateway
+ * Handles SSE connection for receiving wallet responses and POST for sending messages
+ */
+
+import { bytesToBase64, base64ToBytes } from './session';
+
+// Type declarations
+declare const XMLHttpRequest: {
+  new (): XMLHttpRequestInstance;
+} | undefined;
+
+interface XMLHttpRequestInstance {
+  readyState: number;
+  responseText: string;
+  status: number;
+  open(method: string, url: string, async?: boolean): void;
+  setRequestHeader(name: string, value: string): void;
+  send(data?: string | null): void;
+  abort(): void;
+  onreadystatechange: (() => void) | null;
+  onerror: (() => void) | null;
+}
+
+/**
+ * Parsed SSE event
+ */
+interface SSEEvent {
+  id?: string;
+  data?: string;
+}
+
+/**
+ * Bridge message received from wallet
+ */
+export interface BridgeIncomingMessage {
+  from: string; // hex-encoded sender public key
+  message: string; // base64-encoded encrypted message
+}
+
+/**
+ * Bridge Gateway for TON Connect v2 HTTP Bridge
+ */
+export class BridgeGateway {
+  private xhr: XMLHttpRequestInstance | null = null;
+  private lastEventId: string = '';
+  private active: boolean = false;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private bridgeUrl: string = '';
+  private clientId: string = '';
+  private onMessageCallback: ((msg: BridgeIncomingMessage) => void) | null = null;
+  private onErrorCallback: ((error: Error) => void) | null = null;
+
+  /**
+   * 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 {
+    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)
+   */
+  private openSSE(): void {
+    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)
+   */
+  private async pollWithFetch(url: string): Promise<void> {
+    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: any) {
+        if (error?.name === 'AbortError') {
+          // Timeout — reconnect
+          continue;
+        }
+        console.error('[Bridge] Fetch poll error:', error);
+        // Wait before retrying
+        await new Promise<void>((resolve) => setTimeout(() => resolve(), 2000));
+      }
+    }
+  }
+
+  /**
+   * Handle a single SSE event data
+   */
+  private handleEventData(data: string): void {
+    try {
+      const parsed = JSON.parse(data) as BridgeIncomingMessage;
+      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
+   */
+  private scheduleReconnect(): void {
+    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: string,
+    fromClientId: string,
+    toClientId: string,
+    encryptedMessage: Uint8Array,
+    ttl: number = 300
+  ): Promise<void> {
+    const base64Message = 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(): void {
+    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(): boolean {
+    return this.active;
+  }
+
+  /**
+   * Parse SSE text into events
+   */
+  private parseSSE(text: string): { events: SSEEvent[]; remaining: string } {
+    const events: SSEEvent[] = [];
+    const parts = text.split('\n\n');
+    const remaining = parts.pop() || '';
+
+    for (const part of parts) {
+      if (!part.trim()) continue;
+
+      const event: SSEEvent = {};
+      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 };
+  }
+}