toss-expo-sdk 0.1.2 → 1.0.2

package/lib/typescript/src/wifi.d.ts

@@ -0,0 +1,116 @@
+/**
+ * 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 type { SolanaIntent } from './intent';
+import type { OfflineTransaction } from './types/nonceAccount';
+/**
+ * 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 declare class WiFiDirectTransport {
+    private connectedPeers;
+    private readonly SOCKET_TIMEOUT;
+    private readonly WIFI_MTU;
+    constructor(_platform?: 'android' | 'ios');
+    /**
+     * Check if WiFi Direct is available on device
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Enable WiFi Direct on device
+     */
+    enable(): Promise<void>;
+    /**
+     * Discover nearby WiFi Direct peers
+     */
+    discoverPeers(timeoutSeconds?: number): Promise<WiFiDirectPeer[]>;
+    /**
+     * Connect to a specific WiFi Direct peer
+     */
+    connectToPeer(deviceAddress: string): Promise<WiFiDirectSocket>;
+    /**
+     * Send intent via WiFi Direct connection
+     * Uses larger MTU than BLE for efficiency
+     */
+    sendIntent(socket: WiFiDirectSocket, intent: SolanaIntent): Promise<{
+        success: boolean;
+        bytesTransferred: number;
+        chunks: number;
+    }>;
+    /**
+     * Send offline transaction via WiFi Direct
+     */
+    sendOfflineTransaction(socket: WiFiDirectSocket, transaction: OfflineTransaction): Promise<{
+        success: boolean;
+        bytesTransferred: number;
+        chunks: number;
+    }>;
+    /**
+     * Receive data from WiFi Direct peer
+     */
+    receiveData(socket: WiFiDirectSocket, expectedChunks: number): Promise<Buffer>;
+    /**
+     * Disconnect from WiFi Direct peer
+     */
+    disconnect(peerId: string): Promise<void>;
+    /**
+     * Get all connected peers
+     */
+    getConnectedPeers(): WiFiDirectSocket[];
+    /**
+     * Get MTU size for this transport
+     */
+    getMTU(): number;
+    /**
+     * Clean up expired connections
+     */
+    cleanupExpiredConnections(): void;
+}
+/**
+ * Smart transport selector
+ * Automatically chooses best transport for given context
+ */
+export declare class SmartTransportSelector {
+    private wifiDirect;
+    constructor();
+    /**
+     * Select best available transport for intent transmission
+     *
+     * Preference order:
+     * 1. WiFi Direct (fastest, 1200 MTU)
+     * 2. BLE (fallback, 480 MTU)
+     */
+    selectTransport(): Promise<'wifi' | 'ble'>;
+    /**
+     * Check if WiFi Direct should be used
+     * Factors: availability, proximity, battery level
+     */
+    shouldUseWiFi(checkBattery?: boolean): Promise<boolean>;
+}
+//# sourceMappingURL=wifi.d.ts.map

package/lib/typescript/src/wifi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wifi.d.ts","sourceRoot":"","sources":["../../../src/wifi.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAK/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,cAAc,CAA4C;IAClE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,SAAS,GAAE,SAAS,GAAG,KAAiB;IAQpD;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAiBrC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB7B;;OAEG;IACG,aAAa,CAAC,cAAc,GAAE,MAAW,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAmB3E;;OAEG;IACG,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA8BrE;;;OAGG;IACG,UAAU,CACd,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,gBAAgB,EAAE,MAAM,CAAC;QACzB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IAmDF;;OAEG;IACG,sBAAsB,CAC1B,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,kBAAkB,GAC9B,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,gBAAgB,EAAE,MAAM,CAAC;QACzB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IAiCF;;OAEG;IACG,WAAW,CACf,MAAM,EAAE,gBAAgB,EACxB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC;IAqClB;;OAEG;IACG,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB/C;;OAEG;IACH,iBAAiB,IAAI,gBAAgB,EAAE;IAMvC;;OAEG;IACH,MAAM,IAAI,MAAM;IAIhB;;OAEG;IACH,yBAAyB,IAAI,IAAI;CASlC;AAED;;;GAGG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,UAAU,CAAsB;;IAMxC;;;;;;OAMG;IACG,eAAe,IAAI,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC;IAUhD;;;OAGG;IACG,aAAa,CAAC,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,OAAO,CAAC;CAgBrE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toss-expo-sdk",
-  "version": "0.1.2",
+  "version": "1.0.2",
   "description": "The official React Native SDK for The Offline Solana Stack (TOSS)",
   "type": "module",
   "main": "./lib/module/index.js",

