react-native-fpay 0.3.5 → 0.3.7

package/src/engine/FPEngine.ts

@@ -2,24 +2,35 @@
 // Orchestrates BLEReceiverService, BLESenderService, proximity, and the event bus.
 // This replaces AlwaysOnPaymentListener entirely — all its logic lives here.
 
-import { AppState, type AppStateStatus, Vibration, Platform } from 'react-native';
+import {
+  AppState,
+  type AppStateStatus,
+  Vibration,
+  Platform,
+} from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import Geolocation from '@react-native-community/geolocation';
 import { initClient } from '../core/api/client';
-import { proximityAPI, walletAPI } from '../core/api';
+import { proximityAPI, accountAPI } from '../core/api';
 import type {
-  FPUserInfo, 
-  FPSDKOptions, 
-  FPCallbacks, 
+  FPUserInfo,
+  FPSDKOptions,
+  FPCallbacks,
   FPBluetoothPaymentRequest,
-  FPVirtualAccount, 
-  FPGenerateAccountRequest, 
   FPError,
   FintechDevice,
   FPTransferRecipient,
+  FPAccount,
 } from '../core/types';
-import BLEReceiverService, { type BLEPaymentRequest, type BLEPaymentResponse } from './BLEReceiverService';
-import BLESenderService, { type BLESendPaymentRequest, type BLESendPaymentResponse } from './BLESenderService';
+import BLEReceiverService, {
+  type BLEPaymentRequest,
+  type BLEPaymentResponse,
+} from './BLEReceiverService';
+import BLESenderService, {
+  type BLESendPaymentRequest,
+  type BLESendPaymentResponse,
+} from './BLESenderService';
+import { getFPStore, isBalanceCacheValid } from '../store/FPStore';
 
 // ── Module-level singleton state ──────────────────────────────
 let _apiKey: string | null = null;
@@ -33,15 +44,21 @@ let _proximitySessionId: string | null = null;
 let _proximityInterval: ReturnType<typeof setInterval> | null = null;
 let _appStateSub: ReturnType<typeof AppState.addEventListener> | null = null;
 
+const PROXIMITY_THRESHOLD_METERS = 100;
+
 // ── Internal event bus ────────────────────────────────────────
 // Used to communicate between FPEngine and the UI layer
 // without any React coupling.
 
