toss-expo-sdk 0.1.0

package/src/__tests__/reconciliation.test.tsx

@@ -0,0 +1,361 @@
+/**
+ * Unit Tests for TOSS Reconciliation Module
+ * Tests the core reconciliation and settlement logic from Section 9-10
+ */
+
+import { Keypair, PublicKey } from '@solana/web3.js';
+import {
+  validateIntentOnchain,
+  buildTransactionFromIntent,
+} from '../reconciliation';
+import { createSignedIntent } from '../intent';
+import type { SolanaIntent } from '../intent';
+
+// Mock connection for testing
+const mockConnection = {
+  getAccountInfo: jest.fn(),
+  getLatestBlockhash: jest.fn().mockResolvedValue({
+    blockhash: 'EksnHYAxZEqkLC6tsa4LmSKv67m6qPWtKwMEHUxvLfs7',
+    lastValidBlockHeight: 180000000,
+  }),
+  getSignaturesForAddress: jest.fn().mockResolvedValue([]),
+  getParsedTransaction: jest.fn(),
+  getSlot: jest.fn().mockResolvedValue(180000000),
+  sendRawTransaction: jest.fn(),
+  confirmTransaction: jest.fn(),
+} as any;
+
+describe('Reconciliation Module', () => {
+  let senderKeypair: Keypair;
+  let recipientAddress: PublicKey;
+  let testIntent: SolanaIntent;
+
+  beforeEach(async () => {
+    senderKeypair = Keypair.generate();
+    recipientAddress = new PublicKey('11111111111111111111111111111111');
+
+    // Create a test intent
+    testIntent = await createSignedIntent(
+      senderKeypair,
+      recipientAddress,
+      1000000, // 1 SOL
+      mockConnection
+    );
+  });
+
+  describe('validateIntentOnchain', () => {
+    it('should validate a valid intent', async () => {
+      mockConnection.getAccountInfo.mockResolvedValueOnce({
+        lamports: 5000000, // 5 SOL
+        owner: new PublicKey('11111111111111111111111111111111'),
+        executable: false,
+        rentEpoch: 0,
+        data: Buffer.alloc(0),
+      });
+
+      const result = await validateIntentOnchain(testIntent, mockConnection);
+
+      expect(result.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should reject expired intent', async () => {
+      const expiredIntent = {
+        ...testIntent,
+        expiry: Math.floor(Date.now() / 1000) - 100, // Expired
+      };
+
+      const result = await validateIntentOnchain(expiredIntent, mockConnection);
+
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('expired');
+    });
+
+    it('should reject intent with insufficient balance', async () => {
+      mockConnection.getAccountInfo.mockResolvedValueOnce({
+        lamports: 100000, // 0.1 SOL (less than intent amount)
+        owner: new PublicKey('11111111111111111111111111111111'),
+        executable: false,
+        rentEpoch: 0,
+        data: Buffer.alloc(0),
+      });
+
+      const result = await validateIntentOnchain(testIntent, mockConnection);
+
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('Insufficient balance');
+    });
+
+    it('should reject intent from non-existent account', async () => {
+      mockConnection.getAccountInfo.mockResolvedValueOnce(null);
+
+      const result = await validateIntentOnchain(testIntent, mockConnection);
+
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('does not exist');
+    });
+  });
+
+  describe('buildTransactionFromIntent', () => {
+    it('should build a valid transaction from intent', async () => {
+      mockConnection.getLatestBlockhash.mockResolvedValueOnce({
+        blockhash: 'EksnHYAxZEqkLC6tsa4LmSKv67m6qPWtKwMEHUxvLfs7',
+        lastValidBlockHeight: 180000000,
+      });
+
+      const transaction = await buildTransactionFromIntent(
+        testIntent,
+        mockConnection
+      );
+
+      expect(transaction).toBeDefined();
+      expect(transaction.instructions.length).toBeGreaterThan(0);
+      expect(transaction.feePayer).toEqual(senderKeypair.publicKey);
+    });
+
+    it('should include nonce instruction if nonce account provided', async () => {
+      const nonceKeypair = Keypair.generate();
+      const intentWithNonce = {
+        ...testIntent,
+        nonceAccount: nonceKeypair.publicKey.toBase58(),
+        nonceAuth: senderKeypair.publicKey.toBase58(),
+      };
+
+      mockConnection.getLatestBlockhash.mockResolvedValueOnce({
+        blockhash: 'EksnHYAxZEqkLC6tsa4LmSKv67m6qPWtKwMEHUxvLfs7',
+        lastValidBlockHeight: 180000000,
+      });
+
+      const transaction = await buildTransactionFromIntent(
+        intentWithNonce,
+        mockConnection
+      );
+
+      // Should have both transfer and nonce advance instructions
+      expect(transaction.instructions.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+});
+
+/**
+ * Unit Tests for Discovery Module
+ */
+
+import {
+  DeviceDiscoveryService,
+  IntentExchangeProtocol,
+  MultiDeviceConflictResolver,
+  type PeerDevice,
+} from '../discovery';
+
+describe('Discovery Module', () => {
+  describe('DeviceDiscoveryService', () => {
+    let discovery: DeviceDiscoveryService;
+
+    beforeEach(() => {
+      discovery = new DeviceDiscoveryService();
+    });
+
+    it('should register a peer device', () => {
+      const peer: PeerDevice = {
+        id: 'peer_001',
+        lastSeen: Date.now(),
+        transport: 'ble',
+      };
+
+      discovery.registerPeer(peer);
+
+      const active = discovery.getActivePeers();
+      expect(active).toContainEqual(
+        expect.objectContaining({ id: 'peer_001' })
+      );
+    });
+
+    it('should remove timed out peers', (done) => {
+      const peer: PeerDevice = {
+        id: 'peer_timeout',
+        lastSeen: Date.now() - 6 * 60 * 1000, // 6 minutes ago
+        transport: 'ble',
+      };
+
+      // Manually set old timestamp
+      discovery.registerPeer(peer);
+      discovery['discoveredPeers'].get('peer_timeout')!.lastSeen =
+        Date.now() - 6 * 60 * 1000;
+
+      const active = discovery.getActivePeers();
+      expect(active).not.toContainEqual(
+        expect.objectContaining({ id: 'peer_timeout' })
+      );
+
+      done();
+    });
+
+    it('should update trust score', () => {
+      const peer: PeerDevice = {
+        id: 'peer_trust',
+        lastSeen: Date.now(),
+        transport: 'ble',
+        trustScore: 50,
+      };
+
+      discovery.registerPeer(peer);
+      discovery.updateTrustScore('peer_trust', 25);
+
+      const updated = discovery.getPeer('peer_trust');
+      expect(updated?.trustScore).toBe(75);
+    });
+  });
+
+  describe('IntentExchangeProtocol', () => {
+    let protocol: IntentExchangeProtocol;
+
+    beforeEach(() => {
+      protocol = new IntentExchangeProtocol();
+    });
+
+    it('should create an exchange request', () => {
+      const intent: SolanaIntent = {
+        id: 'intent_test',
+        from: 'sender_addr',
+        to: 'recipient_addr',
+        amount: 1000000,
+        nonce: 1,
+        expiry: Math.floor(Date.now() / 1000) + 3600,
+        signature: 'sig123',
+        status: 'pending',
+        createdAt: Math.floor(Date.now() / 1000),
+        updatedAt: Math.floor(Date.now() / 1000),
+      };
+
+      const request = protocol.createRequest(intent, 'device_001');
+
+      expect(request).toBeDefined();
+      expect(request.intent).toEqual(intent);
+      expect(request.requesterId).toBe('device_001');
+    });
+
+    it('should create a response to exchange request', () => {
+      const intent: SolanaIntent = {
+        id: 'intent_test',
+        from: 'sender_addr',
+        to: 'recipient_addr',
+        amount: 1000000,
+        nonce: 1,
+        expiry: Math.floor(Date.now() / 1000) + 3600,
+        signature: 'sig123',
+        status: 'pending',
+        createdAt: Math.floor(Date.now() / 1000),
+        updatedAt: Math.floor(Date.now() / 1000),
+      };
+
+      const request = protocol.createRequest(intent, 'device_001');
+
+      const response = protocol.createResponse(
+        request.requestId,
+        'device_002',
+        'accepted',
+        undefined,
+        [intent.id]
+      );
+
+      expect(response.status).toBe('accepted');
+      expect(response.responderId).toBe('device_002');
+      expect(response.acknowledgedIntentIds).toContain(intent.id);
+    });
+  });
+
+  describe('MultiDeviceConflictResolver', () => {
+    it('should detect conflicting intents', () => {
+      const intent1: SolanaIntent = {
+        id: 'intent_1',
+        from: 'sender_addr',
+        to: 'recipient_addr',
+        amount: 1000000,
+        nonce: 1,
+        expiry: Math.floor(Date.now() / 1000) + 3600,
+        signature: 'sig1',
+        status: 'pending',
+        createdAt: Math.floor(Date.now() / 1000),
+        updatedAt: Math.floor(Date.now() / 1000),
+      };
+
+      const intent2: SolanaIntent = {
+        ...intent1,
+        id: 'intent_2',
+        signature: 'sig2',
+      };
+
+      const conflicts = MultiDeviceConflictResolver.detectConflicts([
+        intent1,
+        intent2,
+      ]);
+
+      expect(conflicts.length).toBe(1);
+      expect(conflicts[0]).toContainEqual(intent1);
+      expect(conflicts[0]).toContainEqual(intent2);
+    });
+
+    it('should resolve conflicts deterministically by nonce', () => {
+      const intent1: SolanaIntent = {
+        id: 'intent_1',
+        from: 'sender_addr',
+        to: 'recipient_addr',
+        amount: 1000000,
+        nonce: 2, // Higher nonce
+        expiry: Math.floor(Date.now() / 1000) + 3600,
+        signature: 'sig1',
+        status: 'pending',
+        createdAt: Math.floor(Date.now() / 1000),
+        updatedAt: Math.floor(Date.now() / 1000),
+      };
+
+      const intent2: SolanaIntent = {
+        ...intent1,
+        id: 'intent_2',
+        nonce: 1, // Lower nonce (wins)
+        signature: 'sig2',
+      };
+
+      const resolution = MultiDeviceConflictResolver.resolveConflicts([
+        intent1,
+        intent2,
+      ]);
+
+      expect(resolution.winner.id).toBe('intent_2');
+      expect(resolution.losers[0]?.id).toBe('intent_1');
+    });
+
+    it('should resolve conflicts by timestamp if nonces equal', () => {
+      const now = Math.floor(Date.now() / 1000);
+
+      const intent1: SolanaIntent = {
+        id: 'intent_1',
+        from: 'sender_addr',
+        to: 'recipient_addr',
+        amount: 1000000,
+        nonce: 1,
+        expiry: now + 3600,
+        signature: 'sig1',
+        status: 'pending',
+        createdAt: now + 100, // Later
+        updatedAt: now,
+      };
+
+      const intent2: SolanaIntent = {
+        ...intent1,
+        id: 'intent_2',
+        createdAt: now, // Earlier (wins)
+        signature: 'sig2',
+      };
+
+      const resolution = MultiDeviceConflictResolver.resolveConflicts([
+        intent1,
+        intent2,
+      ]);
+
+      expect(resolution.winner.id).toBe('intent_2');
+      expect(resolution.losers[0]?.id).toBe('intent_1');
+    });
+  });
+});

package/src/ble.ts

@@ -0,0 +1,138 @@
+// src/ble.ts
+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';
+
+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 manager = new BleManager();
+
+export async function requestBLEPermissions() {
+  if (Platform.OS === 'android') {
+    await PermissionsAndroid.requestMultiple([
+      PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
+      PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+      PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+    ]);
+  }
+}
+
+// Connect to a BLE device
+async function connect(device: Device) {
+  const connectedDevice = await manager.connectToDevice(device.id);
+  await connectedDevice.discoverAllServicesAndCharacteristics();
+  return connectedDevice;
+}
+
+// Scan for BLE devices advertising TOSS service
+export function startTossScan(
+  onUserFound: (user: TossUser, device: Device) => void,
+  onIntentFound: (intent: SolanaIntent, device: Device) => void
+) {
+  manager.startDeviceScan([SERVICE_UUID], null, async (error, device) => {
+    if (error) {
+      console.warn('BLE scan error', error.message);
+      return;
+    }
+
+    if (device) {
+      try {
+        const connectedDevice = await connect(device);
+        const services =
+          await connectedDevice.discoverAllServicesAndCharacteristics();
+
+        // Check for user data
+        const userData = await services.readCharacteristicForService(
+          device.id,
+          SERVICE_UUID,
+          USER_CHARACTERISTIC
+        );
+
+        if (userData?.value) {
+          const user = JSON.parse(userData.value) as TossUser;
+          onUserFound(user, device);
+        }
+
+        // Check for intent data
+        const intentData = await services.readCharacteristicForService(
+          device.id,
+          SERVICE_UUID,
+          INTENT_CHARACTERISTIC
+        );
+
+        if (intentData?.value) {
+          const intent = JSON.parse(intentData.value) as SolanaIntent;
+          onIntentFound(intent, device);
+        }
+      } catch (err) {
+        console.warn('Error reading device data:', err);
+      }
+    }
+  });
+}
+
+import { State } from 'react-native-ble-plx';
+
+// Advertise user data via BLE
+export async function advertiseUser(user: TossUser) {
+  try {
+    // On Android, we need to use a different approach since react-native-ble-plx
+    // doesn't support BLE advertising directly on the client side
+    if (Platform.OS === 'android') {
+      console.warn(
+        'BLE advertising is not directly supported on Android. Consider using react-native-ble-advertise for this functionality.'
+      );
+      return;
+    }
+
+    // For iOS, we can use the state change to know when advertising starts
+    const subscription = manager.onStateChange((state) => {
+      if (state === State.PoweredOn) {
+        console.log(`Advertising user ${user.userId} via BLE`);
+        subscription.remove();
+      }
+    }, true);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error('Error in BLE advertising:', errorMessage);
+    throw new Error(`Failed to advertise user: ${errorMessage}`);
+  }
+}
+
+export async function stopAdvertising() {
+  try {
+    // On iOS, we can stop scanning which will effectively stop advertising
+    manager.stopDeviceScan();
+    console.log('Stopped BLE advertising');
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error('Error stopping BLE advertising:', errorMessage);
+  }
+}
+
+// Send intent to a specific device
+export async function sendIntentToDevice(
+  deviceId: string,
+  intent: SolanaIntent
+) {
+  const jsonIntent = JSON.stringify(intent);
+  const device = await manager.connectToDevice(deviceId);
+  await device.discoverAllServicesAndCharacteristics();
+
+  await device.writeCharacteristicWithResponseForService(
+    device.id,
+    SERVICE_UUID,
+    INTENT_CHARACTERISTIC,
+    Buffer.from(jsonIntent).toString('base64')
+  );
+
+  await device.cancelConnection();
+}
+
+// Stop scan
+export function stopScan() {
+  manager.stopDeviceScan();
+}