react-native-fpay 0.4.30 → 0.4.33

package/src/FountainPayProvider.tsx

@@ -31,6 +31,7 @@ import type {
   FPTransferRecipient,
   FPAccount,
   FPBalance,
+  FPBillCategory,
 } from './core/types';
 import { accountAPI, authenticateAPI, transferAPI } from './core/api';
 
@@ -255,6 +256,12 @@ export function FountainPayProvider({
         FPEngine.showReceive(amount, currency);
       },
 
+      /** Open the Bill Payment bottom sheet for a category. */
+      payBill(amount: number, category: FPBillCategory): void {
+        console.log('[FountainPay] payBill() called:', amount, category);
+        FPEngine.showBills(amount, category);
+      },
+
       /** Generate a virtual account number (no UI shown). */
       async generateAccountNumber(user: FPUserInfo): Promise<FPAccount> {
         console.log(

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

@@ -213,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;
@@ -254,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/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';