@blazium/ton-connect-mobile 1.0.0

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@blazium/ton-connect-mobile",
+  "version": "1.0.0",
+  "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",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blaziumdev/ton-connect-mobile.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "example": "cd example && npm start"
+  },
+  "keywords": [
+    "ton",
+    "tonconnect",
+    "react-native",
+    "expo",
+    "blockchain",
+    "wallet",
+    "mobile",
+    "sdk"
+  ],
+  "author": "BlaziumDev",
+  "license": "MIT",
+  "dependencies": {
+    "tweetnacl": "^1.0.3",
+    "tweetnacl-util": "^0.15.1",
+    "react-native-get-random-values": "^1.9.0"
+  },
+  "peerDependencies": {
+    "react-native": "*"
+  },
+  "peerDependenciesMeta": {
+    "expo-linking": {
+      "optional": true
+    },
+    "expo-crypto": {
+      "optional": true
+    },
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/react-native": "^0.72.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "src"
+  ]
+}
+

package/src/adapters/expo.ts

@@ -0,0 +1,160 @@
+/**
+ * Expo platform adapter
+ * Handles deep linking, storage, and crypto for Expo environments
+ */
+
+// Type declarations for runtime globals
+declare const require: {
+  (id: string): any;
+};
+
+import { PlatformAdapter } from '../types';
+
+// Dynamic imports to handle optional dependencies
+let Linking: any;
+let Crypto: any;
+let AsyncStorage: any;
+
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  Linking = require('expo-linking');
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  Crypto = require('expo-crypto');
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  AsyncStorage = require('@react-native-async-storage/async-storage').default;
+} catch {
+  // Dependencies not available
+}
+
+/**
+ * Expo platform adapter implementation
+ */
+export class ExpoAdapter implements PlatformAdapter {
+  private urlListeners: Array<(url: string) => void> = [];
+  private subscription: { remove: () => void } | null = null;
+
+  constructor() {
+    // Set up URL listener
+    this.setupURLListener();
+  }
+
+  private setupURLListener(): void {
+    if (!Linking) {
+      return;
+    }
+    // Listen for deep links when app is already open
+    this.subscription = Linking.addEventListener('url', (event: { url: string }) => {
+      this.urlListeners.forEach((listener) => listener(event.url));
+    });
+  }
+
+  async openURL(url: string): Promise<boolean> {
+    if (!Linking) {
+      throw new Error('expo-linking is not available');
+    }
+    try {
+      const canOpen = await Linking.canOpenURL(url);
+      if (!canOpen) {
+        return false;
+      }
+      await Linking.openURL(url);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async getInitialURL(): Promise<string | null> {
+    if (!Linking) {
+      return null;
+    }
+    try {
+      return await Linking.getInitialURL();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  addURLListener(callback: (url: string) => void): () => void {
+    this.urlListeners.push(callback);
+    
+    // Return unsubscribe function
+    return () => {
+      const index = this.urlListeners.indexOf(callback);
+      if (index > -1) {
+        this.urlListeners.splice(index, 1);
+      }
+    };
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    if (!AsyncStorage) {
+      throw new Error('@react-native-async-storage/async-storage is not available');
+    }
+    try {
+      await AsyncStorage.setItem(key, value);
+    } catch (error: any) {
+      throw new Error(`Failed to set storage item: ${error?.message || error}`);
+    }
+  }
+
+  async getItem(key: string): Promise<string | null> {
+    if (!AsyncStorage) {
+      return null;
+    }
+    try {
+      return await AsyncStorage.getItem(key);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async removeItem(key: string): Promise<void> {
+    if (!AsyncStorage) {
+      return;
+    }
+    try {
+      await AsyncStorage.removeItem(key);
+    } catch (error) {
+      // Ignore errors on remove
+    }
+  }
+
+  async randomBytes(length: number): Promise<Uint8Array> {
+    if (Crypto) {
+      try {
+        // Use expo-crypto for random bytes
+        const randomString = await Crypto.getRandomBytesAsync(length);
+        return randomString;
+      } catch (error) {
+        // Fall through to crypto.getRandomValues check
+      }
+    }
+    
+    // HIGH FIX: Try crypto.getRandomValues as fallback
+    // eslint-disable-next-line no-undef
+    if (typeof globalThis !== 'undefined' && (globalThis as any).crypto && (globalThis as any).crypto.getRandomValues) {
+      const bytes = new Uint8Array(length);
+      (globalThis as any).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 ensure expo-crypto is installed or use react-native-get-random-values'
+    );
+  }
+
+  /**
+   * Cleanup resources
+   */
+  destroy(): void {
+    if (this.subscription) {
+      this.subscription.remove();
+      this.subscription = null;
+    }
+    this.urlListeners = [];
+  }
+}
+

package/src/adapters/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Platform adapter exports
+ */
+
+export { ExpoAdapter } from './expo';
+export { ReactNativeAdapter } from './react-native';
+export { WebAdapter } from './web';
+

package/src/adapters/react-native.ts

@@ -0,0 +1,148 @@
+/**
+ * React Native platform adapter
+ * Handles deep linking and storage for React Native CLI environments
+ */
+
+// Type declarations for runtime globals
+declare const require: {
+  (id: string): any;
+};
+
+import { PlatformAdapter } from '../types';
+
+// Dynamic imports to handle optional dependencies
+let Linking: any;
+let AsyncStorage: any;
+
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const RN = require('react-native');
+  Linking = RN.Linking;
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  AsyncStorage = require('@react-native-async-storage/async-storage').default;
+} catch {
+  // Dependencies not available
+}
+
+/**
+ * React Native platform adapter implementation
+ */
+export class ReactNativeAdapter implements PlatformAdapter {
+  private urlListeners: Array<(url: string) => void> = [];
+  private subscription: { remove: () => void } | null = null;
+
+  constructor() {
+    // Set up URL listener
+    this.setupURLListener();
+  }
+
+  private setupURLListener(): void {
+    if (!Linking) {
+      return;
+    }
+    // Listen for deep links when app is already open
+    this.subscription = Linking.addEventListener('url', (event: { url: string }) => {
+      this.urlListeners.forEach((listener) => listener(event.url));
+    });
+  }
+
+  async openURL(url: string): Promise<boolean> {
+    if (!Linking) {
+      throw new Error('react-native Linking is not available');
+    }
+    try {
+      const canOpen = await Linking.canOpenURL(url);
+      if (!canOpen) {
+        return false;
+      }
+      await Linking.openURL(url);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async getInitialURL(): Promise<string | null> {
+    if (!Linking) {
+      return null;
+    }
+    try {
+      return await Linking.getInitialURL();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  addURLListener(callback: (url: string) => void): () => void {
+    this.urlListeners.push(callback);
+    
+    // Return unsubscribe function
+    return () => {
+      const index = this.urlListeners.indexOf(callback);
+      if (index > -1) {
+        this.urlListeners.splice(index, 1);
+      }
+    };
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    if (!AsyncStorage) {
+      throw new Error('@react-native-async-storage/async-storage is not available');
+    }
+    try {
+      await AsyncStorage.setItem(key, value);
+    } catch (error: any) {
+      throw new Error(`Failed to set storage item: ${error?.message || error}`);
+    }
+  }
+
+  async getItem(key: string): Promise<string | null> {
+    if (!AsyncStorage) {
+      return null;
+    }
+    try {
+      return await AsyncStorage.getItem(key);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async removeItem(key: string): Promise<void> {
+    if (!AsyncStorage) {
+      return;
+    }
+    try {
+      await AsyncStorage.removeItem(key);
+    } catch (error) {
+      // Ignore errors on remove
+    }
+  }
+
+  async randomBytes(length: number): Promise<Uint8Array> {
+    // HIGH FIX: Use crypto.getRandomValues if available (with polyfill)
+    // eslint-disable-next-line no-undef
+    if (typeof globalThis !== 'undefined' && (globalThis as any).crypto && (globalThis as any).crypto.getRandomValues) {
+      const bytes = new Uint8Array(length);
+      (globalThis as any).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: npm install react-native-get-random-values'
+    );
+  }
+
+  /**
+   * Cleanup resources
+   */
+  destroy(): void {
+    if (this.subscription) {
+      this.subscription.remove();
+      this.subscription = null;
+    }
+    this.urlListeners = [];
+  }
+}
+

package/src/adapters/web.ts

@@ -0,0 +1,176 @@
+/**
+ * Web platform adapter
+ * Handles deep linking and storage for web environments
+ */
+
+// Type declarations for browser APIs
+declare const window: {
+  location: {
+    href: string;
+  };
+  open(url: string, target?: string): any;
+  addEventListener(type: string, listener: () => void): void;
+  removeEventListener(type: string, listener: () => void): void;
+  localStorage: {
+    setItem(key: string, value: string): void;
+    getItem(key: string): string | null;
+    removeItem(key: string): void;
+  };
+  crypto: {
+    getRandomValues(array: Uint8Array): Uint8Array;
+  };
+} | undefined;
+
+import { PlatformAdapter } from '../types';
+
+/**
+ * Web platform adapter implementation
+ * Uses browser APIs for deep linking and localStorage for storage
+ */
+export class WebAdapter implements PlatformAdapter {
+  private urlListeners: Array<(url: string) => void> = [];
+  private isListening = false;
+
+  constructor() {
+    // Set up URL listener
+    this.setupURLListener();
+  }
+
+  private setupURLListener(): void {
+    // Listen for hash changes (web deep links)
+    if (typeof window !== 'undefined') {
+      window.addEventListener('hashchange', () => {
+        this.handleURLChange();
+      });
+      
+      // Also check on popstate (browser back/forward)
+      window.addEventListener('popstate', () => {
+        this.handleURLChange();
+      });
+      
+      this.isListening = true;
+    }
+  }
+
+  private handleURLChange(): void {
+    if (typeof window === 'undefined') return;
+    
+    const url = window.location.href;
+    this.urlListeners.forEach((listener) => {
+      try {
+        listener(url);
+      } catch (error) {
+        // Ignore errors in listeners
+      }
+    });
+  }
+
+  async openURL(url: string): Promise<boolean> {
+    try {
+      if (typeof window !== 'undefined') {
+        // For web, we can use window.open or window.location
+        // For deep links to mobile wallets, we'll use window.location
+        if (url.startsWith('tonconnect://')) {
+          // Try to open in new window/tab, fallback to current window
+          const opened = window.open(url, '_blank');
+          if (!opened) {
+            // Popup blocked, try current window
+            window.location.href = url;
+          }
+          return true;
+        } else {
+          window.location.href = url;
+          return true;
+        }
+      }
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async getInitialURL(): Promise<string | null> {
+    if (typeof window !== 'undefined') {
+      return window.location.href;
+    }
+    return null;
+  }
+
+  addURLListener(callback: (url: string) => void): () => void {
+    this.urlListeners.push(callback);
+    
+    // Immediately check current URL
+    if (typeof window !== 'undefined') {
+      try {
+        callback(window.location.href);
+      } catch (error) {
+        // Ignore errors
+      }
+    }
+    
+    // Return unsubscribe function
+    return () => {
+      const index = this.urlListeners.indexOf(callback);
+      if (index > -1) {
+        this.urlListeners.splice(index, 1);
+      }
+    };
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    if (typeof window === 'undefined' || !window.localStorage) {
+      throw new Error('localStorage is not available');
+    }
+    try {
+      window.localStorage.setItem(key, value);
+    } catch (error: any) {
+      throw new Error(`Failed to set storage item: ${error?.message || error}`);
+    }
+  }
+
+  async getItem(key: string): Promise<string | null> {
+    if (typeof window === 'undefined' || !window.localStorage) {
+      return null;
+    }
+    try {
+      return window.localStorage.getItem(key);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async removeItem(key: string): Promise<void> {
+    if (typeof window === 'undefined' || !window.localStorage) {
+      return;
+    }
+    try {
+      window.localStorage.removeItem(key);
+    } catch (error) {
+      // Ignore errors on remove
+    }
+  }
+
+  async randomBytes(length: number): Promise<Uint8Array> {
+    // Use crypto.getRandomValues (available in modern browsers)
+    if (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {
+      const bytes = new Uint8Array(length);
+      window.crypto.getRandomValues(bytes);
+      return bytes;
+    }
+    
+    // Fallback: should not happen in modern browsers
+    throw new Error(
+      'Cryptographically secure random number generation not available. ' +
+      'Please use a modern browser with crypto.getRandomValues support.'
+    );
+  }
+
+  /**
+   * Cleanup resources
+   */
+  destroy(): void {
+    this.urlListeners = [];
+    this.isListening = false;
+  }
+}
+