@blazium/ton-connect-mobile 1.0.0

package/dist/index.js

@@ -0,0 +1,502 @@
+"use strict";
+/**
+ * TON Connect Mobile SDK
+ * Production-ready implementation for React Native and Expo
+ */
+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 });
+exports.TonConnectMobile = exports.TransactionInProgressError = exports.ConnectionInProgressError = exports.UserRejectedError = exports.TransactionTimeoutError = exports.ConnectionTimeoutError = exports.TonConnectError = void 0;
+const protocol_1 = require("./core/protocol");
+const crypto_1 = require("./core/crypto");
+const expo_1 = require("./adapters/expo");
+const react_native_1 = require("./adapters/react-native");
+const web_1 = require("./adapters/web");
+/**
+ * Custom error classes
+ */
+class TonConnectError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'TonConnectError';
+    }
+}
+exports.TonConnectError = TonConnectError;
+class ConnectionTimeoutError extends TonConnectError {
+    constructor() {
+        super('Connection request timed out', 'CONNECTION_TIMEOUT');
+        this.name = 'ConnectionTimeoutError';
+    }
+}
+exports.ConnectionTimeoutError = ConnectionTimeoutError;
+class TransactionTimeoutError extends TonConnectError {
+    constructor() {
+        super('Transaction request timed out', 'TRANSACTION_TIMEOUT');
+        this.name = 'TransactionTimeoutError';
+    }
+}
+exports.TransactionTimeoutError = TransactionTimeoutError;
+class UserRejectedError extends TonConnectError {
+    constructor() {
+        super('User rejected the request', 'USER_REJECTED');
+        this.name = 'UserRejectedError';
+    }
+}
+exports.UserRejectedError = UserRejectedError;
+class ConnectionInProgressError extends TonConnectError {
+    constructor() {
+        super('Connection request already in progress', 'CONNECTION_IN_PROGRESS');
+        this.name = 'ConnectionInProgressError';
+    }
+}
+exports.ConnectionInProgressError = ConnectionInProgressError;
+class TransactionInProgressError extends TonConnectError {
+    constructor() {
+        super('Transaction request already in progress', 'TRANSACTION_IN_PROGRESS');
+        this.name = 'TransactionInProgressError';
+    }
+}
+exports.TransactionInProgressError = TransactionInProgressError;
+/**
+ * Main TON Connect Mobile SDK class
+ */
+class TonConnectMobile {
+    constructor(config) {
+        this.statusChangeCallbacks = new Set();
+        this.currentStatus = { connected: false, wallet: null };
+        this.urlUnsubscribe = null;
+        this.connectionPromise = null;
+        this.transactionPromise = null;
+        // Validate config
+        if (!config.manifestUrl) {
+            throw new TonConnectError('manifestUrl is required');
+        }
+        if (!config.scheme) {
+            throw new TonConnectError('scheme is required');
+        }
+        this.config = {
+            storageKeyPrefix: 'tonconnect_',
+            connectionTimeout: 300000, // 5 minutes
+            transactionTimeout: 300000, // 5 minutes
+            ...config,
+        };
+        // Initialize platform adapter
+        this.adapter = this.createAdapter();
+        // Set up URL listener
+        this.setupURLListener();
+        // Load persisted session
+        this.loadSession();
+    }
+    /**
+     * Create platform adapter based on available modules
+     */
+    createAdapter() {
+        // Check if we're in a web environment
+        // eslint-disable-next-line no-undef
+        if (typeof globalThis !== 'undefined' && globalThis.window && globalThis.document) {
+            // Web platform
+            return new web_1.WebAdapter();
+        }
+        // Try to detect Expo environment
+        try {
+            // Check if expo-linking is available
+            if (typeof require !== 'undefined') {
+                const expoLinking = require('expo-linking');
+                if (expoLinking) {
+                    return new expo_1.ExpoAdapter();
+                }
+            }
+        }
+        catch {
+            // expo-linking not available, continue to React Native adapter
+        }
+        // Fall back to React Native adapter
+        // This will work for both React Native CLI and Expo (since Expo also has react-native)
+        return new react_native_1.ReactNativeAdapter();
+    }
+    /**
+     * Set up URL listener for wallet callbacks
+     */
+    setupURLListener() {
+        this.urlUnsubscribe = this.adapter.addURLListener((url) => {
+            this.handleCallback(url);
+        });
+        // Also check initial URL (when app was opened via deep link)
+        this.adapter.getInitialURL().then((url) => {
+            if (url) {
+                this.handleCallback(url);
+            }
+        });
+    }
+    /**
+     * Handle callback from wallet
+     */
+    handleCallback(url) {
+        const parsed = (0, protocol_1.parseCallbackURL)(url, this.config.scheme);
+        if (parsed.type === 'connect' && parsed.data) {
+            this.handleConnectionResponse(parsed.data);
+        }
+        else if (parsed.type === 'transaction' && parsed.data) {
+            this.handleTransactionResponse(parsed.data);
+        }
+        else if (parsed.type === 'error' && parsed.data) {
+            const errorData = parsed.data;
+            if (errorData?.error) {
+                if (errorData.error.code === 300 || errorData.error.message?.toLowerCase().includes('reject')) {
+                    this.rejectWithError(new UserRejectedError());
+                }
+                else {
+                    this.rejectWithError(new TonConnectError(errorData.error.message || 'Unknown error', String(errorData.error.code)));
+                }
+            }
+        }
+    }
+    /**
+     * Handle connection response from wallet
+     */
+    handleConnectionResponse(response) {
+        if (!(0, protocol_1.validateConnectionResponse)(response)) {
+            this.rejectWithError(new TonConnectError('Invalid connection response'));
+            return;
+        }
+        // Verify proof if present
+        if (response.proof) {
+            const isValid = (0, crypto_1.verifyConnectionProof)(response, this.config.manifestUrl);
+            if (!isValid) {
+                this.rejectWithError(new TonConnectError('Connection proof verification failed'));
+                return;
+            }
+        }
+        else {
+            // Log warning if proof is missing (security consideration)
+            console.warn('TON Connect: Connection proof missing - wallet may not support proof verification');
+        }
+        const wallet = (0, protocol_1.extractWalletInfo)(response);
+        // Validate session ID before saving
+        if (!this.validateSessionId(response.session)) {
+            this.rejectWithError(new TonConnectError('Invalid session ID format'));
+            return;
+        }
+        // Save session
+        this.saveSession(response.session, wallet).catch((error) => {
+            console.error('TON Connect: Failed to save session:', error);
+            // Continue anyway - connection is still valid
+        });
+        // Update status
+        this.currentStatus = { connected: true, wallet };
+        this.notifyStatusChange();
+        // Resolve connection promise
+        if (this.connectionPromise) {
+            if (this.connectionPromise.timeout !== null) {
+                clearTimeout(this.connectionPromise.timeout);
+            }
+            this.connectionPromise.resolve(wallet);
+            this.connectionPromise = null;
+        }
+    }
+    /**
+     * Handle transaction response from wallet
+     */
+    handleTransactionResponse(response) {
+        if (!(0, protocol_1.validateTransactionResponse)(response)) {
+            this.rejectWithError(new TonConnectError('Invalid transaction response'));
+            return;
+        }
+        // Resolve transaction promise
+        if (this.transactionPromise) {
+            if (this.transactionPromise.timeout !== null) {
+                clearTimeout(this.transactionPromise.timeout);
+            }
+            this.transactionPromise.resolve({
+                boc: response.boc,
+                signature: response.signature,
+            });
+            this.transactionPromise = null;
+        }
+    }
+    /**
+     * Reject current promise with error
+     */
+    rejectWithError(error) {
+        if (this.connectionPromise) {
+            if (this.connectionPromise.timeout !== null) {
+                clearTimeout(this.connectionPromise.timeout);
+            }
+            this.connectionPromise.reject(error);
+            this.connectionPromise = null;
+        }
+        if (this.transactionPromise) {
+            if (this.transactionPromise.timeout !== null) {
+                clearTimeout(this.transactionPromise.timeout);
+            }
+            this.transactionPromise.reject(error);
+            this.transactionPromise = null;
+        }
+    }
+    /**
+     * Connect to wallet
+     */
+    async connect() {
+        // If already connected, return current wallet
+        if (this.currentStatus.connected && this.currentStatus.wallet) {
+            return this.currentStatus.wallet;
+        }
+        // CRITICAL FIX: Check if connection is already in progress
+        if (this.connectionPromise) {
+            throw new ConnectionInProgressError();
+        }
+        // Build connection request URL
+        const url = (0, protocol_1.buildConnectionRequest)(this.config.manifestUrl, this.config.scheme);
+        // Create promise for connection
+        return new Promise((resolve, reject) => {
+            let timeout = null;
+            this.connectionPromise = {
+                resolve: (wallet) => {
+                    if (timeout !== null) {
+                        clearTimeout(timeout);
+                    }
+                    this.connectionPromise = null;
+                    resolve(wallet);
+                },
+                reject: (error) => {
+                    if (timeout !== null) {
+                        clearTimeout(timeout);
+                    }
+                    this.connectionPromise = null;
+                    reject(error);
+                },
+                timeout: null,
+            };
+            // Set timeout
+            timeout = setTimeout(() => {
+                if (this.connectionPromise) {
+                    this.connectionPromise.reject(new ConnectionTimeoutError());
+                }
+            }, this.config.connectionTimeout);
+            this.connectionPromise.timeout = timeout;
+            // Open wallet app
+            this.adapter.openURL(url).catch((error) => {
+                if (this.connectionPromise) {
+                    this.connectionPromise.reject(new TonConnectError(`Failed to open wallet: ${error?.message || String(error)}`));
+                }
+            });
+        });
+    }
+    /**
+     * Send transaction
+     */
+    async sendTransaction(request) {
+        // Validate request
+        const validation = (0, protocol_1.validateTransactionRequest)(request);
+        if (!validation.valid) {
+            throw new TonConnectError(validation.error || 'Invalid transaction request');
+        }
+        // Check if connected
+        if (!this.currentStatus.connected || !this.currentStatus.wallet) {
+            throw new TonConnectError('Not connected to wallet. Call connect() first.');
+        }
+        // CRITICAL FIX: Check if transaction is already in progress
+        if (this.transactionPromise) {
+            throw new TransactionInProgressError();
+        }
+        // Build transaction request URL
+        const url = (0, protocol_1.buildTransactionRequest)(this.config.manifestUrl, request, this.config.scheme);
+        // Create promise for transaction
+        return new Promise((resolve, reject) => {
+            let timeout = null;
+            this.transactionPromise = {
+                resolve: (response) => {
+                    if (timeout !== null) {
+                        clearTimeout(timeout);
+                    }
+                    this.transactionPromise = null;
+                    resolve(response);
+                },
+                reject: (error) => {
+                    if (timeout !== null) {
+                        clearTimeout(timeout);
+                    }
+                    this.transactionPromise = null;
+                    reject(error);
+                },
+                timeout: null,
+            };
+            // Set timeout
+            timeout = setTimeout(() => {
+                if (this.transactionPromise) {
+                    this.transactionPromise.reject(new TransactionTimeoutError());
+                }
+            }, this.config.transactionTimeout);
+            this.transactionPromise.timeout = timeout;
+            // Open wallet app
+            this.adapter.openURL(url).catch((error) => {
+                if (this.transactionPromise) {
+                    this.transactionPromise.reject(new TonConnectError(`Failed to open wallet: ${error?.message || String(error)}`));
+                }
+            });
+        });
+    }
+    /**
+     * Disconnect from wallet
+     */
+    async disconnect() {
+        // Clear session
+        await this.clearSession();
+        // Update status
+        this.currentStatus = { connected: false, wallet: null };
+        this.notifyStatusChange();
+    }
+    /**
+     * Get current connection status
+     */
+    getStatus() {
+        return { ...this.currentStatus };
+    }
+    /**
+     * Subscribe to status changes
+     */
+    onStatusChange(callback) {
+        this.statusChangeCallbacks.add(callback);
+        // Immediately call with current status
+        callback(this.getStatus());
+        // Return unsubscribe function
+        return () => {
+            this.statusChangeCallbacks.delete(callback);
+        };
+    }
+    /**
+     * Notify all status change callbacks
+     */
+    notifyStatusChange() {
+        const status = this.getStatus();
+        this.statusChangeCallbacks.forEach((callback) => {
+            try {
+                callback(status);
+            }
+            catch (error) {
+                // Ignore errors in callbacks
+            }
+        });
+    }
+    /**
+     * Validate session ID format
+     */
+    validateSessionId(sessionId) {
+        if (!sessionId || typeof sessionId !== 'string') {
+            return false;
+        }
+        // Session ID should be reasonable length (1-200 characters)
+        if (sessionId.length === 0 || sessionId.length > 200) {
+            return false;
+        }
+        // Basic validation: should not contain control characters
+        if (/[\x00-\x1F\x7F]/.test(sessionId)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Save session to storage
+     */
+    async saveSession(sessionId, wallet) {
+        // Validate inputs
+        if (!this.validateSessionId(sessionId)) {
+            throw new TonConnectError('Invalid session ID format');
+        }
+        if (!wallet || !wallet.address || !wallet.publicKey) {
+            throw new TonConnectError('Invalid wallet data');
+        }
+        try {
+            const sessionKey = `${this.config.storageKeyPrefix}session`;
+            const walletKey = `${this.config.storageKeyPrefix}wallet`;
+            await this.adapter.setItem(sessionKey, sessionId);
+            await this.adapter.setItem(walletKey, JSON.stringify(wallet));
+        }
+        catch (error) {
+            // Log error but don't throw - connection is still valid
+            console.error('TON Connect: Failed to save session to storage:', error);
+        }
+    }
+    /**
+     * Load session from storage
+     */
+    async loadSession() {
+        try {
+            const sessionKey = `${this.config.storageKeyPrefix}session`;
+            const walletKey = `${this.config.storageKeyPrefix}wallet`;
+            const sessionId = await this.adapter.getItem(sessionKey);
+            const walletJson = await this.adapter.getItem(walletKey);
+            if (sessionId && walletJson) {
+                try {
+                    // Validate session ID
+                    if (!this.validateSessionId(sessionId)) {
+                        await this.clearSession();
+                        return;
+                    }
+                    const wallet = JSON.parse(walletJson);
+                    // Validate wallet data
+                    if (!wallet || !wallet.address || !wallet.publicKey) {
+                        await this.clearSession();
+                        return;
+                    }
+                    this.currentStatus = { connected: true, wallet };
+                    this.notifyStatusChange();
+                }
+                catch (error) {
+                    // Invalid wallet data, clear it
+                    console.error('TON Connect: Invalid session data, clearing:', error);
+                    await this.clearSession();
+                }
+            }
+        }
+        catch (error) {
+            // Log storage errors for debugging
+            console.error('TON Connect: Failed to load session from storage:', error);
+        }
+    }
+    /**
+     * Clear session from storage
+     */
+    async clearSession() {
+        try {
+            const sessionKey = `${this.config.storageKeyPrefix}session`;
+            const walletKey = `${this.config.storageKeyPrefix}wallet`;
+            await this.adapter.removeItem(sessionKey);
+            await this.adapter.removeItem(walletKey);
+        }
+        catch (error) {
+            // Ignore storage errors
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        if (this.urlUnsubscribe) {
+            this.urlUnsubscribe();
+            this.urlUnsubscribe = null;
+        }
+        if ('destroy' in this.adapter && typeof this.adapter.destroy === 'function') {
+            this.adapter.destroy();
+        }
+        this.statusChangeCallbacks.clear();
+        this.connectionPromise = null;
+        this.transactionPromise = null;
+    }
+}
+exports.TonConnectMobile = TonConnectMobile;
+// Export types
+__exportStar(require("./types"), exports);

package/dist/types/index.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Core types for TON Connect Mobile SDK
+ * These types define the protocol structure for TonConnect
+ */
+/**
+ * Wallet information returned after successful connection
+ */
+export interface WalletInfo {
+    /** Wallet name (e.g., "Tonkeeper", "MyTonWallet") */
+    name: string;
+    /** Wallet app name */
+    appName: string;
+    /** Wallet app version */
+    version: string;
+    /** Platform (ios/android) */
+    platform: 'ios' | 'android' | 'unknown';
+    /** TON address of the connected wallet */
+    address: string;
+    /** Public key in hex format */
+    publicKey: string;
+    /** Wallet icon URL */
+    icon?: string;
+}
+/**
+ * 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...) */
+    address: string;
+    /** Amount in nanotons (1 TON = 1,000,000,000 nanotons) */
+    amount: string;
+    /** Optional message payload (base64 encoded) */
+    payload?: string;
+    /** Optional state init (base64 encoded) */
+    stateInit?: string;
+}
+/**
+ * Transaction request parameters
+ */
+export interface SendTransactionRequest {
+    /** Unix timestamp (ms) when the request expires */
+    validUntil: number;
+    /** Array of messages to send */
+    messages: TransactionMessage[];
+    /** Optional network (mainnet/testnet) */
+    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 URL scheme */
+    returnStrategy?: 'back' | 'none';
+}
+/**
+ * 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 */
+    returnStrategy?: 'back' | '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
+ */
+export interface PlatformAdapter {
+    /** Open a deep link URL */
+    openURL(url: string): 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>;
+}
+/**
+ * SDK configuration
+ */
+export interface TonConnectMobileConfig {
+    /** Manifest URL (required) */
+    manifestUrl: string;
+    /** Deep link scheme for callbacks (required) */
+    scheme: string;
+    /** Optional storage key prefix */
+    storageKeyPrefix?: string;
+    /** Optional connection timeout in ms (default: 300000 = 5 minutes) */
+    connectionTimeout?: number;
+    /** Optional transaction timeout in ms (default: 300000 = 5 minutes) */
+    transactionTimeout?: number;
+}
+/**
+ * Event listener callback type
+ */
+export type StatusChangeCallback = (status: ConnectionStatus) => void;

package/dist/types/index.js

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