-type FPEventName = 'incoming_payment_request' | 'show_send' | 'show_receive';
+type FPEventName =
+  | 'incoming_payment_request'
+  | 'show_send'
+  | 'show_receive'
+  | 'close_send';
 const _listeners = new Map<FPEventName, Set<Function>>();
 
 export function _emitEvent(event: FPEventName, data?: unknown): void {
-  _listeners.get(event)?.forEach(fn => fn(data));
+  _listeners.get(event)?.forEach((fn) => fn(data));
 }
 
 export function _onEvent(event: FPEventName, fn: Function): () => void {
@@ -53,45 +70,120 @@ export function _onEvent(event: FPEventName, fn: Function): () => void {
 // ── Proximity helpers ─────────────────────────────────────────
 
 function _clearProximityInterval(): void {
-  if (_proximityInterval) { clearInterval(_proximityInterval); _proximityInterval = null; }
+  if (_proximityInterval) {
+    clearInterval(_proximityInterval);
+    _proximityInterval = null;
+  }
 }
 
 function _getLocation(): Promise<{ lat: number; lng: number }> {
   return new Promise((resolve, reject) => {
     Geolocation.getCurrentPosition(
-      p => resolve({ lat: p.coords.latitude, lng: p.coords.longitude }),
-      e => reject({ code: 'LOCATION_DENIED', message: e.message } as FPError),
+      (p) => resolve({ lat: p.coords.latitude, lng: p.coords.longitude }),
+      (e) => reject({ code: 'LOCATION_DENIED', message: e.message } as FPError),
       { enableHighAccuracy: true, timeout: 8000, maximumAge: 10000 }
     );
   });
 }
 
 async function _startProximityBroadcast(): Promise<void> {
-  if (!_user || !_account) return;
+  const store = getFPStore();
+  const psspId = store.psspId;
+  if (!_user || !psspId) {
+    console.warn('[FPay Engine] Proximity skipped — no user or psspId');
+    return;
+  }
+
   try {
     const loc = await _getLocation();
-    const session = await proximityAPI.broadcast({
-      latitude: loc.lat, longitude: loc.lng,
-      user:          _user?.name || "",
-      email:         _user?.email || "",
-      accountName:   _account?.accountName || "",
-      accountNumber: _account?.accountNumber || "",
-      bankCode:      _account?.bankCode || "",
-      bankName:      _account?.bankName || "",
+
+    // Check if we've moved more than 100m from last broadcast position
+    const lastPos = store.lastBroadcastPosition;
+    if (lastPos) {
+      const distance = _getDistanceMeters(
+        lastPos.latitude,
+        lastPos.longitude,
+        loc.lat,
+        loc.lng
+      );
+
+      if (distance < PROXIMITY_THRESHOLD_METERS) {
+        console.log(
+          `[FPay Engine] Within ${Math.round(distance)}m of last broadcast — skipping`
+        );
+        return; // Not moved enough — no need to broadcast
+      }
+
+      console.log(
+        `[FPay Engine] Moved ${Math.round(distance)}m — broadcasting new position`
+      );
+    }
+
+    // Broadcast new position
+    const session = await proximityAPI.broadcast(psspId, {
+      latitude: loc.lat,
+      longitude: loc.lng,
+      user_type: 'VIRTUAL_ACCOUNT_USER',
     });
+
+    // Save new position to store
+    store.setLastBroadcastPosition({ latitude: loc.lat, longitude: loc.lng });
     _proximitySessionId = session.sessionId;
+
+    console.log(
+      '[FPay Engine] Proximity broadcast active at:',
+      loc.lat,
+      loc.lng
+    );
+
+    // Start heartbeat interval
     _clearProximityInterval();
     _proximityInterval = setInterval(async () => {
       if (!_proximitySessionId) return;
       try {
-        const l = await _getLocation();
-        await proximityAPI.heartbeat(_proximitySessionId, l.lat, l.lng);
-      } catch { /* silent — heartbeat failure is non-fatal */ }
+        const current = await _getLocation();
+        const saved = getFPStore().lastBroadcastPosition;
+
+        if (saved) {
+          const moved = _getDistanceMeters(
+            saved.latitude,
+            saved.longitude,
+            current.lat,
+            current.lng
+          );
+
+          if (moved >= PROXIMITY_THRESHOLD_METERS) {
+            // Moved significantly — broadcast new position
+            console.log(
+              `[FPay Engine] Heartbeat: moved ${Math.round(moved)}m — re-broadcasting`
+            );
+            await proximityAPI.broadcast(psspId, {
+              latitude: current.lat,
+              longitude: current.lng,
+              user_type: 'VIRTUAL_ACCOUNT_USER',
+            });
+            getFPStore().setLastBroadcastPosition({
+              latitude: current.lat,
+              longitude: current.lng,
+            });
+          } else {
+            // Just send heartbeat to keep session alive
+            await proximityAPI.heartbeat(
+              _proximitySessionId,
+              current.lat,
+              current.lng
+            );
+          }
+        }
+      } catch {
+        /* silent */
+      }
     }, 15000);
-    console.log('[FPay Engine] Proximity broadcast active');
   } catch (err) {
-    // Non-fatal — app still works without proximity
-    console.warn('[FPay Engine] Proximity unavailable:', (err as FPError).message);
+    console.warn(
+      '[FPay Engine] Proximity unavailable:',
+      (err as FPError).message
+    );
   }
 }
 
@@ -134,10 +226,11 @@ async function _validateRequest(req: BLEPaymentRequest): Promise<boolean> {
   try {
     const raw = await AsyncStorage.getItem('@fp_recent_requests');
     const recent: BLEPaymentRequest[] = raw ? JSON.parse(raw) : [];
-    const isDuplicate = recent.some(r =>
-      r.senderId === req.senderId &&
-      r.amount   === req.amount &&
-      Math.abs(r.timestamp - req.timestamp) < 60000 // within 1 minute
+    const isDuplicate = recent.some(
+      (r) =>
+        r.senderId === req.senderId &&
+        r.amount === req.amount &&
+        Math.abs(r.timestamp - req.timestamp) < 60000 // within 1 minute
     );
     // Store and trim to last 50
     await AsyncStorage.setItem(
@@ -157,13 +250,23 @@ async function _validateRequest(req: BLEPaymentRequest): Promise<boolean> {
 // This is the core of AlwaysOnPaymentListener.handleIncomingPaymentRequest()
 // It fires automatically when BLEReceiverService receives a write event.
 
-async function _handleIncomingRequest(req: BLEPaymentRequest, deviceId: string): Promise<void> {
-  console.log('[FPay Engine] Incoming payment request from:', req.senderName, req.currency + req.amount);
+async function _handleIncomingRequest(
+  req: BLEPaymentRequest,
+  deviceId: string
+): Promise<void> {
+  console.log(
+    '[FPay Engine] Incoming payment request from:',
+    req.senderName,
+    req.currency + req.amount
+  );
 
   const isValid = await _validateRequest(req);
   if (!isValid) {
     // Auto-decline invalid requests silently
-    await BLEReceiverService.sendPaymentResponse({ accepted: false, timestamp: Date.now() }).catch(() => {});
+    await BLEReceiverService.sendPaymentResponse({
+      accepted: false,
+      timestamp: Date.now(),
+    }).catch(() => {});
     return;
   }
 
@@ -174,15 +277,16 @@ async function _handleIncomingRequest(req: BLEPaymentRequest, deviceId: string):
   const fpRequest: FPBluetoothPaymentRequest = {
     requestId: req.senderId + '_' + req.timestamp,
     sender: {
-      name: req.senderName,
+      firstName: req.senderName,
+      lastName: '',
       phone: req.senderPhone,
       email: req.senderEmail,
       userId: req.senderId,
       deviceId,
       deviceName: req.senderName,
     },
-    amount:    req.amount,
-    currency:  req.currency,
+    amount: req.amount,
+    currency: req.currency,
     timestamp: new Date(req.timestamp).toISOString(),
   };
 
@@ -193,10 +297,90 @@ async function _handleIncomingRequest(req: BLEPaymentRequest, deviceId: string):
   _emitEvent('incoming_payment_request', fpRequest);
 }
 
+async function _resolveAccount(
+  user: FPUserInfo,
+  callbacks: FPCallbacks
+): Promise<void> {
+  const store = getFPStore();
+  // const existingPsspId = store.psspId;  // ← read before clearing
+
+  // // Now safe to clear stale data
+  // store.clearUser();
+  // store.clearAccount();
+  // store.clearBalance();
+  const psspId = store.psspId;
+
+  try {
+    if (psspId) {
+      // ← use the saved value, not store.psspId
+      console.log('[FPay Engine] Existing PSSP id found — fetching account...');
+      try {
+        const account = await accountAPI.getAccount(psspId);
+        store.setAccount(account);
+        store.setUser(user);
+        callbacks.onAccountReady?.(account);
+        _fetchBalance();
+        return;
+      } catch (err) {
+        console.warn(
+          '[FPay Engine] Existing account fetch failed — creating new...'
+        );
+      }
+    }
+
+    // Create new account
+    const account: any = await accountAPI.generate(user);
+    if (account.status) {
+      store.setPsspId(account.id);
+      store.setAccount(account);
+      store.setUser(user);
+      callbacks.onAccountReady?.(account);
+      _fetchBalance();
+    }
+  } catch (err: any) {
+    callbacks.onAccountError?.(err, user);
+  }
+}
+
+async function _fetchBalance(): Promise<void> {
+  const { psspId } = getFPStore();
+  if (!psspId) return;
+
+  if (isBalanceCacheValid()) {
+    console.log('[FPay Engine] Balance cache valid — skipping fetch.');
+    return;
+  }
+
+  try {
+    const { balance } = await accountAPI.getBalance(psspId);
+    getFPStore().setBalance(balance);
+    console.log('[FPay Engine] Balance fetched:', balance);
+  } catch (err) {
+    console.warn('[FPay Engine] Balance fetch failed (non-fatal):', err);
+  }
+}
+
+function _getDistanceMeters(
+  lat1: number,
+  lng1: number,
+  lat2: number,
+  lng2: number
+): number {
+  const R = 6371000; // Earth radius in meters
+  const toRad = (deg: number) => (deg * Math.PI) / 180;
+  const dLat = toRad(lat2 - lat1);
+  const dLng = toRad(lng2 - lng1);
+  const a =
+    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+    Math.cos(toRad(lat1)) *
+      Math.cos(toRad(lat2)) *
+      Math.sin(dLng / 2) *
+      Math.sin(dLng / 2);
+  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
 // ── FPEngine public API ───────────────────────────────────────
 
 export const FPEngine = {
-
   // Called by pay.initializeSDK()
   // Mirrors AlwaysOnPaymentListener.initializeAlwaysOnService()
   async initialize(
@@ -205,55 +389,59 @@ export const FPEngine = {
     options: FPSDKOptions = {},
     callbacks: FPCallbacks = {}
   ): Promise<void> {
-    _apiKey    = apiKey;
-    _user      = user;
-    _options   = options;
+    _apiKey = apiKey;
+    _user = user;
+    _options = options;
     _callbacks = callbacks;
 
-    // Boot the HTTP client
-    initClient(apiKey, { baseUrl: options.baseUrl, environment: options.environment });
+    initClient(apiKey, {
+      baseUrl: options.baseUrl,
+      environment: options.environment,
+    });
 
-    // Initialize BLE receiver with this user's info
-    const displayName = options.bluetoothDisplayName ?? user.name;
+    const displayName =
+      options.bluetoothDisplayName ?? `${user.firstName} ${user.lastName}`;
     await BLEReceiverService.initializeWithUserInfo(
-      user.userId ?? user.userId,
+      user.userId ?? '',
       displayName,
       'FountainPay'
     );
 
-    // Start BLE advertising + proximity broadcast in parallel.
-    // Both are non-fatal — SDK still works if either fails.
-    await Promise.allSettled([
-      BLEReceiverService.startAdvertising(),
-      _startProximityBroadcast(),
-    ]);
+    // Start BLE advertising immediately — doesn't need psspId
+    await BLEReceiverService.startAdvertising().catch((err) =>
+      console.warn('[FPay Engine] BLE advertising failed (non-fatal):', err)
+    );
 
-    // Initialize BLE sender (central) — used when user sends payments via BT
-    await BLESenderService.initialize().catch(err =>
+    await BLESenderService.initialize().catch((err) =>
       console.warn('[FPay Engine] BLE sender init failed (non-fatal):', err)
     );
 
-    // Resume broadcasting when app returns to foreground
-    _appStateSub = AppState.addEventListener('change', (next: AppStateStatus) => {
-      if (next === 'active' && _isReady) {
-        _startProximityBroadcast();
-        BLEReceiverService.startAdvertising().catch(() => {});
-      } else if (next === 'background') {
-        _clearProximityInterval();
+    _appStateSub = AppState.addEventListener(
+      'change',
+      (next: AppStateStatus) => {
+        if (next === 'active' && _isReady) {
+          _startProximityBroadcast();
+          BLEReceiverService.startAdvertising().catch(() => {});
+        } else if (next === 'background') {
+          _clearProximityInterval();
+        }
       }
-    });
+    );
 
     _isReady = true;
     console.log('[FPay Engine] Initialized. Advertising as:', displayName);
+
+    // Resolve account first — sets psspId in store
+    // Then broadcast proximity — needs psspId to be set
+    await _resolveAccount(user, callbacks);
+    await _startProximityBroadcast(); // ← moved here, after psspId is available
   },
 
-  async setAccountDetails(account: FPTransferRecipient): Promise<void>{
+  async setAccountDetails(account: FPTransferRecipient): Promise<void> {
     _account = account;
   },
 
-
-
-  async deviceConnection (deviceId: string): Promise<void>{
+  async deviceConnection(deviceId: string): Promise<void> {
     await BLESenderService.connectToDevice(deviceId);
   },
 
@@ -275,43 +463,61 @@ export const FPEngine = {
 
   // Called by FPPaymentRequestModal when user taps "Accept"
   // Mirrors AlwaysOnPaymentListener.handleAcceptPayment()
-  async acceptPaymentRequest(request: FPBluetoothPaymentRequest): Promise<void> {
+  async acceptPaymentRequest(
+    request: FPBluetoothPaymentRequest
+  ): Promise<void> {
     try {
-      const transactionId = 'txn_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+      const transactionId =
+        'txn_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+      const store = getFPStore();
+      const account = getFPStore().account;
 
-      // Build response — same shape as your original:
-      // { accepted, transactionId, timestamp, accountDetails, requestTimestamp }
+      // Build BLE response with receiver's wallet details
       const response: BLEPaymentResponse = {
         accepted: true,
         transactionId,
         timestamp: Date.now(),
-        accountDetails: _account ? {
-          accountName:   _account?.accountName,
-          accountNumber: _account?.accountNumber,
-          bankName:      _account?.bankName,
-          bankCode:      _account?.bankCode,
-        } : undefined,
-        // requestTimestamp is echoed back so the sender's polling can match it
         requestTimestamp: new Date(request.timestamp).getTime(),
+        accountDetails: account
+          ? {
+              accountName: account.accountName,
+              accountNumber: account.accountNumber,
+              bankName: account.bankName ?? '',
+              bankCode: account.bankCode ?? '',
+              userId: store.psspId ?? undefined,
+              type: 'USER' as const,
+            }
+          : undefined,
       };
-
-      // Write response to the BLE characteristic — sender is polling this
+      console.log('[FPay Engine] _account at accept time:', _account);
+      console.log(
+        '[FPay Engine] store account at accept time:',
+        getFPStore().account
+      );
+      console.log('[FPay Engine] response at accept time:', response);
+      // Send response back to sender via BLE
       await BLEReceiverService.sendPaymentResponse(response);
       console.log('[FPay Engine] Acceptance response sent to sender');
 
-      // Notify host app
+      // Notify host app that payment is incoming
+      // Status is 'pending' until sender confirms transfer on their end
       const tx = {
-        id:        transactionId,
+        id: transactionId,
         reference: transactionId,
-        type:      'credit' as const,
-        channel:   'bluetooth' as const,
-        amount:    request.amount,
-        currency:  request.currency,
-        status:    'successful' as const,
-        sender:    request.sender,
+        type: 'credit' as const,
+        channel: 'bluetooth' as const,
+        amount: request.amount,
+        currency: request.currency,
+        status: 'pending' as const, // ← pending until sender processes
+        sender: request.sender,
         createdAt: new Date().toISOString(),
       };
       _callbacks.onPaymentReceived?.(tx);
+
+      // Refresh balance after a delay to give sender time to process
+      setTimeout(() => {
+        _fetchBalance();
+      }, 5000); // ← 5s delay to allow sender's transfer to settle
     } catch (err) {
       _callbacks.onError?.(err as FPError);
     }
@@ -319,9 +525,14 @@ export const FPEngine = {
 
   // Called by FPPaymentRequestModal when user taps "Decline"
   // Mirrors AlwaysOnPaymentListener.handleDeclinePayment()
-  async declinePaymentRequest(request: FPBluetoothPaymentRequest): Promise<void> {
+  async declinePaymentRequest(
+    request: FPBluetoothPaymentRequest
+  ): Promise<void> {
     try {
-      await BLEReceiverService.sendPaymentResponse({ accepted: false, timestamp: Date.now() });
+      await BLEReceiverService.sendPaymentResponse({
+        accepted: false,
+        timestamp: Date.now(),
+      });
       console.log('[FPay Engine] Decline response sent to sender');
     } catch {
       // Non-fatal — decline even if response send fails
@@ -351,21 +562,29 @@ export const FPEngine = {
 
   // ── Other SDK actions ──────────────────────────────────────
 
-  async generateAccount(req: FPGenerateAccountRequest): Promise<FPVirtualAccount> {
-    return walletAPI.generate(req);
+  async generateAccount(req: FPUserInfo): Promise<FPAccount> {
+    return accountAPI.generate(req);
+  },
+
+  async refreshBalance(): Promise<void> {
+    await _fetchBalance();
+  },
+
+  closeSend(): void {
+    _emitEvent('close_send');
   },
 
   showSend(amount: number, currency: string): void {
-    _emitEvent('show_send', {amount, currency });
+    _emitEvent('show_send', { amount, currency });
   },
 
   showReceive(amount?: number, currency?: string): void {
     _emitEvent('show_receive', { amount, currency });
   },
 
-  getUser:      () => _user,
-  getAccount:   () => _account,
-  isReady:      () => _isReady,
+  getUser: () => _user,
+  getAccount: () => _account,
+  isReady: () => _isReady,
   getCallbacks: () => _callbacks,
 
   async destroy(): Promise<void> {

package/src/engine/NearbyUsersService.ts

@@ -24,9 +24,9 @@ class NearbyUsersService {
     Geolocation.getCurrentPosition(
       async (position) => {
         const { latitude, longitude } = position.coords;
-        
+
         const authToken = await this.getAuthToken();
-        
+
         await fetch(`${this.API_URL}/api/users/location`, {
           method: 'POST',
           headers: {
@@ -48,10 +48,10 @@ class NearbyUsersService {
   // Get list of nearby users from server
   async getNearbyUsers(): Promise<NearbyUser[]> {
     const authToken = await this.getAuthToken();
-    
+
     const response = await fetch(`${this.API_URL}/api/users/nearby?radius=50`, {
       headers: {
-        'Authorization': `Bearer ${authToken}`,
+        Authorization: `Bearer ${authToken}`,
       },
     });
 
@@ -69,7 +69,7 @@ class NearbyUsersService {
     currency: string = 'USD'
   ) {
     const authToken = await this.getAuthToken();
-    
+
     const response = await fetch(`${this.API_URL}/api/payments/request`, {
       method: 'POST',
       headers: {
@@ -103,4 +103,4 @@ class NearbyUsersService {
   }
 }
 
-export default new NearbyUsersService();
+export default new NearbyUsersService();

package/src/engine/useIsForeground.ts

@@ -1,18 +1,18 @@
-import { useState } from 'react'
-import { useEffect } from 'react'
-import type { AppStateStatus } from 'react-native'
-import { AppState } from 'react-native'
+import { useState } from 'react';
+import { useEffect } from 'react';
+import type { AppStateStatus } from 'react-native';
+import { AppState } from 'react-native';
 
 export const useIsForeground = (): boolean => {
-  const [isForeground, setIsForeground] = useState(true)
+  const [isForeground, setIsForeground] = useState(true);
 
   useEffect(() => {
     const onChange = (state: AppStateStatus): void => {
-      setIsForeground(state === 'active')
-    }
-    const listener = AppState.addEventListener('change', onChange)
-    return () => listener.remove()
-  }, [setIsForeground])
+      setIsForeground(state === 'active');
+    };
+    const listener = AppState.addEventListener('change', onChange);
+    return () => listener.remove();
+  }, [setIsForeground]);
 
-  return isForeground
-}
+  return isForeground;
+};

package/src/index.ts

@@ -5,10 +5,17 @@
 // ─────────────────────────────────────────────
 
 // The one hook
-export { useFountainPay }       from './useFountainPay';
+export { useFountainPay } from './useFountainPay';
 
 // The one provider (mount at app root)
-export { FountainPayProvider }  from './FountainPayProvider';
+export { FountainPayProvider } from './FountainPayProvider';
+
+export {
+  useFPStore,
+  getFPStore,
+  isBanksCacheValid,
+  isTokenValid,
+} from './store/FPStore';
 
 // All TypeScript types (for type-safe usage)
 export type {
@@ -18,8 +25,7 @@ export type {
   FPCallbacks,
   FPCurrency,
   FPTransaction,
-  FPVirtualAccount,
-  FPGenerateAccountRequest,
+  FPAccount,
   FPBluetoothPaymentRequest,
   FPProximityPeer,
   FPNQRData,