// Création de compte Simiz et obtention des clés API
// 1. Créer un compte sur https://simiz.io/register
// 2. Compléter le KYB (5-10 minutes)
// 3. Obtenir les clés API instantanément
const simiz = new Simiz({
  apiKey: 'smz_test_pk_burkina_xxxxx',
  secretKey: 'smz_test_sk_burkina_xxxxx',
  environment: 'sandbox'
});

.env file
ORANGE_MONEY_CLIENT_ID=bf_sandbox_client_xxxxx
ORANGE_MONEY_CLIENT_SECRET=bf_sandbox_secret_xxxxx
ORANGE_MONEY_API_KEY=bf_api_key_xxxxx
ORANGE_MONEY_MERCHANT_ID=BF_MERCHANT_XXXXX
ORANGE_MONEY_WEBHOOK_SECRET=webhook_secret_xxxxx
ORANGE_MONEY_ENVIRONMENT=sandbox
OU avec Simiz (recommandé)
SIMIZ_API_KEY=smz_test_pk_burkina_xxxxx
SIMIZ_SECRET_KEY=smz_test_sk_burkina_xxxxx
SIMIZ_ENVIRONMENT=sandbox

npm install @simiz/sdk axios

pip install simiz-sdk requests

// config/orange-money.js
import { Simiz } from '@simiz/sdk';
export const paymentProvider = new Simiz({
  apiKey: process.env.SIMIZ_API_KEY,
  secretKey: process.env.SIMIZ_SECRET_KEY,
  environment: process.env.SIMIZ_ENVIRONMENT || 'sandbox',
  webhookSecret: process.env.SIMIZ_WEBHOOK_SECRET
});
export default paymentProvider;

config/orange_money.py
from simiz_sdk import Simiz
import os
payment_provider = Simiz(
    api_key=os.getenv('SIMIZ_API_KEY'),
    secret_key=os.getenv('SIMIZ_SECRET_KEY'),
    environment=os.getenv('SIMIZ_ENVIRONMENT', 'sandbox'),
    webhook_secret=os.getenv('SIMIZ_WEBHOOK_SECRET')
)

// services/payment.js
import { paymentProvider } from '../config/orange-money.js';
export async function createOrangeMoneyPayment(amount, phone, reference) {
  try {
    const payment = await paymentProvider.payments.create({
      amount: amount,
      currency: 'XOF',                  // Franc CFA West Africa
      phone: formatPhoneBurkina(phone),  // Format: +226 XX XX XX XX
      provider: 'orange_money_burkina',
      reference: reference,
      description: 'Paiement sur MaPlateforme',
      webhookUrl: 'https://votre-site.com/webhooks/orange-money',
      metadata: {
        country: 'BF',
        merchant_reference: reference
      }
    });
    return {
      success: true,
      paymentId: payment.id,
      status: payment.status,
      expiresAt: payment.expiresAt
    };
  } catch (error) {
    console.error('Erreur création paiement:', error);
    return {
      success: false,
      error: error.message
    };
  }
}
function formatPhoneBurkina(phone) {
  // Nettoyer et formater au format international +226
  const cleaned = phone.replace(/\D/g, '');
  if (cleaned.startsWith('226')) {
    return +${cleaned};
  }
  if (cleaned.length === 8) {
    return +226${cleaned};
  }
  return phone;
}

services/payment.py
from config.orange_money import payment_provider
import re
def create_orange_money_payment(amount: int, phone: str, reference: str):
    try:
        payment = payment_provider.payments.create(
            amount=amount,
            currency='XOF',
            phone=format_phone_burkina(phone),
            provider='orange_money_burkina',
            reference=reference,
            description='Paiement sur MaPlateforme',
            webhook_url='https://votre-site.com/webhooks/orange-money',
            metadata={
                'country': 'BF',
                'merchant_reference': reference
            }
        )
        return {
            'success': True,
            'payment_id': payment.id,
            'status': payment.status,
            'expires_at': payment.expires_at
        }
    except Exception as error:
        print(f'Erreur création paiement: {error}')
        return {
            'success': False,
            'error': str(error)
        }
