White-Label Setup

const kyb = await fossapay.business.submitVerification({
  business_name: 'Your Neobank Ltd',
  business_type: 'fintech',
  registration_number: 'RC1234567',
  tax_id: 'TIN123456',
  business_address: {
    street: '123 Business St',
    city: 'Lagos',
    state: 'Lagos',
    country: 'NG'
  },
  documents: {
    cac: cacDocumentBuffer,
    directors: directorsDocumentBuffer,
    bank_statement: bankStatementBuffer
  }
});

await fossapay.business.updateSettings({
  business_name: 'Your Neobank',
  support_email: '[email protected]',
  support_phone: '+2341234567890',
  website: 'https://yourneobank.com',
  logo_url: 'https://yourneobank.com/logo.png'
});

await fossapay.whitelabel.setBranding({
  brand_name: 'YourBank',
  primary_color: '#0080FF',
  secondary_color: '#00C9A7',
  logo: {
    light: 'https://cdn.yourneobank.com/logo-light.png',
    dark: 'https://cdn.yourneobank.com/logo-dark.png'
  },
  account_name_format: 'YOURBANK - {customer_name}' // How virtual accounts appear
});

await fossapay.whitelabel.setEmailTemplates({
  welcome_email: {
    subject: 'Welcome to YourBank!',
    template: welcomeEmailTemplate,
    from_name: 'YourBank Team',
    from_email: '[email protected]'
  },
  payment_received: {
    subject: 'Payment Received',
    template: paymentReceivedTemplate
  },
  payout_completed: {
    subject: 'Transfer Completed',
    template: payoutCompletedTemplate
  }
});

await fossapay.whitelabel.configureWallets({
  currencies: ['NGN', 'USDT', 'USDC'],
  features: {
    p2p_transfers: true,
    bank_transfers: true,
    bill_payments: true,
    savings: true,
    virtual_cards: false // Coming soon
  },
  limits: {
    daily_transfer_limit: 5000000,
    single_transaction_limit: 1000000,
    monthly_volume_limit: 50000000
  }
});

await fossapay.whitelabel.configureKYC({
  tier1: {
    requirements: ['email', 'phone'],
    limits: {
      daily: 50000,
      monthly: 300000,
      balance: 300000
    }
  },
  tier2: {
    requirements: ['bvn', 'address'],
    limits: {
      daily: 200000,
      monthly: 1000000,
      balance: 1000000
    }
  },
  tier3: {
    requirements: ['government_id', 'selfie', 'proof_of_address'],
    limits: {
      daily: 5000000,
      monthly: null, // unlimited
      balance: null
    }
  }
});

await fossapay.whitelabel.setPricing({
  customer_fees: {
    transfer_fee: 50, // Charge customers ₦50 per transfer
    transfer_fee_cap: 100,
    withdrawal_fee_percentage: 0.5, // 0.5% of withdrawal amount
    wallet_maintenance: 0 // Free
  },
  wholesale_costs: {
    // What Fossapay charges you (agreed in contract)
    virtual_account_creation: 0,
    transfer_fee: 25,
    payout_fee: 30
  }
});

await fossapay.webhooks.configure({
  url: 'https://api.yourneobank.com/webhooks/fossapay',
  events: [
    'payment.received',
    'payout.completed',
    'payout.failed',
    'wallet.credited',
    'wallet.debited',
    'kyc.verified',
    'kyc.failed'
  ],
  secret: process.env.WEBHOOK_SECRET
});

// When user signs up on your platform
async function onboardCustomer(user) {
  // 1. Create customer in Fossapay
  const customer = await fossapay.customers.create({
    email: user.email,
    phone: user.phone,
    first_name: user.firstName,
    last_name: user.lastName,
    metadata: {
      internal_user_id: user.id
    }
  });

  // 2. Create wallet
  const wallet = await fossapay.wallets.create({
    type: 'customer',
    customer_id: customer.customer_id,
    customer_name: `${user.firstName} ${user.lastName}`,
    customer_email: user.email,
    currencies: ['NGN']
  });

  // 3. Create virtual account for deposits
  const virtualAccount = await fossapay.virtualAccounts.create({
    type: 'dedicated',
    customer_name: `${user.firstName} ${user.lastName}`,
    customer_email: user.email,
    metadata: {
      wallet_id: wallet.wallet_id,
      user_id: user.id
    }
  });

  // 4. Save to your database
  await db.customers.create({
    user_id: user.id,
    fossapay_customer_id: customer.customer_id,
    wallet_id: wallet.wallet_id,
    virtual_account_number: virtualAccount.account_number,
    virtual_account_id: virtualAccount.virtual_account_id
  });

  return {
    wallet,
    virtualAccount
  };
}

