Comprehensive comparison for Payment Processing technology in Software Development applications

const express = require('express');
const BitPaySDK = require('bitpay-sdk');
const crypto = require('crypto');

const app = express();
app.use(express.json());

// Initialize BitPay client with environment variables
const bitpayClient = new BitPaySDK.Client(
  process.env.BITPAY_PRIVATE_KEY,
  {
    environment: process.env.BITPAY_ENV || 'test',
    tokens: {
      merchant: process.env.BITPAY_MERCHANT_TOKEN
    }
  }
);

// Create invoice endpoint
app.post('/api/payments/create-invoice', async (req, res) => {
  try {
    const { orderId, amount, currency, buyerEmail, redirectUrl } = req.body;

    // Validate required fields
    if (!orderId || !amount || !currency) {
      return res.status(400).json({
        error: 'Missing required fields: orderId, amount, currency'
      });
    }

    // Create BitPay invoice
    const invoice = await bitpayClient.createInvoice({
      price: amount,
      currency: currency,
      orderId: orderId,
      notificationEmail: buyerEmail,
      notificationURL: `${process.env.BASE_URL}/api/payments/ipn`,
      redirectURL: redirectUrl || `${process.env.BASE_URL}/order/confirmation`,
      extendedNotifications: true,
      transactionSpeed: 'medium',
      itemDesc: `Order #${orderId}`,
      physical: false
    });

    res.status(201).json({
      success: true,
      invoiceId: invoice.id,
      invoiceUrl: invoice.url,
      status: invoice.status,
      expirationTime: invoice.expirationTime
    });

  } catch (error) {
    console.error('BitPay invoice creation error:', error);
    res.status(500).json({
      error: 'Failed to create payment invoice',
      message: error.message
    });
  }
});

// IPN (Instant Payment Notification) webhook handler
app.post('/api/payments/ipn', async (req, res) => {
  try {
    const ipnData = req.body;

    // Verify IPN authenticity
    const signature = req.headers['x-signature'];
    if (!verifyIPNSignature(ipnData, signature)) {
      return res.status(401).json({ error: 'Invalid IPN signature' });
    }

    // Get full invoice details from BitPay
    const invoice = await bitpayClient.getInvoice(ipnData.id);

    // Process based on invoice status
    switch (invoice.status) {
      case 'paid':
        await handlePaidInvoice(invoice);
        break;
      case 'confirmed':
        await handleConfirmedInvoice(invoice);
        break;
      case 'complete':
        await handleCompleteInvoice(invoice);
        break;
      case 'expired':
      case 'invalid':
        await handleFailedInvoice(invoice);
        break;
      default:
        console.log(`Unhandled invoice status: ${invoice.status}`);
    }

    res.status(200).send('IPN processed');

  } catch (error) {
    console.error('IPN processing error:', error);
    res.status(500).json({ error: 'IPN processing failed' });
  }
});

// Verify IPN signature for security
function verifyIPNSignature(data, signature) {
  const payload = JSON.stringify(data);
  const expectedSignature = crypto
    .createHmac('sha256', process.env.BITPAY_MERCHANT_TOKEN)
    .update(payload)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

// Handle different payment states
async function handlePaidInvoice(invoice) {
  console.log(`Invoice ${invoice.id} paid, awaiting confirmations`);
  // Update order status to 'payment_pending'
}

async function handleConfirmedInvoice(invoice) {
  console.log(`Invoice ${invoice.id} confirmed`);
  // Update order status to 'payment_confirmed'
}

async function handleCompleteInvoice(invoice) {
  console.log(`Invoice ${invoice.id} complete`);
  // Fulfill order, update status to 'processing'
}

async function handleFailedInvoice(invoice) {
  console.log(`Invoice ${invoice.id} failed: ${invoice.status}`);
  // Update order status to 'payment_failed'
}

// Get invoice status endpoint
app.get('/api/payments/invoice/:invoiceId', async (req, res) => {
  try {
    const invoice = await bitpayClient.getInvoice(req.params.invoiceId);
    res.json({
      id: invoice.id,
      status: invoice.status,
      price: invoice.price,
      currency: invoice.currency,
      orderId: invoice.orderId,
      expirationTime: invoice.expirationTime
    });
  } catch (error) {
    res.status(404).json({ error: 'Invoice not found' });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Payment server running on port ${PORT}`);
});