def format_phone_burkina(phone: str) -> str:
    cleaned = re.sub(r'\D', '', phone)
    if cleaned.startswith('226'):
        return f'+{cleaned}'
    if len(cleaned) == 8:
        return f'+226{cleaned}'
    return phone

// routes/webhooks.js
import express from 'express';
import { paymentProvider } from '../config/orange-money.js';
const router = express.Router();
router.post('/orange-money', express.raw({type: 'application/json'}), (req, res) => {
  const signature = req.headers['x-simiz-signature'];
  const payload = req.body;
  // Vérification de la signature webhook
  if (!paymentProvider.webhooks.verify(payload, signature)) {
    console.error('Signature webhook invalide');
    return res.status(401).json({ error: 'Invalid signature' });
  }
  const event = JSON.parse(payload);
  switch (event.type) {
    case 'payment.success':
      handlePaymentSuccess(event.data);
      break;
    case 'payment.failed':
      handlePaymentFailed(event.data);
      break;
    case 'payment.expired':
      handlePaymentExpired(event.data);
      break;
  }
  res.json({ received: true });
});
async function handlePaymentSuccess(payment) {
  // Mettre à jour votre base de données
  // Confirmer la commande
  // Envoyer notification au client
  console.log(Paiement ${payment.id} réussi pour ${payment.reference});
}
async function handlePaymentFailed(payment) {
  // Annuler la commande
  // Notifier le client
  console.log(Paiement ${payment.id} échoué: ${payment.failureReason});
}
async function handlePaymentExpired(payment) {
  // Libérer le stock
  // Notifier le client
  console.log(Paiement ${payment.id} expiré);
}
export default router;

// tests/payment.test.js
import { createOrangeMoneyPayment } from '../services/payment.js';
import { paymentProvider } from '../config/orange-money.js';
async function testScenarios() {
  const testCases = [
    { phone: '+22670000001', amount: 5000, scenario: 'Succès' },
    { phone: '+22670000002', amount: 500000, scenario: 'Solde insuffisant' },
    { phone: '+22670000003', amount: 5000, scenario: 'Annulation' },
    { phone: '+22670000004', amount: 5000, scenario: 'Timeout' }
  ];
  for (const testCase of testCases) {
    console.log(\n--- Test : ${testCase.scenario} ---);
    console.log(Numéro: ${testCase.phone});
    console.log(Montant: ${testCase.amount} XOF);
    const result = await createOrangeMoneyPayment(
      testCase.amount,
      testCase.phone,
      TEST-${Date.now()}
    );
    if (result.success) {
      console.log(✓ Paiement créé: ${result.paymentId});
      console.log(  Statut: ${result.status});
      console.log(  Expiration: ${result.expiresAt});
      // Attendre et vérifier le statut final
      await new Promise(resolve => setTimeout(resolve, 3000));
      const status = await paymentProvider.payments.retrieve(result.paymentId);
      console.log(  Statut final: ${status.status});
    } else {
      console.log(✗ Erreur: ${result.error});
    }
  }
}
testScenarios();

Installation ngrok
npm install -g ngrok
Lancer votre serveur local
npm run dev
Dans un autre terminal, exposer le port
ngrok http 3000
Configurer l'URL webhook dans votre dashboard Simiz
https://votre-id.ngrok.io/webhooks/orange-money