// Webhook handler for automatic wallet top-ups
app.post('/webhooks/fossapay', async (req, res) => {
  const { event, data } = req.body;

  if (event === 'payment.received') {
    // Get customer from metadata
    const walletId = data.metadata.wallet_id;

    // Credit wallet
    await fossapay.wallets.credit({
      wallet_id: walletId,
      amount: data.amount,
      currency: 'NGN',
      reference: data.transaction_id,
      narration: 'Account top-up'
    });

    // Update your database
    await db.transactions.create({
      user_id: data.metadata.user_id,
      type: 'deposit',
      amount: data.amount,
      status: 'completed',
      reference: data.transaction_id
    });

    // Notify user
    await sendPushNotification(data.metadata.user_id, {
      title: 'Deposit Received',
      body: `Your account has been credited with ₦${data.amount.toLocaleString()}`
    });
  }

  res.status(200).send('OK');
});

async function processWithdrawal(userId, amount, bankDetails) {
  // 1. Get customer wallet
  const customer = await db.customers.findOne({ user_id: userId });

  // 2. Check balance
  const balance = await fossapay.wallets.getBalance(customer.wallet_id);

  if (balance.data.balances[0].available_balance < amount) {
    throw new Error('Insufficient balance');
  }

  // 3. Debit wallet
  const debit = await fossapay.wallets.debit({
    wallet_id: customer.wallet_id,
    amount: amount,
    currency: 'NGN',
    reference: `withdrawal-${Date.now()}`,
    narration: 'Bank withdrawal'
  });

  // 4. Process payout
  const payout = await fossapay.payouts.create({
    amount: amount,
    account_number: bankDetails.account_number,
    account_name: bankDetails.account_name,
    bank_code: bankDetails.bank_code,
    reference: debit.reference,
    narration: 'Withdrawal'
  });

  // 5. Save transaction
  await db.transactions.create({
    user_id: userId,
    type: 'withdrawal',
    amount: amount,
    status: 'pending',
    payout_id: payout.data.payout_id,
    reference: debit.reference
  });

  return payout;
}

// Use test API keys
const fossapayTest = new Fossapay('fp_test_sk_xxxxxxxx');

// Test customer creation
const testCustomer = await fossapayTest.customers.create({
  email: '[email protected]',
  phone: '+2348012345678',
  first_name: 'Test',
  last_name: 'User'
});

// Test virtual account creation
const testVA = await fossapayTest.virtualAccounts.create({
  customer_name: 'Test User',
  customer_email: '[email protected]'
});

// Simulate payment
await fossapayTest.sandbox.simulatePayment({
  virtual_account_number: testVA.data.account_number,
  amount: 10000,
  sender_name: 'Test Sender'
});

// Test payout
await fossapayTest.payouts.create({
  amount: 5000,
  account_number: '0000000001', // Test account
  account_name: 'Test Recipient',
  bank_code: '058',
  reference: `test-payout-${Date.now()}`
});

// Replace test keys with live keys
const fossapayLive = new Fossapay('fp_live_sk_xxxxxxxx');

// Update webhook URL to production
await fossapayLive.webhooks.configure({
  url: 'https://api.yourneobank.com/webhooks/fossapay',
  secret: process.env.PRODUCTION_WEBHOOK_SECRET
});

// Daily reconciliation
cron.schedule('0 1 * * *', async () => {
  await reconcileTransactions();
  await checkSettlements();
  await generateDailyReport();
});

// Monitor wallet balances
async function monitorBalances() {
  const wallets = await db.customers.findAll();

  for (const customer of wallets) {
    const fpBalance = await fossapay.wallets.getBalance(customer.wallet_id);
    const dbBalance = await db.wallets.getBalance(customer.user_id);

    if (fpBalance !== dbBalance) {
      await alertMismatch(customer.user_id);
    }
  }
}