Use Cases

// DeFi protocol payout using Gateway contract
const gateway = new Contract(gatewayAddress, gatewayAbi, signer);

const payoutOrder = await gateway.createOrder(
  usdtAddress,
  parseUnits('150.00', 6),
  rate,
  ZeroAddress,
  0,
  refundAddress,
  messageHash
);

// Automated payroll system
const payrollOrder = await paycrest.createOrder({
  amount: '2500.00',
  token: 'USDC',
  network: 'polygon',
  recipient: {
    institution: 'KCB',
    accountIdentifier: '9876543210',
    accountName: 'Sarah Johnson',
    currency: 'KES'
  },
  reference: 'payroll-2024-01-sarah-johnson'
});

// Express.js server with Paycrest integration
const express = require('express');
const crypto = require('crypto');
const app = express();

// Use raw body for this route only — do not use express.json() before webhook verification
function verifyPaycrestSignature(rawBody, signature, secret) {
  const sig = (signature && String(signature).trim().toLowerCase()) || '';
  const key = String(secret || '').trim();
  if (!sig || !key) return false;
  const bodyBuf = Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(rawBody, 'utf8');
  const computed = crypto.createHmac('sha256', key).update(bodyBuf).digest('hex').toLowerCase();
  if (computed.length !== sig.length) return false;
  try {
    return crypto.timingSafeEqual(Buffer.from(computed, 'utf8'), Buffer.from(sig, 'utf8'));
  } catch {
    return false;
  }
}

// Webhook endpoint for order updates (raw JSON bytes for HMAC)
app.post('/webhooks/paycrest', express.raw({ type: 'application/json' }), async (req, res) => {
  const signature = req.get('X-Paycrest-Signature');

  if (!verifyPaycrestSignature(req.body, signature, process.env.WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }

  const { event, orderId, status, data } = JSON.parse(req.body);
  
  try {
    // Update order status in database
    await updateOrderStatus(orderId, status);
    
    // Send notification to user based on status
    if (status === 'settled') {
      await notifyUserSuccess(orderId, data);
    } else if (status === 'expired') {
      await notifyUserExpired(orderId);
    }
    
    res.status(200).send('Webhook processed');
  } catch (error) {
    console.error('Webhook processing error:', error);
    res.status(500).send('Internal server error');
  }
});

// API endpoint to create payment order
app.post('/api/payments', async (req, res) => {
  try {
    const { amount, recipient } = req.body;
    
    const order = await paycrest.createOrder({
      amount: amount.toString(),
      token: 'USDT',
      network: 'base',
      recipient: recipient,
      reference: `payment-${Date.now()}`
    });
    
    res.json({
      success: true,
      orderId: order.id,
      receiveAddress: order.receiveAddress,
      validUntil: order.validUntil
    });
  } catch (error) {
    res.status(400).json({
      success: false,
      error: error.message
    });
  }
});

// React Native payment flow
// Direct API integration

// Direct API integration using fetch
const API_BASE_URL = 'https://api.paycrest.io/v2';
const API_KEY = 'YOUR_API_KEY';

const initiatePayment = async (amount, recipient) => {
  try {
    const response = await fetch(`${API_BASE_URL}/orders`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'API-Key': API_KEY
  },
  body: JSON.stringify({
    amount: amount.toString(),
    token: 'USDT',
    network: 'base',
    recipient: recipient,
    reference: `mobile-payment-${Date.now()}`
  })
});

if (!response.ok) {
  throw new Error(`API request failed: ${response.statusText}`);
}

const order = await response.json();
    
    // Show payment instructions to user
    showPaymentInstructions(order.receiveAddress, order.validUntil);
    
    // Start polling for status updates
    pollOrderStatus(order.id);
    
    return order;
  } catch (error) {
    console.error('Payment initiation failed:', error);
    throw error;
  }
};

const pollOrderStatus = async (orderId) => {
  const checkStatus = async () => {
    try {
      const response = await fetch(`${API_BASE_URL}/orders/${orderId}`, {
  headers: {
    'API-Key': API_KEY
  }
});

if (!response.ok) {
  throw new Error(`Status check failed: ${response.statusText}`);
}

const orderData = await response.json();
const status = orderData.status;
      
      if (status === 'settled') {
        showSuccessMessage('Payment completed successfully!');
        stopPolling();
      } else if (status === 'expired') {
        showErrorMessage('Payment expired. Please try again.');
        stopPolling();
      }
    } catch (error) {
      console.error('Status check failed:', error);
    }
  };
  
  // Poll every 10 seconds
  const interval = setInterval(checkStatus, 10000);
  
  // Stop polling after 5 minutes
  setTimeout(() => {
    clearInterval(interval);
  }, 300000);
};