toss-expo-sdk 0.1.2 → 1.0.2

package/src/utils/compression.ts

@@ -0,0 +1,247 @@
+/**
+ * Compression Utilities for TOSS
+ *
+ * Implements safe, deterministic compression for metadata only.
+ * Transaction bytes are NEVER compressed to preserve determinism.
+ *
+ * Production-ready with official APIs.
+ */
+
+import { Buffer } from 'buffer';
+
+/**
+ * Simple DEFLATE-based compression using native zlib
+ * (Available in Node.js and via polyfills in React Native)
+ *
+ * For metadata compression: memos, recipient names, etc.
+ * NOT for transaction signatures or amounts!
+ */
+export interface CompressionResult {
+  compressed: boolean;
+  data: Uint8Array;
+  originalSize: number;
+  compressedSize: number;
+  compressionRatio: number;
+}
+
+/**
+ * Compress metadata safely
+ * Only compresses if compression saves >10% and data >200 bytes
+ *
+ * Safe for: memo text, user names, descriptions
+ * UNSAFE for: signatures, amounts, transaction data
+ */
+export async function compressMetadata(
+  data: string
+): Promise<CompressionResult> {
+  try {
+    const originalBuffer = Buffer.from(data, 'utf-8');
+    const originalSize = originalBuffer.length;
+
+    // Only compress if it's worth it
+    if (originalSize < 200) {
+      return {
+        compressed: false,
+        data: new Uint8Array(originalBuffer),
+        originalSize,
+        compressedSize: originalSize,
+        compressionRatio: 1.0,
+      };
+    }
+
+    // Use native compression if available (Node.js)
+    // For React Native, this will use a polyfill
+    const zlib = await importZlib();
+
+    const compressed = await new Promise<Buffer>((resolve, reject) => {
+      zlib.deflate(originalBuffer, (err: any, result: Buffer) => {
+        if (err) reject(err);
+        else resolve(result);
+      });
+    });
+
+    const compressedSize = compressed.length;
+    const compressionRatio = compressedSize / originalSize;
+
+    // Only use compression if it saves >10%
+    if (compressionRatio > 0.9) {
+      return {
+        compressed: false,
+        data: new Uint8Array(originalBuffer),
+        originalSize,
+        compressedSize: originalSize,
+        compressionRatio: 1.0,
+      };
+    }
+
+    return {
+      compressed: true,
+      data: new Uint8Array(compressed),
+      originalSize,
+      compressedSize,
+      compressionRatio,
+    };
+  } catch (error) {
+    // Graceful fallback: if compression fails, return uncompressed
+    console.warn('Compression failed, returning uncompressed:', error);
+    const buffer = Buffer.from(data, 'utf-8');
+    return {
+      compressed: false,
+      data: new Uint8Array(buffer),
+      originalSize: buffer.length,
+      compressedSize: buffer.length,
+      compressionRatio: 1.0,
+    };
+  }
+}
+
+/**
+ * Decompress metadata
+ */
+export async function decompressMetadata(data: Uint8Array): Promise<string> {
+  try {
+    const zlib = await importZlib();
+
+    const decompressed = await new Promise<Buffer>((resolve, reject) => {
+      zlib.inflate(Buffer.from(data), (err: any, result: Buffer) => {
+        if (err) reject(err);
+        else resolve(result);
+      });
+    });
+
+    return decompressed.toString('utf-8');
+  } catch (error) {
+    console.warn('Decompression failed:', error);
+    // Assume data was not compressed
+    return Buffer.from(data).toString('utf-8');
+  }
+}
+
+/**
+ * Compress intent metadata for efficient transmission
+ * Returns the original intent with compressed metadata
+ */
+export async function compressIntentMetadata(
+  intentMetadata: Record<string, any>
+): Promise<{
+  original: Record<string, any>;
+  compressed: Record<string, any>;
+  savings: number;
+}> {
+  const compressed: Record<string, any> = {};
+  let totalOriginal = 0;
+  let totalCompressed = 0;
+
+  for (const [key, value] of Object.entries(intentMetadata)) {
+    if (typeof value === 'string') {
+      const result = await compressMetadata(value);
+      totalOriginal += result.originalSize;
+      totalCompressed += result.compressedSize;
+
+      if (result.compressed) {
+        compressed[key] = {
+          __compressed: true,
+          data: Array.from(result.data),
+        };
+      } else {
+        compressed[key] = value;
+      }
+    } else {
+      compressed[key] = value;
+    }
+  }
+
+  const savings =
+    totalOriginal > 0 ? ((totalOriginal - totalCompressed) / totalOriginal) * 100 : 0;
+
+  return {
+    original: intentMetadata,
+    compressed,
+    savings: Math.round(savings),
+  };
+}
+
+/**
+ * Decompress intent metadata
+ */
+export async function decompressIntentMetadata(
+  compressedMetadata: Record<string, any>
+): Promise<Record<string, any>> {
+  const decompressed: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(compressedMetadata)) {
+    if (
+      typeof value === 'object' &&
+      value !== null &&
+      value.__compressed === true
+    ) {
+      const buffer = new Uint8Array(value.data);
+      decompressed[key] = await decompressMetadata(buffer);
+    } else {
+      decompressed[key] = value;
+    }
+  }
+
+  return decompressed;
+}
+
+/**
+ * Lazy-load zlib to avoid breaking in environments without it
+ */
+async function importZlib(): Promise<any> {
+  // In Node.js, use native zlib
+  if (typeof require !== 'undefined') {
+    try {
+      return require('zlib');
+    } catch {
+      // Fall through to polyfill
+    }
+  }
+
+  // For React Native, try to use a polyfill
+  // This can be pako (pako-zlib) or similar
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const pako = await import('pako' as string) as any;
+    return {
+      deflate: (data: Buffer, callback: any) => {
+        try {
+          const compressed = pako.deflate(data);
+          callback(null, Buffer.from(compressed));
+        } catch (err) {
+          callback(err);
+        }
+      },
+      inflate: (data: Buffer, callback: any) => {
+        try {
+          const decompressed = pako.inflate(data);
+          callback(null, Buffer.from(decompressed));
+        } catch (err) {
+          callback(err);
+        }
+      },
+    };
+  } catch {
+    throw new Error(
+      'Compression not available in this environment. Install pako or use Node.js.'
+    );
+  }
+}
+
+/**
+ * Calculate size savings for a metadata object
+ */
+export function estimateCompressionSavings(
+  metadata: Record<string, any>
+): number {
+  let totalSize = 0;
+
+  for (const value of Object.values(metadata)) {
+    if (typeof value === 'string') {
+      totalSize += value.length;
+    }
+  }
+
+  // Conservative estimate: ~35% savings on text (typical for DEFLATE)
+  return Math.round(totalSize * 0.35);
+}

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;
+  }
+}