// services/payment-handler.js
export class PaymentHandler {
  static handlePaymentError(error, context) {
    const errorMap = {
      'INVALID_PHONE': {
        userMessage: 'Le numéro de téléphone est invalide. Veuillez entrer un numéro au format +226 XX XX XX XX.',
        retryable: false
      },
      'AMOUNT_OUT_OF_RANGE': {
        userMessage: 'Le montant doit être compris entre 100 et 500 000 FCFA.',
        retryable: false
      },
      'INSUFFICIENT_FUNDS': {
        userMessage: 'Le solde Orange Money est insuffisant. Veuillez recharger votre compte ou utiliser un autre moyen de paiement.',
        retryable: false
      },
      'USER_NOT_FOUND': {
        userMessage: 'Ce numéro n\'est pas associé à un compte Orange Money. Vérifiez le numéro.',
        retryable: false
      },
      'DUPLICATE_REFERENCE': {
        userMessage: 'Une erreur technique est survenue. Veuillez réessayer.',
        retryable: true,
        action: 'generateNewReference'
      },
      'RATE_LIMIT_EXCEEDED': {
        userMessage: 'Trop de tentatives. Veuillez attendre quelques instants.',
        retryable: true,
        delay: 5000
      },
      'PROVIDER_ERROR': {
        userMessage: 'Un problème temporaire est survenu. Veuillez réessayer dans quelques minutes.',
        retryable: true,
        delay: 30000
      }
    };
    const errorCode = error.code || 'UNKNOWN_ERROR';
    const errorConfig = errorMap[errorCode] || errorMap['PROVIDER_ERROR'];
    // Log pour monitoring
    this.logError(error, context, errorCode);
    return {
      userMessage: errorConfig.userMessage,
      retryable: errorConfig.retryable,
      retryDelay: errorConfig.delay || 0,
      action: errorConfig.action
    };
  }
  static logError(error, context, code) {
    // Envoyer à votre système de monitoring
    // Sentry, DataDog, ou votre propre solution
    console.error({
      timestamp: new Date().toISOString(),
      code,
      message: error.message,
      context: {
        phone: context.phone,
        amount: context.amount,
        reference: context.reference
      }
    });
  }
  static async retryWithBackoff(fn, maxRetries = 3, baseDelay = 1000) {
    for (let attempt = 0; attempt < maxRetries; attempt++) {
      try {
        return await fn();
      } catch (error) {
        if (attempt === maxRetries - 1) throw error;
        const handling = this.handlePaymentError(error, {});
        if (!handling.retryable) throw error;
        const delay = baseDelay * Math.pow(2, attempt);
        await new Promise(resolve => setTimeout(resolve, delay));
      }
    }
  }
}

// config/orange-money.production.js
import { Simiz } from '@simiz/sdk';
const validateEnvironment = () => {
  const required = [
    'SIMIZ_API_KEY',
    'SIMIZ_SECRET_KEY',
    'SIMIZ_WEBHOOK_SECRET',
    'DATABASE_URL'
  ];
  const missing = required.filter(key => !process.env[key]);
  if (missing.length > 0) {
    throw new Error(Variables manquantes: ${missing.join(', ')});
  }
  if (process.env.NODE_ENV !== 'production') {
    console.warn('  Attention: environnement != production');
  }
};
validateEnvironment();
export const paymentProvider = new Simiz({
  apiKey: process.env.SIMIZ_API_KEY,
  secretKey: process.env.SIMIZ_SECRET_KEY,
  environment: 'production',
  webhookSecret: process.env.SIMIZ_WEBHOOK_SECRET,
  timeout: 30000,
  maxRetries: 3
});

// middleware/webhook-security.js
import crypto from 'crypto';
export function webhookSecurity(req, res, next) {
  const signature = req.headers['x-simiz-signature'];
  const timestamp = req.headers['x-simiz-timestamp'];
  const payload = req.body;
  // Vérifier que le timestamp est récent (anti-replay)
  const now = Math.floor(Date.now() / 1000);
  if (Math.abs(now - parseInt(timestamp)) > 300) {
    return res.status(401).json({ error: 'Timestamp too old' });
  }
  // Vérifier la signature
  const expectedSignature = crypto
    .createHmac('sha256', process.env.SIMIZ_WEBHOOK_SECRET)
    .update(${timestamp}.${payload})
    .digest('hex');
  if (!crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(sha256=${expectedSignature})
  )) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  // Vérifier l'IP (optionnel, si IP fixe)
  const allowedIPs = process.env.WEBHOOK_ALLOWED_IPS?.split(',') || [];
  if (allowedIPs.length > 0 && !allowedIPs.includes(req.ip)) {
    return res.status(403).json({ error: 'IP not allowed' });
  }
  next();
}