package/src/__tests__/solana-program-simple.test.ts

@@ -0,0 +1,256 @@
+/**
+ * TOSS Solana Program Integration Tests (Simplified)
+ *
+ * Tests for the toss-intent-processor program
+ * Gap #5: Onchain Intent Verification
+ */
+
+import { Connection, Keypair } from '@solana/web3.js';
+import { createIntent, verifyIntent } from '../intent';
+import { NonceAccountManager } from '../client/NonceAccountManager';
+
+describe('TOSS Solana Intent Processor Program', () => {
+  let connection: Connection;
+  let senderKeypair: Keypair;
+  let recipientKeypair: Keypair;
+  let nonceManager: NonceAccountManager;
+
+  beforeAll(() => {
+    // Use Devnet for testing
+    connection = new Connection('https://api.devnet.solana.com', 'confirmed');
+    senderKeypair = Keypair.generate();
+    recipientKeypair = Keypair.generate();
+    nonceManager = new NonceAccountManager(connection);
+  });
+
+  describe('Intent Signature Verification', () => {
+    it('should create a valid, verifiable intent', async () => {
+      // Create intent
+      const intent = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        1000000,
+        connection,
+        { expiresIn: 60 * 60 }
+      );
+
+      // Verify the intent can be verified
+      expect(intent.signature).toBeDefined();
+      expect(intent.signature.length).toBeGreaterThan(0);
+
+      // Verify intent signature locally (client-side)
+      const isValid = await verifyIntent(intent, connection);
+      expect(isValid).toBe(true);
+    });
+
+    it('should reject modified intent', async () => {
+      const intent = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        1000000,
+        connection
+      );
+
+      // Modify the intent (would fail signature check)
+      const modifiedIntent = { ...intent, amount: 2000000 };
+
+      // Modified intent should fail verification
+      const isValid = await verifyIntent(modifiedIntent, connection);
+      expect(isValid).toBe(false);
+    });
+
+    it('should reject expired intent', async () => {
+      // Create an intent that's already expired
+      const intent = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        1000000,
+        connection,
+        { expiresIn: -100 } // Already expired
+      );
+
+      // Expired intent should fail
+      const isValid = await verifyIntent(intent, connection);
+      expect(isValid).toBe(false);
+    });
+  });
+
+  describe('Intent Program Data Structure', () => {
+    it('should verify intent data structure matches program expectations', async () => {
+      const intent = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        5000000,
+        connection
+      );
+
+      // Verify all required fields for onchain program
+      expect(intent.from).toBeDefined();
+      expect(intent.to).toBeDefined();
+      expect(intent.amount).toBeGreaterThan(0);
+      expect(intent.nonce).toBeGreaterThanOrEqual(0);
+      expect(intent.expiry).toBeGreaterThan(Date.now() / 1000);
+      expect(intent.signature).toBeDefined();
+      expect(intent.blockhash).toBeDefined();
+    });
+
+    it('should enforce expiry constraints', async () => {
+      const now = Math.floor(Date.now() / 1000);
+      const intent = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        1000000,
+        connection,
+        { expiresIn: 3600 } // 1 hour
+      );
+
+      // Expiry should be in future
+      expect(intent.expiry).toBeGreaterThan(now);
+      expect(intent.expiry - now).toBeCloseTo(3600, -1);
+    });
+  });
+
+  describe('Deterministic Settlement', () => {
+    it('should handle settlement with proper sequencing', async () => {
+      // Create multiple intents
+      const intent1 = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        1000000,
+        connection
+      );
+
+      const intent2 = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        2000000,
+        connection
+      );
+
+      // Both should be valid
+      const isValid1 = await verifyIntent(intent1, connection);
+      const isValid2 = await verifyIntent(intent2, connection);
+
+      expect(isValid1).toBe(true);
+      expect(isValid2).toBe(true);
+
+      // Different nonces ensure ordering
+      expect(intent1.nonce).not.toBe(intent2.nonce);
+    });
+
+    it('should reject duplicate nonce', async () => {
+      const intent = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        1000000,
+        connection
+      );
+
+      // Try to create another intent with same nonce (would fail in practice)
+      const intentDupe = { ...intent };
+
+      // Both have same nonce - would be rejected onchain
+      expect(intent.nonce).toBe(intentDupe.nonce);
+    });
+  });
+
+  describe('Program Constraints', () => {
+    it('should validate amount is positive', async () => {
+      const intent = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        1000000,
+        connection
+      );
+
+      // Intent amount should be positive
+      expect(intent.amount).toBeGreaterThan(0);
+    });
+
+    it('should allow large amounts within u64 bounds', async () => {
+      const largeAmount = Math.floor(Number.MAX_SAFE_INTEGER / 2);
+      const intent = await createIntent(
+        senderKeypair,
+        recipientKeypair.publicKey,
+        largeAmount,
+        connection
+      );
+
+      expect(intent.amount).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
+    });
+  });
+
+  describe('Nonce Account Integration', () => {
+    it('should create nonce account for replay protection', async () => {
+      const nonceAuthority = Keypair.generate();
+
+      const mockTossUser: any = {
+        userId: 'test-user-nonce',
+        username: 'testusernonce',
+        wallet: {
+          publicKey: senderKeypair.publicKey.toBase58(),
+          isVerified: true,
+        },
+        security: {
+          biometricEnabled: true,
+          nonceAccountRequiresBiometric: true,
+        },
+        tossFeatures: {
+          canSend: true,
+          canReceive: true,
+          isPrivateTxEnabled: false,
+          maxTransactionAmount: 10000000,
+          offlineTransactionsEnabled: true,
+          nonceAccountEnabled: true,
+        },
+      };
+
+      const nonceAccountInfo = await nonceManager.createNonceAccount(
+        mockTossUser,
+        nonceAuthority,
+        senderKeypair.publicKey,
+        { requireBiometric: true }
+      );
+
+      expect(nonceAccountInfo).toBeDefined();
+      expect(nonceAccountInfo.address).toBeDefined();
+      expect(nonceAccountInfo.isBiometricProtected).toBe(true);
+    });
+
+    it('should validate nonce account is active', async () => {
+      const nonceAuthority = Keypair.generate();
+
+      const mockTossUser: any = {
+        userId: 'test-user-validate',
+        username: 'testuservalidate',
+        wallet: {
+          publicKey: senderKeypair.publicKey.toBase58(),
+          isVerified: true,
+        },
+        security: {
+          biometricEnabled: true,
+          nonceAccountRequiresBiometric: true,
+        },
+        tossFeatures: {
+          canSend: true,
+          canReceive: true,
+          isPrivateTxEnabled: false,
+          maxTransactionAmount: 10000000,
+          offlineTransactionsEnabled: true,
+          nonceAccountEnabled: true,
+        },
+      };
+
+      const nonceAccountInfo = await nonceManager.createNonceAccount(
+        mockTossUser,
+        nonceAuthority,
+        senderKeypair.publicKey,
+        { requireBiometric: true }
+      );
+
+      // Nonce account should be valid
+      const isValid = nonceManager.isNonceAccountValid(nonceAccountInfo);
+      expect(isValid).toBe(true);
+    });
+  });
+});

