toss-expo-sdk 1.0.1 → 1.0.4

package/src/wifi.ts

@@ -0,0 +1,401 @@
+/**
+ * WiFi Direct Transport for TOSS
+ *
+ * Higher-bandwidth alternative to BLE for device-to-device communication
+ * Fallback to BLE if WiFi Direct unavailable
+ *
+ * Uses native React Native APIs for production-ready implementation
+ */
+
+import { NativeModules, Platform } from 'react-native';
+import type { SolanaIntent } from './intent';
+import type { OfflineTransaction } from './types/nonceAccount';
+import { TossError } from './errors';
+
+const { WiFiDirect } = NativeModules;
+
+/**
+ * WiFi Direct connection state
+ */
+export interface WiFiDirectPeer {
+  deviceName: string;
+  deviceAddress: string;
+  isGroupOwner: boolean;
+  signalStrength?: number;
+}
+
+/**
+ * WiFi Direct socket for data transmission
+ */
+export interface WiFiDirectSocket {
+  peerId: string;
+  connected: boolean;
+  bytesTransferred: number;
+  lastActivityTime: number;
+}
+
+/**
+ * WiFi Direct Transport Handler
+ * Wrapper around native WiFi Direct capabilities
+ *
+ * Supports higher MTU (1200+ bytes) than BLE (480 bytes)
+ * Useful for batch transmission of intents
+ */
+export class WiFiDirectTransport {
+  private connectedPeers: Map<string, WiFiDirectSocket> = new Map();
+  private readonly SOCKET_TIMEOUT = 30000; // 30 seconds
+  private readonly WIFI_MTU = 1200; // Conservative MTU for WiFi packets
+
+  constructor(_platform: 'android' | 'ios' = 'android') {
+    if (!WiFiDirect) {
+      console.warn(
+        'WiFi Direct not available in this environment (requires native module)'
+      );
+    }
+  }
+
+  /**
+   * Check if WiFi Direct is available on device
+   */
+  async isAvailable(): Promise<boolean> {
+    if (!WiFiDirect) {
+      return false;
+    }
+
+    try {
+      if (Platform.OS === 'android') {
+        return await WiFiDirect.isAvailable();
+      }
+      // iOS uses different APIs (Bonjour, Multipeer Connectivity)
+      return true;
+    } catch (error) {
+      console.warn('Error checking WiFi Direct availability:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Enable WiFi Direct on device
+   */
+  async enable(): Promise<void> {
+    if (!WiFiDirect) {
+      throw new TossError(
+        'WiFi Direct native module not available',
+        'WIFI_DIRECT_UNAVAILABLE'
+      );
+    }
+
+    try {
+      if (Platform.OS === 'android') {
+        await WiFiDirect.enable();
+      }
+    } catch (error) {
+      throw new TossError(
+        `Failed to enable WiFi Direct: ${error instanceof Error ? error.message : String(error)}`,
+        'WIFI_DIRECT_ERROR'
+      );
+    }
+  }
+
+  /**
+   * Discover nearby WiFi Direct peers
+   */
+  async discoverPeers(timeoutSeconds: number = 10): Promise<WiFiDirectPeer[]> {
+    if (!WiFiDirect) {
+      return [];
+    }
+
+    try {
+      const peers = await WiFiDirect.discoverPeers(timeoutSeconds * 1000);
+      return peers.map((p: any) => ({
+        deviceName: p.deviceName,
+        deviceAddress: p.deviceAddress,
+        isGroupOwner: p.isGroupOwner,
+        signalStrength: p.signalStrength,
+      }));
+    } catch (error) {
+      console.warn('Peer discovery failed:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Connect to a specific WiFi Direct peer
+   */
+  async connectToPeer(deviceAddress: string): Promise<WiFiDirectSocket> {
+    if (!WiFiDirect) {
+      throw new TossError(
+        'WiFi Direct not available',
+        'WIFI_DIRECT_UNAVAILABLE'
+      );
+    }
+
+    try {
+      const socket: WiFiDirectSocket = {
+        peerId: deviceAddress,
+        connected: false,
+        bytesTransferred: 0,
+        lastActivityTime: Date.now(),
+      };
+
+      await WiFiDirect.connect(deviceAddress);
+
+      socket.connected = true;
+      this.connectedPeers.set(deviceAddress, socket);
+
+      return socket;
+    } catch (error) {
+      throw new TossError(
+        `Failed to connect to WiFi Direct peer: ${error instanceof Error ? error.message : String(error)}`,
+        'WIFI_DIRECT_CONNECT_ERROR'
+      );
+    }
+  }
+
+  /**
+   * Send intent via WiFi Direct connection
+   * Uses larger MTU than BLE for efficiency
+   */
+  async sendIntent(
+    socket: WiFiDirectSocket,
+    intent: SolanaIntent
+  ): Promise<{
+    success: boolean;
+    bytesTransferred: number;
+    chunks: number;
+  }> {
+    if (!socket.connected) {
+      throw new TossError(
+        'WiFi Direct socket not connected',
+        'WIFI_DIRECT_DISCONNECTED'
+      );
+    }
+
+    try {
+      const intentBuffer = Buffer.from(JSON.stringify(intent), 'utf-8');
+      const chunks = Math.ceil(intentBuffer.length / this.WIFI_MTU);
+
+      let totalTransferred = 0;
+
+      for (let i = 0; i < chunks; i++) {
+        const start = i * this.WIFI_MTU;
+        const end = Math.min(start + this.WIFI_MTU, intentBuffer.length);
+        const chunk = intentBuffer.slice(start, end);
+
+        // Send with simple header: chunk number + total chunks
+        const chunkHeader = Buffer.allocUnsafe(2);
+        chunkHeader.writeUInt8(i, 0);
+        chunkHeader.writeUInt8(chunks, 1);
+
+        const packet = Buffer.concat([chunkHeader, chunk]);
+
+        await WiFiDirect.sendData(socket.peerId, packet);
+
+        totalTransferred += chunk.length;
+
+        // Update socket stats
+        socket.bytesTransferred += chunk.length;
+        socket.lastActivityTime = Date.now();
+
+        // Small delay between chunks to avoid congestion
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+
+      return {
+        success: true,
+        bytesTransferred: totalTransferred,
+        chunks,
+      };
+    } catch (error) {
+      throw new TossError(
+        `Failed to send intent via WiFi Direct: ${error instanceof Error ? error.message : String(error)}`,
+        'WIFI_DIRECT_SEND_ERROR'
+      );
+    }
+  }
+
+  /**
+   * Send offline transaction via WiFi Direct
+   */
+  async sendOfflineTransaction(
+    socket: WiFiDirectSocket,
+    transaction: OfflineTransaction
+  ): Promise<{
+    success: boolean;
+    bytesTransferred: number;
+    chunks: number;
+  }> {
+    const txBuffer = Buffer.from(JSON.stringify(transaction), 'utf-8');
+    const chunks = Math.ceil(txBuffer.length / this.WIFI_MTU);
+
+    let totalTransferred = 0;
+
+    for (let i = 0; i < chunks; i++) {
+      const start = i * this.WIFI_MTU;
+      const end = Math.min(start + this.WIFI_MTU, txBuffer.length);
+      const chunk = txBuffer.slice(start, end);
+
+      const chunkHeader = Buffer.allocUnsafe(2);
+      chunkHeader.writeUInt8(i, 0);
+      chunkHeader.writeUInt8(chunks, 1);
+
+      const packet = Buffer.concat([chunkHeader, chunk]);
+
+      await WiFiDirect.sendData(socket.peerId, packet);
+
+      totalTransferred += chunk.length;
+      socket.bytesTransferred += chunk.length;
+      socket.lastActivityTime = Date.now();
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+
+    return {
+      success: true,
+      bytesTransferred: totalTransferred,
+      chunks,
+    };
+  }
+
+  /**
+   * Receive data from WiFi Direct peer
+   */
+  async receiveData(
+    socket: WiFiDirectSocket,
+    expectedChunks: number
+  ): Promise<Buffer> {
+    const chunks: Buffer[] = [];
+    const receivedChunks = new Set<number>();
+
+    try {
+      while (receivedChunks.size < expectedChunks) {
+        const packet = await WiFiDirect.receiveData(socket.peerId, 5000); // 5 second timeout
+
+        if (packet) {
+          const chunkNumber = packet[0];
+          // Header byte (not used in reassembly)
+          const chunkData = packet.slice(2);
+
+          chunks[chunkNumber] = chunkData;
+          receivedChunks.add(chunkNumber);
+
+          socket.lastActivityTime = Date.now();
+        }
+
+        // Check timeout
+        if (Date.now() - socket.lastActivityTime > this.SOCKET_TIMEOUT) {
+          throw new TossError(
+            'WiFi Direct socket timeout',
+            'WIFI_DIRECT_TIMEOUT'
+          );
+        }
+      }
+
+      return Buffer.concat(chunks);
+    } catch (error) {
+      throw new TossError(
+        `Failed to receive data via WiFi Direct: ${error instanceof Error ? error.message : String(error)}`,
+        'WIFI_DIRECT_RECEIVE_ERROR'
+      );
+    }
+  }
+
+  /**
+   * Disconnect from WiFi Direct peer
+   */
+  async disconnect(peerId: string): Promise<void> {
+    try {
+      const socket = this.connectedPeers.get(peerId);
+
+      if (socket) {
+        socket.connected = false;
+        this.connectedPeers.delete(peerId);
+      }
+
+      if (WiFiDirect) {
+        await WiFiDirect.disconnect(peerId);
+      }
+    } catch (error) {
+      console.warn(`Error disconnecting from ${peerId}:`, error);
+    }
+  }
+
+  /**
+   * Get all connected peers
+   */
+  getConnectedPeers(): WiFiDirectSocket[] {
+    return Array.from(this.connectedPeers.values()).filter(
+      (socket) => socket.connected
+    );
+  }
+
+  /**
+   * Get MTU size for this transport
+   */
+  getMTU(): number {
+    return this.WIFI_MTU;
+  }
+
+  /**
+   * Clean up expired connections
+   */
+  cleanupExpiredConnections(): void {
+    const now = Date.now();
+
+    for (const [peerId, socket] of this.connectedPeers.entries()) {
+      if (now - socket.lastActivityTime > this.SOCKET_TIMEOUT) {
+        this.disconnect(peerId).catch(() => {});
+      }
+    }
+  }
+}
+
+/**
+ * Smart transport selector
+ * Automatically chooses best transport for given context
+ */
+export class SmartTransportSelector {
+  private wifiDirect: WiFiDirectTransport;
+
+  constructor() {
+    this.wifiDirect = new WiFiDirectTransport();
+  }
+
+  /**
+   * Select best available transport for intent transmission
+   *
+   * Preference order:
+   * 1. WiFi Direct (fastest, 1200 MTU)
+   * 2. BLE (fallback, 480 MTU)
+   */
+  async selectTransport(): Promise<'wifi' | 'ble'> {
+    const wifiAvailable = await this.wifiDirect.isAvailable();
+
+    if (wifiAvailable) {
+      return 'wifi';
+    }
+
+    return 'ble';
+  }
+
+  /**
+   * Check if WiFi Direct should be used
+   * Factors: availability, proximity, battery level
+   */
+  async shouldUseWiFi(checkBattery: boolean = false): Promise<boolean> {
+    const available = await this.wifiDirect.isAvailable();
+
+    if (!available) {
+      return false;
+    }
+
+    // Optional: check battery level
+    if (checkBattery) {
+      // In production, query Battery API
+      // For now, assume battery OK
+      return true;
+    }
+
+    return true;
+  }
+}