1
async function createOrderSafely(country, currency, amount, preferredMethod) {
2
  // 1. Obtener métodos disponibles
3
  const methods = await getPaymentMethods(country, currency);
4
  console.log('Métodos disponibles:', methods.map(m => m.method));
5
  
6
  // 2. Verificar si el método preferido está disponible
7
  const methodAvailable = methods.some(m => m.method === preferredMethod);
8
  
9
  if (!methodAvailable) {
10
    console.error(`Método ${preferredMethod} no disponible`);
11
    console.log('Usar uno de:', methods.map(m => m.method));
12
    throw new Error('Método de pago no soportado');
13
  }
14
  
15
  // 3. Crear orden
16
  return await createPayinOrder(token, orgId, merchantId, {
17
    originCurrencySymbol: currency,
18
    destinationCurrencySymbol: currency,
19
    amountIn: amount,
20
    paymentMethods: [{ method: preferredMethod }]
21
    // ... otros campos
22
  });
23
}

1
function validateDocument(country, documentType, documentNumber) {
2
  const validators = {
3
    'CO': {
4
      'CC': /^\d{6,10}$/,  // ID colombiano: 6-10 dígitos
5
      'CE': /^\d{6,7}$/,   // ID extranjero: 6-7 dígitos
6
      'NIT': /^\d{9,10}$/  // ID fiscal: 9-10 dígitos
7
    },
8
    'BR': {
9
      'CPF': /^\d{11}$/,   // Individual: 11 dígitos
10
      'CNPJ': /^\d{14}$/   // Empresa: 14 dígitos
11
    },
12
    'MX': {
13
      'RFC': /^[A-Z]{3,4}\d{6}[A-Z0-9]{3}$/  // Formato ID fiscal
14
    },
15
    'CL': {
16
      'RUT': /^\d{7,8}-[\dkK]$/  // Formato: 12345678-9
17
    }
18
  };
19
  
20
  const regex = validators[country]?.[documentType];
21
  if (!regex) {
22
    console.warn(`No hay validador para ${country} ${documentType}`);
23
    return true;  // Permitir si no hay validador
24
  }
25
  
26
  const isValid = regex.test(documentNumber);
27
  if (!isValid) {
28
    console.error(`Formato ${documentType} inválido: ${documentNumber}`);
29
    console.log(`Formato esperado: ${regex}`);
30
  }
31
  
32
  return isValid;
33
}
34
35
// Uso
36
const isValid = validateDocument('CO', 'CC', '1234567890');
37
if (!isValid) {
38
  throw new Error('Número de documento inválido');
39
}

1
async function createOrderIdempotent(internalOrderId, orderData) {
2
  // Usar tu ID de orden interno como externalId
3
  const externalId = `order-${internalOrderId}`;
4
  
5
  try {
6
    const order = await createPayinOrder(token, orgId, merchantId, {
7
      ...orderData,
8
      externalId: externalId  // Mismo externalId = misma orden
9
    });
10
    
11
    console.log('Orden creada:', order.id);
12
    return order;
13
    
14
  } catch (error) {
15
    if (error.response?.status === 409) {
16
      // Orden ya existe, recuperarla
17
      console.log('Orden ya existe, recuperando...');
18
      const existingOrder = await getOrderByExternalId(externalId);
19
      return existingOrder;
20
    }
21
    throw error;
22
  }
23
}
24
25
// Seguro para reintentar
26
const order = await createOrderIdempotent('12345', orderData);

1
async function checkOrderStatus(orderId) {
2
  const order = await getOrderStatus(token, orgId, merchantId, orderId);
3
  
4
  console.log('Estado:', order.status);
5
  console.log('Creada:', order.createdAt);
6
  console.log('Fecha límite:', order.dueDate);
7
  
8
  if (order.status === 'PENDING') {
9
    const createdTime = new Date(order.createdAt);
10
    const now = new Date();
11
    const minutesElapsed = (now - createdTime) / 1000 / 60;
12
    
13
    console.log(`Orden pendiente por ${minutesElapsed.toFixed(0)} minutos`);
14
    
15
    if (minutesElapsed > 30) {
16
      console.warn('Orden pendiente por demasiado tiempo - cliente puede no haber pagado');
17
      // Considerar cancelar o expirar la orden
18
    }
19
  }
20
  
21
  return order;
22
}

1
const crypto = require('crypto');
2
3
function verifyWebhookSignature(payload, signature, secret) {
4
  // payload debe ser el body crudo (string o Buffer)
5
  // NO JSON parseado
6
  
7
  const expectedSignature = crypto
8
    .createHmac('sha256', secret)
9
    .update(payload)
10
    .digest('hex');
11
  
12
  const isValid = signature === expectedSignature;
13
  
14
  if (!isValid) {
15
    console.error('Firma no coincide');
16
    console.error('Recibida:', signature);
17
    console.error('Esperada:', expectedSignature);
18
  }
19
  
20
  return isValid;
21
}
22
23
// Ejemplo Express - DEBE usar body crudo
24
app.post('/webhooks/koywe', 
25
  express.raw({ type: 'application/json' }),  // Importante: raw, no json
26
  (req, res) => {
27
    const signature = req.headers['koywe-signature'];
28
    const secret = process.env.KOYWE_WEBHOOK_SECRET;
29
    
30
    // req.body es Buffer al usar express.raw
31
    if (!verifyWebhookSignature(req.body, signature, secret)) {
32
      return res.status(401).send('Firma inválida');
33
    }
34
    
35
    // Ahora parsear
36
    const event = JSON.parse(req.body);
37
    console.log('Evento webhook válido:', event.type);
38
    
39
    // Procesar evento...
40
    
41
    res.status(200).send('OK');
42
  }
43
);