package/src/ble.ts

@@ -3,12 +3,18 @@ import { BleManager, Device } from 'react-native-ble-plx';
 import { PermissionsAndroid, Platform } from 'react-native';
 import type { TossUser } from './types/tossUser';
 import type { SolanaIntent } from './intent';
+import type { OfflineTransaction } from './types/nonceAccount';
+import { BLETransactionHandler } from './client/BLETransactionHandler';
 
 const SERVICE_UUID = '0000ff00-0000-1000-8000-00805f9b34fb';
 const USER_CHARACTERISTIC = '0000ff01-0000-1000-8000-00805f9b34fb';
 const INTENT_CHARACTERISTIC = '0000ff02-0000-1000-8000-00805f9b34fb';
+const OFFLINE_TX_CHARACTERISTIC = '0000ff03-0000-1000-8000-00805f9b34fb'; // New for offline transactions
 
 const manager = new BleManager();
+const bleTransactionHandler = new BLETransactionHandler(
+  Platform.OS === 'ios' ? 'ios' : 'android'
+);
 
 export async function requestBLEPermissions() {
   if (Platform.OS === 'android') {
@@ -30,7 +36,8 @@ async function connect(device: Device) {
 // Scan for BLE devices advertising TOSS service
 export function startTossScan(
   onUserFound: (user: TossUser, device: Device) => void,
-  onIntentFound: (intent: SolanaIntent, device: Device) => void
+  onIntentFound: (intent: SolanaIntent, device: Device) => void,
+  onOfflineTransactionFound?: (tx: OfflineTransaction, device: Device) => void
 ) {
   manager.startDeviceScan([SERVICE_UUID], null, async (error, device) => {
     if (error) {
@@ -67,6 +74,25 @@ export function startTossScan(
           const intent = JSON.parse(intentData.value) as SolanaIntent;
           onIntentFound(intent, device);
         }
+
+        // Check for offline transaction data (fragmented)
+        if (onOfflineTransactionFound) {
+          try {
+            const txData = await services.readCharacteristicForService(
+              device.id,
+              SERVICE_UUID,
+              OFFLINE_TX_CHARACTERISTIC
+            );
+
+            if (txData?.value) {
+              const tx = JSON.parse(txData.value) as OfflineTransaction;
+              onOfflineTransactionFound(tx, device);
+            }
+          } catch {
+            // Offline TX characteristic may not be available
+            console.debug('Offline transaction characteristic not found');
+          }
+        }
       } catch (err) {
         console.warn('Error reading device data:', err);
       }
@@ -132,7 +158,82 @@ export async function sendIntentToDevice(
   await device.cancelConnection();
 }
 
-// Stop scan
-export function stopScan() {
-  manager.stopDeviceScan();
+/**
+ * Send fragmented offline transaction over BLE with Noise Protocol encryption
+ * Automatically handles MTU limitations and retries
+ */
+export async function sendOfflineTransactionFragmented(
+  device: Device,
+  transaction: OfflineTransaction | SolanaIntent,
+  noiseEncryptFn?: (data: Uint8Array) => Promise<any>,
+  isIntent: boolean = false
+): Promise<{
+  success: boolean;
+  sentFragments: number;
+  failedFragments: number[];
+  messageId: string;
+}> {
+  try {
+    const result = await bleTransactionHandler.sendFragmentedTransactionBLE(
+      device,
+      transaction,
+      async (deviceId, charUUID, data) => {
+        const dev = await manager.connectToDevice(deviceId);
+        await dev.discoverAllServicesAndCharacteristics();
+
+        const characteristic =
+          charUUID === OFFLINE_TX_CHARACTERISTIC
+            ? OFFLINE_TX_CHARACTERISTIC
+            : INTENT_CHARACTERISTIC;
+
+        await dev.writeCharacteristicWithResponseForService(
+          deviceId,
+          SERVICE_UUID,
+          characteristic,
+          data.toString('base64')
+        );
+
+        await dev.cancelConnection();
+      },
+      noiseEncryptFn,
+      isIntent
+    );
+
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error('Failed to send offline transaction:', errorMessage);
+    throw new Error(`BLE transmission failed: ${errorMessage}`);
+  }
+}
+
+/**
+ * Receive and reassemble fragmented message from BLE
+ */
+export async function receiveOfflineTransactionFragment(
+  fragment: any,
+  noiseDecryptFn?: (encrypted: any) => Promise<Uint8Array>
+): Promise<{
+  complete: boolean;
+  transaction?: OfflineTransaction | SolanaIntent;
+  progress: { received: number; total: number };
+}> {
+  return bleTransactionHandler.receiveFragmentedMessage(
+    fragment,
+    noiseDecryptFn
+  );
+}
+
+/**
+ * Get current BLE MTU configuration
+ */
+export function getBLEMTUConfig() {
+  return bleTransactionHandler.getMTUConfig();
+}
+
+/**
+ * Set custom BLE MTU configuration
+ */
+export function setBLEMTUConfig(config: Partial<any>) {
+  bleTransactionHandler.setMTUConfig(config);
 }