react-native-fpay 0.4.29 → 0.4.31

package/src/core/api/index.ts

@@ -13,6 +13,18 @@ import {
   type FPTransactionResponse,
   type FPBalance,
   type HttpCallResponseFormat,
+  type FPNetworkOperator,
+  type FPNetworkCode,
+  type FPDataPlan,
+  type FPBillProvider,
+  type FPBillTariff,
+  type FPMeterLookupResult,
+  type FPMeterType,
+  type FPAirtimePurchaseRequest,
+  type FPDataPurchaseRequest,
+  type FPElectricityPurchaseRequest,
+  type FPCablePurchaseRequest,
+  type FPBillTransaction,
   BUSINESSID,
 } from '../types';
 
@@ -20,32 +32,32 @@ export const healthAPI = {
   ping: () =>
     http()
       .get('/health')
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 };
 
 export const authenticateAPI = {
   login: (appId: string) =>
     http()
       .post('/auth', { user_id: appId })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   profile: () =>
     http()
       .get(`/get-user-details`)
-      .then((r) => r.data.payload),
+      .then((r: any) => r.data.payload),
 
   logout: () =>
     http()
       .post('/auth/logout')
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   validateOtp: (otp: string, email: string) =>
     http()
       .post<{ Response: any }>('/verify-otp', { otp, email })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   validateToken: () =>
-    http().get<{response: HttpCallResponseFormat}>('/auth/agent/validate-token').then(r => r.data),
+    http().get<{response: HttpCallResponseFormat}>('/auth/agent/validate-token').then((r: any) => r.data),
 
   sendSmsOtp: async(payload: any)=>
     http()
@@ -54,22 +66,22 @@ export const authenticateAPI = {
         message: string;
         payload:any
       }>("shared/send-sms-otp", payload)
-      .then((r)=>r.data),
+      .then((r: any)=>r.data),
   
   verifyBvn: async() => 
     http()
       .get<{response: HttpCallResponseFormat}>("verify-bvn")
-      .then((r)=>r.data),
+      .then((r: any)=>r.data),
 
   verifySms: async(payload: any)=>
      http()
       .post<{response: HttpCallResponseFormat}>("verify-bvn", payload)
-      .then((r)=>r.data),
+      .then((r: any)=>r.data),
 
   updateProfile: async(payload: any)=>
      http()
       .put<{response: HttpCallResponseFormat}>("update-user-agent", payload)
-      .then((r)=>r.data),
+      .then((r: any)=>r.data),
 };
 
 export const accountAPI = {
@@ -85,17 +97,17 @@ export const accountAPI = {
         nin: user.nin ?? '',
         dateOfBirth: user.dateOfBirth ?? '',
       })
-      .then((r) => r.data.payload),
+      .then((r: any) => r.data.payload),
 
   // Get account details using PSSP id
   getAccount: () =>
     http()
       .get<{ payload: FPAccount }>(`/get-accounts-details`)
-      .then((r) => r.data.payload),
+      .then((r: any) => r.data.payload),
 
   getAgentBalance: () =>
     http().get<{ payload: FPBalance }>(`/get-balance`)
-      .then(r => r.data.payload),
+      .then((r: any) => r.data.payload),
       
 };
 
@@ -103,7 +115,7 @@ export const transferAPI = {
   getBanks: () =>
     http()
       .get<FPBankItem[]>('/get-banks')
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   verifyAccount: (accountNumber: string, bankCode: string) =>
     http()
@@ -116,7 +128,7 @@ export const transferAPI = {
         account_no: accountNumber,
         institution_code: bankCode,
       })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   verifyWalletAccount: (accountNumber: string) =>
     http()
@@ -126,16 +138,16 @@ export const transferAPI = {
         bankName: string;
         bankCode: string;
       }>('/wallet-name-enquiry', { account_number: accountNumber })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   validateTransfer: (pin: string, userId: string, receiverId: string) =>
     http()
