react-native-fpay 0.3.4 → 0.3.6

package/src/FountainPayProvider.tsx

@@ -11,9 +11,16 @@
 //   </FountainPayProvider>
 // ─────────────────────────────────────────────────────────────────────────────
 import React, {
-  type ReactNode, createContext, useContext, useMemo, useRef,
+  type ReactNode,
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
 } from 'react';
 import { FPShell } from './ui/modals/FPShell';
+import { useFPStore, getFPStore, isTokenValid } from './store/FPStore';
 import { FPEngine } from './engine/FPEngine';
 import { initClient } from './core/api/client';
 import type {
@@ -22,10 +29,11 @@ import type {
   FPSDKOptions,
   FPCallbacks,
   FPCurrency,
-  FPGenerateAccountRequest,
-  FPVirtualAccount,
   FPTransferRecipient,
+  FPAccount,
 } from './core/types';
+import { authenticateAPI, transferAPI } from './core/api';
+import { Alert } from 'react-native';
 
 // ── Context ───────────────────────────────────────────────────────────────────
 
@@ -47,7 +55,7 @@ export function useFountainPay(): FPInstance {
   if (!instance) {
     throw new Error(
       '[FountainPay] useFountainPay() must be called inside <FountainPayProvider>.\n' +
-      'Make sure you have wrapped your app root with <FountainPayProvider apiKey="...">.'
+        'Make sure you have wrapped your app root with <FountainPayProvider apiKey="...">.'
     );
   }
   return instance;
@@ -61,30 +69,126 @@ interface ProviderProps {
   children: ReactNode;
 }
 
-export function FountainPayProvider({ apiKey, options, children }: ProviderProps) {
+export function FountainPayProvider({
+  apiKey,
+  options,
+  children,
+}: ProviderProps) {
   // Boot the HTTP client as soon as the provider mounts —
   // this means generateAccountNumber works even before initializeSDK
   const clientBooted = useRef(false);
-  if (!clientBooted.current) {
-    initClient(apiKey, { baseUrl: options?.baseUrl, environment: options?.environment });
-    clientBooted.current = true;
-    console.log('[FountainPay] Provider mounted. HTTP client ready.');
-  }
+
+  const isAuthenticated = useFPStore((s) => s.isAuthenticated);
+  const authError = useFPStore((s) => s.authError);
+  const setAuthenticated = useFPStore((s) => s.setAuthenticated);
+  const account = useFPStore((s) => s.account);
+  const user = useFPStore((s) => s.user);
+  const balance = useFPStore((s) => s.balance);
+
+  console.log('[FPStore] user:', user);
+  console.log('[FPStore] account:', account);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    // Make sure client is initialized before any API call
+    console.log('[FountainPay] Provider mounted. HTTP client ready.', options);
+    if (!clientBooted.current) {
+      initClient(apiKey, {
+        baseUrl: options?.baseUrl,
+        environment: options?.environment,
+      });
+      clientBooted.current = true;
+      console.log(
+        '[FountainPay] Provider mounted. HTTP client ready.: ',
+        options
+      );
+    }
+
+    const authenticate = async () => {
+      if (isTokenValid()) {
+        console.log('[FountainPay] Valid token found — skipping auth.');
+        setAuthenticated(true);
+        return;
+      }
+
+      try {
+        console.log('[FountainPay] Verifying API key...');
+        const response = await authenticateAPI.login(apiKey);
+        if (cancelled) return;
+
+        if (response.status) {
+          console.log('[FountainPay] Auth successful.');
+          if (response.payload?.access_token) {
+            getFPStore().setAccessToken(
+              response.payload.access_token,
+              response.payload.expires_in
+            );
+
+            const banks: any = await transferAPI.getBanks();
+            if (banks.status) {
+              getFPStore().setBanks(banks.payload);
+            }
+          }
+          setAuthenticated(true);
+        } else {
+          console.error('[FountainPay] Auth failed:', response.message);
+          setAuthenticated(false, response.message);
+        }
+      } catch (err: any) {
+        if (cancelled) return;
+        console.error('[FountainPay] Auth error:', err.message);
+        setAuthenticated(false, err.message);
+      }
+    };
+
+    console.log('Calling authentication');
+    authenticate();
+    return () => {
+      cancelled = true;
+    };
+  }, [apiKey]);
 
   // Build the instance once per provider lifetime.
   // All components that call useFountainPay() share this exact object.
   const instance = useMemo<FPInstance>(() => {
-    console.log('[FountainPay] Creating shared FPInstance for apiKey:', apiKey.slice(0, 8) + '...');
+    console.log(
+      '[FountainPay] Creating shared FPInstance for apiKey:',
+      apiKey.slice(0, 8) + '...'
+    );
 
     return {
       /**
        * Call once after the user logs in.
        * Starts BLE advertising, proximity broadcast, and the payment listener.
        */
-      async initializeSDK(user: FPUserInfo, callbacks?: FPCallbacks): Promise<void> {
-        console.log('[FountainPay] initializeSDK() called for user:', user.name);
+      async initializeSDK(
+        user: FPUserInfo,
+        callbacks?: FPCallbacks
+      ): Promise<void> {
+        console.log(
+          '[FountainPay] initializeSDK() called for user:',
+          user.firstName
+        );
         try {
-          await FPEngine.initialize(apiKey, user, options ?? {}, callbacks ?? {});
+          await FPEngine.initialize(
+            apiKey,
+            user,
+            options ?? {},
+            callbacks ?? {}
+          );
+          await FPEngine.initialize(apiKey, user, options ?? {}, {
+            ...callbacks,
+            onPaymentSent: async (tx) => {
+              callbacks?.onPaymentSent?.(tx);
+              await FPEngine.refreshBalance();
+              FPEngine.closeSend(); // ← close on success
+            },
+            onError: (err) => {
+              callbacks?.onError?.(err);
+              FPEngine.closeSend(); // ← close on error
+            },
+          });
           console.log('[FountainPay] initializeSDK() complete. SDK is ready.');
         } catch (err) {
           console.error('[FountainPay] initializeSDK() FAILED:', err);
@@ -93,13 +197,31 @@ export function FountainPayProvider({ apiKey, options, children }: ProviderProps
       },
 
       setAccountDetails(account: FPTransferRecipient): void {
-        console.log('[FountainPay] setAccountDetails() called for user:', account.accountName);
+        console.log(
+          '[FountainPay] setAccountDetails() called for user:',
+          account.accountName
+        );
         FPEngine.setAccountDetails(account);
       },
 
       /** Open the Send Money bottom sheet. */
       send(amount: number, currency: FPCurrency): void {
         console.log('[FountainPay] send() called:', amount, currency);
+        console.log('[FountainPay] send() called:', amount, currency);
+        console.log('[FountainPay] balance in store:', getFPStore().balance);
+        console.log('[FountainPay] balance type:', typeof getFPStore().balance);
+
+        const balance = getFPStore().balance ?? 0;
+        console.log('Balance: ', balance);
+        if (Number(amount) > Number(balance)) {
+          console.error('[FountainPay] Insufficient balance.');
+          FPEngine.getCallbacks().onError?.({
+            code: 'INSUFFICIENT_BALANCE',
+            message: `Insufficient balance. Available: ${balance}`,
+          });
+          return; // ← stops here, FPShell never opens
+        }
+
         FPEngine.showSend(amount, currency);
       },
 
@@ -110,9 +232,12 @@ export function FountainPayProvider({ apiKey, options, children }: ProviderProps
       },
 
       /** Generate a virtual account number (no UI shown). */
-      async generateAccountNumber(request: FPGenerateAccountRequest): Promise<FPVirtualAccount> {
-        console.log('[FountainPay] generateAccountNumber() called:', request.accountName);
-        return FPEngine.generateAccount(request);
+      async generateAccountNumber(user: FPUserInfo): Promise<FPAccount> {
+        console.log(
+          '[FountainPay] generateAccountNumber() called:',
+          user.firstName
+        );
+        return FPEngine.generateAccount(user);
       },
 
       /**
@@ -121,7 +246,9 @@ export function FountainPayProvider({ apiKey, options, children }: ProviderProps
        * modal will appear automatically.
        */
       listen(): void {
-        console.log('[FountainPay] listen() called — activating BT payment listener.');
+        console.log(
+          '[FountainPay] listen() called — activating BT payment listener.'
+        );
         FPEngine.startListening();
       },
 
@@ -132,16 +259,30 @@ export function FountainPayProvider({ apiKey, options, children }: ProviderProps
         console.log('[FountainPay] All services stopped.');
       },
 
+      async refreshBalance(): Promise<void> {
+        await FPEngine.refreshBalance();
+      },
+
       get isReady(): boolean {
         return FPEngine.isReady();
       },
-
+      get isAuthenticated(): boolean {
+        return isAuthenticated;
+      },
+      get authError(): string | null {
+        return authError;
+      },
+      get account(): FPAccount | null {
+        return account;
+      },
       get currentUser(): FPUserInfo | null {
-        return FPEngine.getUser();
+        return user;
+      },
+      get balance(): number | null {
+        return balance;
       },
     };
-  // Re-create instance only if the apiKey changes (which should never happen at runtime)
-  }, [apiKey]);
+  }, [apiKey, isAuthenticated, authError, account, user, balance]);
 
   return (
     <FountainPayContext.Provider value={instance}>

package/src/core/api/client.ts

@@ -4,24 +4,40 @@
 
 import axios, { type AxiosInstance } from 'axios';
 import type { FPError } from '../types';
+import { getFPStore } from '../../store/FPStore';
 
-const DEFAULT_BASE_URL = 'https://api.fountainpay.ng/sdk/detect/';
+const DEFAULT_BASE_URL =
+  'https://30a6-102-89-83-67.ngrok-free.app/sdk/v1/fpip/';
 
 let _client: AxiosInstance | null = null;
 
-export function initClient(apiKey: string, options: { baseUrl?: string; environment?: string } = {}): void {
+export function initClient(
+  apiKey: string,
+  options: { baseUrl?: string; environment?: string } = {}
+): void {
   _client = axios.create({
     baseURL: options.baseUrl ?? DEFAULT_BASE_URL,
     timeout: 30000,
     headers: {
       'Content-Type': 'application/json',
       'x-api-key': apiKey,
+      'x-api-client': 'modal',
       'x-sdk': 'react-native-fountainpay-sdk',
       'x-sdk-version': '1.0.0',
       'x-env': options.environment ?? 'production',
     },
   });
 
+  // Attach Authorization header on every request — reads token fresh from
+  // store each time so it's always current after login
+  _client.interceptors.request.use((config) => {
+    const accessToken = getFPStore().accessToken;
+    if (accessToken) {
+      config.headers.Authorization = `Bearer ${accessToken}`;
+    }
+    return config;
+  });
+
   _client.interceptors.response.use(
     (r) => r,
     (err) => {
@@ -34,7 +50,10 @@ export function initClient(apiKey: string, options: { baseUrl?: string; environm
         e.code = d.code ?? `HTTP_${err.response.status}`;
         e.message = d.message ?? err.message;
         e.statusCode = err.response.status;
-        if (err.response.status === 401) { e.code = 'INVALID_API_KEY'; e.message = 'Invalid API key.'; }
+        if (err.response.status === 401) {
+          e.code = 'INVALID_API_KEY';
+          e.message = 'Invalid API key.';
+        }
       }
       return Promise.reject(e);
     }
@@ -42,6 +61,9 @@ export function initClient(apiKey: string, options: { baseUrl?: string; environm
 }
 
 export function http(): AxiosInstance {
-  if (!_client) throw new Error('[FountainPay] SDK not initialized. Call pay.initializeSDK() first.');
+  if (!_client)
+    throw new Error(
+      '[FountainPay] SDK not initialized. Call pay.initializeSDK() first.'
+    );
   return _client;
 }

package/src/core/api/index.ts

@@ -1,76 +1,197 @@
 // FountainPay SDK — All API calls
-import { http } from "./client";
+import { http } from './client';
 import type {
-  FPVirtualAccount,
-  FPGenerateAccountRequest,
   FPBankItem,
-  FPTransaction, 
-  FPNQRData, 
-  FPTxStatus, 
+  FPTransaction,
+  FPNQRData,
+  FPTxStatus,
   FPProximityPeer,
   FPSendPaymentRequest,
-} from "../types";
+  FPUserInfo,
+  FPAccount,
+  FPSendWalletPaymentRequest,
+  FPTransactionResponse,
+} from '../types';
+
+export const healthAPI = {
+  ping: () =>
+    http()
+      .get('/health')
+      .then((r) => r.data),
+};
+
+export const authenticateAPI = {
+  login: (apiKey: string) =>
+    http()
+      .post('/auth', { api_key: apiKey })
+      .then((r) => r.data),
+
+  profile: (userId: string) =>
+    http()
+      .get(`/get-user-details/${userId}`)
+      .then((r) => r.data),
 
-export const walletAPI = {
-  generate: (req: FPGenerateAccountRequest) =>
-    http().post<FPVirtualAccount>("/wallet/generate", req).then(r => r.data),
+  logout: () =>
+    http()
+      .post('/auth/logout')
+      .then((r) => r.data),
+
+  validateOtp: (otp: string, email: string) =>
+    http()
+      .post<{ Response: any }>('/verify-otp', { otp, email })
+      .then((r) => r.data),
+};
 
-  getBalance: (walletId: string) =>
-    http().get<{ balance: number; currency: string }>("/wallet/" + walletId + "/balance").then(r => r.data),
+export const accountAPI = {
+  generate: (user: FPUserInfo) =>
+    http()
+      .post<{ payload: FPAccount }>('/generate-virtual-account', {
+        first_name: user.firstName,
+        last_name: user.lastName,
+        phone_no: user.phone,
+        email: user.email,
+        bvn: user.bvn ?? '',
+        nin: user.nin ?? '',
+        dateOfBirth: user.dateOfBirth ?? '',
+      })
+      .then((r) => r.data.payload),
+
+  // Get user profile using PSSP id
+  getUser: (psspId: string) =>
+    http()
+      .get<{ payload: FPAccount }>(`/get-user-details/${psspId}`)
+      .then((r) => r.data.payload),
+
+  // Get account details using PSSP id
+  getAccount: (psspId: string) =>
+    http()
+      .get<{ payload: FPAccount }>(`/get-accounts-details/${psspId}`)
+      .then((r) => r.data.payload),
+
+  // Get balance using PSSP id
+  getBalance: (psspId: string) =>
+    http()
+      .get<{ payload: { balance: number; currency: string } }>(
+        `/get-balance/${psspId}`
+      )
+      .then((r) => r.data.payload),
 };
 
 export const transferAPI = {
   getBanks: () =>
-    http().get<FPBankItem[]>("/banks").then(r => r.data),
+    http()
+      .get<FPBankItem[]>('/get-banks')
+      .then((r) => r.data),
 
   verifyAccount: (accountNumber: string, bankCode: string) =>
-    http().post<{ accountName: string; accountNumber: string; bankName: string; bankCode: string }>(
-      "/transfer/verify-account", { accountNumber, bankCode }
-    ).then(r => r.data),
-
-  send: (
-    payload: FPSendPaymentRequest
-) =>
-    http().post<FPTransaction>("/transfer/initiate", payload).then(r => r.data),
+    http()
+      .post<{
+        accountName: string;
+        accountNumber: string;
+        bankName: string;
+        bankCode: string;
+      }>('/name-enquiry', {
+        account_no: accountNumber,
+        institution_code: bankCode,
+      })
+      .then((r) => r.data),
+
+  verifyWalletAccount: (accountNumber: string) =>
+    http()
+      .post<{
+        accountName: string;
+        accountNumber: string;
+        bankName: string;
+        bankCode: string;
+      }>('/wallet-name-enquiry', { account_number: accountNumber })
+      .then((r) => r.data),
+
+  validateTransfer: (pin: string, userId: string) =>
+    http()
+      .post<{ status: boolean; message: string }>('/validate-transaction', {
+        pin,
+        user_id: userId,
+      })
+      .then((r) => r.data),
+
+  sendToWallet: (payload: FPSendWalletPaymentRequest, temptId: string) =>
+    http()
+      .post<{ payload: FPTransactionResponse }>('/wallet-transfer-funds', {
+        ...payload,
+        temp_id: temptId,
+      })
+      .then((r) => r.data.payload),
+
+  // Send to external bank account
+  sendToBank: (payload: FPSendPaymentRequest, temptId: string) =>
+    http()
+      .post<{ payload: FPTransactionResponse }>('/transfer-funds', {
+        ...payload,
+        temp_id: temptId,
+      })
+      .then((r) => r.data.payload),
+
+  status: (reference: string) =>
+    http()
+      .get<{ status: FPTxStatus; reference: string }>(
+        '/query-transaction-status/' + reference
+      )
+      .then((r) => r.data),
+
+  verify: (reference: string) =>
+    http()
+      .get<{ FPTransactionResponse: any }>('/transaction/verify/' + reference)
+      .then((r) => r.data),
 };
 
 export const nqrAPI = {
-  generate: (payload: { amount?: number; reference?: string; currency?: string; expiresInMinutes?: number }) =>
-    http().post<FPNQRData>("/payment/nqr/generate", payload).then(r => r.data),
-
-  pay: (payload: FPSendPaymentRequest) =>
-    http().post<FPTransaction>("/payment/nqr/pay", payload).then(r => r.data),
+  generate: (payload: {
+    amount?: number;
+    reference?: string;
+    currency?: string;
+    expiresInMinutes?: number;
+  }) =>
+    http()
+      .post<FPNQRData>('/generate-nqr', payload)
+      .then((r) => r.data),
+
+  pay: (payload: FPSendPaymentRequest, temptId: string) =>
+    http()
+      .post<FPTransactionResponse>('/pay-nqr', { ...payload, temp_id: temptId })
+      .then((r) => r.data),
 };
 
 export const nfcAPI = {
-  pay: (payload: FPSendPaymentRequest) =>
-    http().post<FPTransaction>("/payment/nfc/pay", payload).then(r => r.data),
+  pay: (payload: FPSendPaymentRequest, temptId: string) =>
+    http()
+      .post<FPTransactionResponse>('/pay-nfc', { ...payload, temp_id: temptId })
+      .then((r) => r.data),
 };
 
 export const proximityAPI = {
-  broadcast: (payload: { latitude: number; longitude: number; user: string; email: string; accountName: string; accountNumber: string; bankCode: string; bankName: string }) =>
-    http().post<{ sessionId: string }>("/proximity/broadcast", payload).then(r => r.data),
+  broadcast: (
+    psspId: string,
+    payload: { latitude: number; longitude: number; user_type: string }
+  ) =>
+    http()
+      .post<{ sessionId: string }>(`/broadcast-proximity/${psspId}`, payload)
+      .then((r) => r.data),
 
   heartbeat: (sessionId: string, lat: number, lng: number) =>
-    http().patch("/proximity/broadcast/" + sessionId, { latitude: lat, longitude: lng }),
+    http().patch(`/broadcast-proximity/${sessionId}`, {
+      latitude: lat,
+      longitude: lng,
+    }),
 
   unregister: (sessionId: string) =>
-    http().delete("/proximity/broadcast/" + sessionId),
-
-  discover: (lat: number, lng: number, radiusMeters: number) =>
-    http().post<{ peers: FPProximityPeer[] }>(
-      "/proximity/discover", { latitude: lat, longitude: lng, radiusMeters }
-    ).then(r => r.data.peers),
-};
-
-
-export const transactionAPI = {
-  status: (reference: string) =>
-    http().get<{ status: FPTxStatus; reference: string }>("/transaction/verify/" + reference).then(r => r.data),
-
-  verify: (reference: string) =>
-    http().get<{ FPTransaction: any }>("/transaction/verify/" + reference).then(r => r.data),
-
-  validateOtp: (otp: string, email: string) =>
-    http().post<{Response: any}>("/verify-otp", {otp, email}).then(r=>r.data)
+    http().delete('/broadcast-proximity/' + sessionId),
+
+  discover: (psspId: string, lat: number, lng: number, radius_meters: number) =>
+    http()
+      .post<{ peers: FPProximityPeer[] }>(`/discover-proximity/${psspId}`, {
+        latitude: lat,
+        longitude: lng,
+        radius_meters,
+      })
+      .then((r) => r.data),
 };