-      .post<{ status: boolean; message: string }>('/validate-transaction', {
+      .post<{ status: boolean; message: string; payload?: { temp_id: string } }>('/validate-transaction', {
         pin,
         sender_type: 'AGENT',
         receiver_id: receiverId,
       })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   sendToWallet: (payload: any, temptId: string) =>
     http()
@@ -143,7 +155,7 @@ export const transferAPI = {
         ...payload,
         temp_id: temptId,
       })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   // Send to external bank account
   sendToBank: (payload: FPSendPaymentRequest, temptId: string) =>
@@ -152,19 +164,19 @@ export const transferAPI = {
         ...payload,
         temp_id: temptId,
       })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   status: (reference: string) =>
     http()
       .get<{ status: FPTxStatus; reference: string }>(
         '/get-transaction-status/' + reference
       )
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   verify: (reference: string) =>
     http()
       .get<{ FPTransactionResponse: any }>('/transaction/verify/' + reference)
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 };
 
 export const nqrAPI = {
@@ -176,19 +188,19 @@ export const nqrAPI = {
   }) =>
     http()
       .post<FPNQRData>('/generate-nqr', payload)
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   pay: (payload: FPSendPaymentRequest, temptId: string) =>
     http()
       .post<FPTransactionResponse>('/pay-nqr', { ...payload, temp_id: temptId })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 };
 
 export const nfcAPI = {
   pay: (payload: FPSendPaymentRequest, temptId: string) =>
     http()
       .post<FPTransactionResponse>('/pay-nfc', { ...payload, temp_id: temptId })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 };
 
 export const proximityAPI = {
@@ -198,7 +210,7 @@ export const proximityAPI = {
   ) =>
     http()
       .post<{ sessionId: string }>(`/broadcast-proximity/${psspId}`, payload)
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 
   heartbeat: (sessionId: string, lat: number, lng: number) =>
     http().patch(`/broadcast-proximity/${sessionId}`, {
@@ -216,5 +228,115 @@ export const proximityAPI = {
         longitude: lng,
         radius_meters,
       })
-      .then((r) => r.data),
+      .then((r: any) => r.data),
 };
+
+
+export const subscriptionAPI = {
+  create: (
+    payload: any
+  ) =>
+    http()
+      .post<{ sessionId: string }>(`/subscription/`, payload)
+      .then((r: any) => r.data),
+}
+
+export const billsAPI = {
+  getNetworks: () =>
+    http()
+      .get<{ status: boolean; payload: FPNetworkOperator[] }>('/bills/networks')
+      .then((r: any) => r.data),
+
+  getDataPlans: (network: FPNetworkCode) =>
+    http()
+      .get<{ status: boolean; payload: FPDataPlan[] }>('/bills/data-plans', {
+        params: { network },
+      })
+      .then((r: any) => r.data),
+
+  getDiscos: () =>
+    http()
+      .get<{ status: boolean; payload: FPBillProvider[] }>('/bills/electricity/discos')
+      .then((r: any) => r.data),
+
+  /** Validates a meter number against a disco before purchase — mirrors
+   * the existing CheckMeterNo() lookup in Tapit's BuyPower-backed
+   * Electricity screen, generalized behind this SDK's own endpoint. */
+  validateMeter: (meterNumber: string, disco: string, meterType: FPMeterType) =>
+    http()
+      .post<{ status: boolean; message: string; payload: FPMeterLookupResult }>(
+        '/bills/electricity/validate-meter',
+        { meter_number: meterNumber, disco, meter_type: meterType }
+      )
+      .then((r: any) => r.data),
+
+  getCableProviders: () =>
+    http()
+      .get<{ status: boolean; payload: FPBillProvider[] }>('/bills/cable/providers')
+      .then((r: any) => r.data),
+
+  getCableTariffs: (provider: string) =>
+    http()
+      .get<{ status: boolean; payload: FPBillTariff[] }>('/bills/cable/tariffs', {
+        params: { provider },
+      })
+      .then((r: any) => r.data),
+
+  /** Validates a smartcard/IUC number before purchase. */
+  validateSmartcard: (smartcardNumber: string, provider: string) =>
+    http()
+      .post<{ status: boolean; message: string; payload: FPMeterLookupResult }>(
+        '/bills/cable/validate-smartcard',
+        { smartcard_number: smartcardNumber, provider }
+      )
+      .then((r: any) => r.data),
+
+  /** Separate from transferAPI.validateTransfer — bills have no transfer
+   * recipient, so this hits its own backend endpoint rather than reusing
+   * /validate-transaction's receiver_id-shaped contract. One endpoint
+   * covers all four categories — the backend doesn't need to know which
+   * category is being authorized at PIN-check time. */
+  validateBillPin: (pin: string, userId: string) =>
+    http()
+      .post<{ status: boolean; message: string; payload: { temp_id: string } }>(
+        '/bills/validate-pin',
+        { pin, user_id: userId }
+      )
+      .then((r: any) => r.data),
+
+  purchaseAirtime: (payload: FPAirtimePurchaseRequest, tempId: string) =>
+    http()
+      .post<{ status: boolean; message: string; payload: FPBillTransaction }>(
+        '/bills/airtime',
+        { ...payload, temp_id: tempId }
+      )
+      .then((r: any) => r.data),
+
+  purchaseData: (payload: FPDataPurchaseRequest, tempId: string) =>
+    http()
+      .post<{ status: boolean; message: string; payload: FPBillTransaction }>(
+        '/bills/data',
+        { ...payload, temp_id: tempId }
+      )
+      .then((r: any) => r.data),
+
+  purchaseElectricity: (payload: FPElectricityPurchaseRequest, tempId: string) =>
+    http()
+      .post<{ status: boolean; message: string; payload: FPBillTransaction }>(
+        '/bills/electricity',
+        { ...payload, temp_id: tempId }
+      )
+      .then((r: any) => r.data),
+
+  purchaseCable: (payload: FPCablePurchaseRequest, tempId: string) =>
+    http()
+      .post<{ status: boolean; message: string; payload: FPBillTransaction }>(
+        '/bills/cable',
+        { ...payload, temp_id: tempId }
+      )
+      .then((r: any) => r.data),
+
+  /** Bill transactions live in the same agencyTransaction table as
+   * transfers, so the existing status endpoint is reused as-is. */
+  status: (reference: string) => transferAPI.status(reference),
+};

package/src/core/types/index.ts

@@ -14,6 +14,11 @@ export type FPTxStatus =
   | 'reversed';
 export type FPTxType = 'debit' | 'credit';
 
+export type MovementPayload = {
+  latitude:  number;
+  longitude: number;
+  address?:  string;
+};
 export interface FPUserInfo {
   firstName: string;
   lastName: string;
@@ -91,24 +96,21 @@ export interface FPSendPaymentRequest {
   isBank?: boolean;
   channel: 'transfer' | 'proximity' | 'bluetooth' | 'nfc' | 'nqr';
   currency?: string;
-  recipient:
-    | FPInternalTransferRecipient
-    | FPTransferRecipient
-    | FPNfcRecipient
-    | FPNqrRecipient
-    | FPWalletTransferRecipient;
+  movement?: MovementPayload; 
+  recipient: any
 }
 
 export interface FPSendWalletPaymentRequest {
-  sender_id: string;
-  sender_type: 'USER' | 'AGENT';
+  sender_id?: string;
+  sender_type?: 'USER' | 'AGENT';
   recipient: any;
   amount: string;
   reference: string;
   narration: string;
   currency?: string;
-  isBank?: false;
-  channel: 'transfer' | 'proximity' | 'bluetooth';
+  isBank?: boolean;
+  channel: 'transfer' | 'proximity' | 'bluetooth' | 'nfc' | 'nqr';
+  movement?: MovementPayload;
 }
 
 export interface FPNfcTransfer {
@@ -211,6 +213,11 @@ export interface FPInstance {
   initializeSDK: (user: FPUserInfo | null, callbacks?: FPCallbacks) => Promise<void>;
   send: (amount: number, currency: FPCurrency) => void;
   receive: (amount?: number, currency?: FPCurrency) => void;
+  /** Open the Bill Payment bottom sheet for a given category and amount —
+   * mirrors send(amount, currency). The amount may be adjusted inside the
+   * sheet for categories where the user picks a plan/tariff (DATA, CABLE)
+   * rather than typing a free amount (AIRTIME, ELECTRICITY). */
+  payBill: (amount: number, category: FPBillCategory) => void;
   generateAccountNumber: (user: FPUserInfo) => Promise<FPAccount>;
   refreshBalance: () => Promise<void>;
   listen: () => void;
@@ -239,7 +246,7 @@ export interface Props {
   currency?: FPCurrency;
   onClose: () => void;
   onProcessTransaction?: (
-    tx: FPSendPaymentRequest | FPSendWalletPaymentRequest | null
+    tx: FPSendWalletPaymentRequest | null
   ) => void;
   onError?: (err: FPError) => void;
 }
@@ -252,3 +259,179 @@ export interface ReceiveTransferScreenProps {
   onClose?: () => void;
   onPaymentReceived?: (data: any) => void;
 }
+
+export type SubscriptionFreq = 'DAILY' | 'WEEKLY' | 'MONTHLY' | 'YEARLY';
+export type SubscriptionStatus = 'ACTIVE' | 'PAUSED' | 'CANCELLED';
+export type PaymentStatus = 'PENDING' | 'SUCCESS' | 'FAILED';
+
+export interface Subscription {
+  id: string;
+  serviceName: string;
+  serviceCategory: string;
+  amount: number;
+  currency: string;
+  frequency: SubscriptionFreq;
+  nextPaymentDate: string;
+  accountNumber: string;
+  status: SubscriptionStatus;
+  logoUrl?: string;
+  description?: string;
+  createdAt: string;
+  payments?: SubscriptionPayment[];
+}
+
+export interface SubscriptionPayment {
+  id: string;
+  amount: number;
+  status: PaymentStatus;
+  processedAt?: string;
+  failureReason?: string;
+  createdAt: string;
+}
+
+export interface CreateSubscriptionPayload {
+  serviceName: string;
+  serviceCategory: string;
+  amount: number;
+  currency: string;
+  frequency: SubscriptionFreq;
+  nextPaymentDate: string;
+  accountNumber: string;
+  logoUrl?: string;
+}
+
+// ── Bill Payment ───────────────────────────────────────────────
+// Added to support FPInstance.payBill(). Kept fully separate from
+// FPTransferRecipient / FPSendPaymentRequest — bills have no recipient,
+// so nothing here is unioned into the transfer types above.
+//
+// Provider routing (BuyPower today, Paga later, possibly per-category) is
+// resolved entirely on the backend behind /bills/*. Nothing here encodes
+// which provider services a category — the mobile layer is provider-agnostic
+// by design, same as the rest of the SDK.
+
+export type FPBillCategory = 'AIRTIME' | 'DATA' | 'ELECTRICITY' | 'CABLE';
+export type FPNetworkCode = 'MTN' | 'AIRTEL' | 'GLO' | '9MOBILE';
+export type FPMeterType = 'PREPAID' | 'POSTPAID';
+
+export interface FPNetworkOperator {
+  code: FPNetworkCode;
+  displayName: string;
+  logoUrl: string;
+  brandColor: string;
+  isActive: boolean;
+}
+
+export interface FPDataPlan {
+  id: string;
+  network: FPNetworkCode;
+  label: string;       // e.g. "1.5GB"
+  validity: string;    // e.g. "30 days"
+  priceInKobo: number;
+  isAvailable: boolean;
+}
+
+/** A disco (electricity) or cable provider, loaded dynamically — same
+ * pattern as FPNetworkOperator, just for a different bill category. */
+export interface FPBillProvider {
+  code: string;          // e.g. "BENIN", "DSTV"
+  displayName: string;
+  logoUrl?: string;
+  isActive: boolean;
+}
+
+/** A purchasable tariff/plan for electricity (band) or cable (bouquet).
+ * Distinct from FPDataPlan because the fields that matter differ —
+ * electricity tariffs don't have "validity", cable bouquets don't have
+ * a meter-type concept. */
+export interface FPBillTariff {
+  code: string;
+  label: string;       // e.g. "DSTV Compact", "Band A"
+  priceInKobo: number;  // 0 for electricity, where the user enters amount
+  isAvailable: boolean;
+}
+
+/** Returned by the meter/smartcard validation lookup, before purchase —
+ * mirrors what Electricity/index.tsx's checkMeterNumber() currently
+ * resolves locally against BuyPower, now generalized for any category
+ * that requires a pre-purchase ownership check. */
+export interface FPMeterLookupResult {
+  customerName: string;
+  minVendAmountInKobo?: number; // electricity only
+}
+
+/** Generic shape ConfirmScreen/ResultScreen render — built by the caller
+ * (SendScreen builds one from `recipient`, BillsScreen builds one from
+ * network/phone/plan/meter) so neither shared component needs to know what
+ * a "recipient" or a "bill" is. */
+export interface FPSummaryRow {
+  label: string;
+  value: string;
+}
+
+// Discriminated union — each category carries only the fields it actually
+// needs, instead of one shape with a pile of optional fields where "which
+// ones matter" depends on a category nobody can see from the type alone.
+
+export interface FPAirtimePurchaseRequest {
+  category: 'AIRTIME';
+  phoneNumber: string;
+  network: FPNetworkCode;
+  amountInKobo: number;
+  idempotencyKey: string;
+}
+
+export interface FPDataPurchaseRequest {
+  category: 'DATA';
+  phoneNumber: string;
+  network: FPNetworkCode;
+  planId: string;
+  /** The selected plan's price — included here (not just inferred from
+   * planId) so BillsScreen can read amountInKobo generically across every
+   * category for the Confirm screen's amount display, the same way
+   * AIRTIME/ELECTRICITY/CABLE do. */
+  amountInKobo: number;
+  idempotencyKey: string;
+}
+
+export interface FPElectricityPurchaseRequest {
+  category: 'ELECTRICITY';
+  meterNumber: string;
+  disco: string;
+  meterType: FPMeterType;
+  amountInKobo: number;
+  forSelf: boolean;
+  phoneNumber: string;
+  email: string;
+  idempotencyKey: string;
+}
+
+export interface FPCablePurchaseRequest {
+  category: 'CABLE';
+  smartcardNumber: string;
+  provider: string; // e.g. "DSTV"
+  tariffCode: string;
+  amountInKobo: number;
+  phoneNumber: string;
+  idempotencyKey: string;
+}
+
+export type FPBillPurchaseRequest =
+  | FPAirtimePurchaseRequest
+  | FPDataPurchaseRequest
+  | FPElectricityPurchaseRequest
+  | FPCablePurchaseRequest;
+
+export interface FPBillTransaction {
+  id: string;
+  reference: string;
+  category: FPBillCategory;
+  status: FPTxStatus;
+  amount: number;
+  currency: FPCurrency;
+  identifier: string;
+  network?: FPNetworkCode;  // AIRTIME/DATA only
+  provider?: string;        // ELECTRICITY/CABLE only
+  planLabel?: string;
+  createdAt: string;
+}

package/src/engine/FPEngine.ts

@@ -22,6 +22,7 @@ import type {
   FPTransferRecipient,
   FPAccount,
   FPBalance,
+  FPBillCategory,
 } from '../core/types';
 import BLEReceiverService, {
   type BLEPaymentRequest,
@@ -55,7 +56,9 @@ type FPEventName =
   | 'incoming_payment_request'
   | 'show_send'
   | 'show_receive'
-  | 'close_send';
+  | 'close_send'
+  | 'show_bills'
+  | 'close_bills';
 const _listeners = new Map<FPEventName, Set<Function>>();
 
 export function _emitEvent(event: FPEventName, data?: unknown): void {
@@ -633,6 +636,14 @@ export const FPEngine = {
     _emitEvent('show_receive', { amount, currency });
   },
 
+  closeBills(): void {
+    _emitEvent('close_bills');
+  },
+
+  showBills(amount: number, category: FPBillCategory): void {
+    _emitEvent('show_bills', { amount, category });
+  },
+
   getUser: () => _user,
   getAccount: () => _account,
   isReady: () => _isReady,

package/src/hooks/useLocation.ts

@@ -0,0 +1,81 @@
+// hooks/useLocation.ts
+
+import { useState, useCallback } from 'react';
+import { Platform, PermissionsAndroid, Alert } from 'react-native';
+import Geolocation from '@react-native-community/geolocation';
+
+export type LocationData = {
+  latitude:  number;
+  longitude: number;
+};
+
+export type LocationState = {
+  location:       LocationData | null;
+  loading:        boolean;
+  error:          string | null;
+  requestLocation: () => Promise<LocationData | null>;
+};
+
+export function useLocation(): LocationState {
+  const [location, setLocation] = useState<LocationData | null>(null);
+  const [loading,  setLoading]  = useState(false);
+  const [error,    setError]    = useState<string | null>(null);
+
+  const requestAndroidPermission = async (): Promise<boolean> => {
+    const granted = await PermissionsAndroid.request(
+      PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+      {
+        title:   'Location Permission',
+        message: 'FountainPay needs your location to record where transactions are processed',
+        buttonPositive: 'Allow',
+        buttonNegative: 'Deny',
+      },
+    );
+    return granted === PermissionsAndroid.RESULTS.GRANTED;
+  };
+
+  const requestLocation = useCallback((): Promise<LocationData | null> => {
+    return new Promise(async (resolve) => {
+      setLoading(true);
+      setError(null);
+
+      // Request permission on Android
+      if (Platform.OS === 'android') {
+        const granted = await requestAndroidPermission();
+        if (!granted) {
+          setError('Location permission denied');
+          setLoading(false);
+          resolve(null);
+          return;
+        }
+      }
+
+      Geolocation.getCurrentPosition(
+        (position) => {
+          const data: LocationData = {
+            latitude:  position.coords.latitude,
+            longitude: position.coords.longitude,
+          };
+          setLocation(data);
+          setLoading(false);
+          resolve(data);
+        },
+        (err) => {
+          const message = err.message || 'Could not get location';
+          setError(message);
+          setLoading(false);
+          // Resolve null — transfer can still proceed without location
+          // Python/Django will omit movement block if null
+          resolve(null);
+        },
+        {
+          enableHighAccuracy: true,
+          timeout:            8000,   // 8 seconds max — never block transaction
+          maximumAge:         0,      // always fresh — no cached position
+        },
+      );
+    });
+  }, []);
+
+  return { location, loading, error, requestLocation };
+}

package/src/index.ts

@@ -34,4 +34,12 @@ export type {
   FPError,
   FPTxStatus,
   FPChannel,
-} from './core/types';
+  FPBillCategory,
+  FPNetworkCode,
+  FPMeterType,
+  FPNetworkOperator,
+  FPDataPlan,
+  FPBillProvider,
+  FPBillTariff,
+  FPBillTransaction,
+} from './core/types';