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());

// BitPay Configuration
const BITPAY_ENV = process.env.BITPAY_ENV || 'test';
const BITPAY_PRIVATE_KEY = process.env.BITPAY_PRIVATE_KEY;
const BITPAY_TOKEN = process.env.BITPAY_TOKEN;

let bitpayClient;

// Initialize BitPay client
async function initBitPay() {
  try {
    const privateKey = new BitPaySDK.PrivateKey(BITPAY_PRIVATE_KEY);
    bitpayClient = new BitPaySDK.Client(
      BITPAY_ENV,
      privateKey,
      new BitPaySDK.Tokens(BITPAY_TOKEN)
    );
    console.log('BitPay client initialized successfully');
  } catch (error) {
    console.error('Failed to initialize BitPay client:', error.message);
    throw error;
  }
}

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

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

    // Create invoice object
    const invoice = new BitPaySDK.Invoice(amount, currency);
    invoice.setOrderId(orderId);
    invoice.setFullNotifications(true);
    invoice.setExtendedNotifications(true);
    invoice.setTransactionSpeed('medium');
    invoice.setNotificationURL(notificationUrl || `${process.env.BASE_URL}/api/payments/webhook`);
    invoice.setRedirectURL(redirectUrl || `${process.env.BASE_URL}/payment/success`);
    
    if (buyerEmail) {
      invoice.setBuyerEmail(buyerEmail);
    }

    // Create invoice via BitPay API
    const createdInvoice = await bitpayClient.createInvoice(invoice);

    // Store invoice details in database (pseudo-code)
    // await database.invoices.create({
    //   invoiceId: createdInvoice.getId(),
    //   orderId: orderId,
    //   amount: amount,
    //   currency: currency,
    //   status: createdInvoice.getStatus(),
    //   createdAt: new Date()
    // });

    res.status(201).json({
      success: true,
      invoice: {
        id: createdInvoice.getId(),
        url: createdInvoice.getUrl(),
        status: createdInvoice.getStatus(),
        expirationTime: createdInvoice.getExpirationTime()
      }
    });
  } catch (error) {
    console.error('Error creating invoice:', error.message);
    res.status(500).json({
      success: false,
      error: 'Failed to create invoice',
      details: error.message
    });
  }
});

// Webhook endpoint for BitPay IPN notifications
app.post('/api/payments/webhook', async (req, res) => {
  try {
    const ipnData = req.body;
    
    // Verify webhook authenticity
    const receivedSignature = req.headers['x-signature'];
    const payload = JSON.stringify(ipnData);
    const expectedSignature = crypto
      .createHmac('sha256', BITPAY_PRIVATE_KEY)
      .update(payload)
      .digest('hex');

    if (receivedSignature !== expectedSignature) {
      console.warn('Invalid webhook signature detected');
      return res.status(401).json({ error: 'Invalid signature' });
    }

    const invoiceId = ipnData.id;
    const status = ipnData.status;

    // Retrieve full invoice details
    const invoice = await bitpayClient.getInvoice(invoiceId);

    // Handle different payment statuses
    switch (status) {
      case 'paid':
        console.log(`Invoice ${invoiceId} has been paid`);
        // await database.invoices.update(invoiceId, { status: 'paid' });
        break;
      case 'confirmed':
        console.log(`Invoice ${invoiceId} payment confirmed`);
        // await database.invoices.update(invoiceId, { status: 'confirmed' });
        // await fulfillOrder(invoice.getOrderId());
        break;
      case 'complete':
        console.log(`Invoice ${invoiceId} is complete`);
        // await database.invoices.update(invoiceId, { status: 'complete' });
        break;
      case 'expired':
        console.log(`Invoice ${invoiceId} has expired`);
        // await database.invoices.update(invoiceId, { status: 'expired' });
        break;
      case 'invalid':
        console.log(`Invoice ${invoiceId} is invalid`);
        // await database.invoices.update(invoiceId, { status: 'invalid' });
        break;
      default:
        console.log(`Invoice ${invoiceId} status: ${status}`);
    }

    res.status(200).json({ success: true });
  } catch (error) {
    console.error('Error processing webhook:', error.message);
    res.status(500).json({ error: 'Webhook processing failed' });
  }
});

// Get invoice status endpoint
app.get('/api/payments/invoice/:invoiceId', async (req, res) => {
  try {
    const { invoiceId } = req.params;
    const invoice = await bitpayClient.getInvoice(invoiceId);

    res.status(200).json({
      success: true,
      invoice: {
        id: invoice.getId(),
        status: invoice.getStatus(),
        price: invoice.getPrice(),
        currency: invoice.getCurrency(),
        orderId: invoice.getOrderId(),
        expirationTime: invoice.getExpirationTime()
      }
    });
  } catch (error) {
    console.error('Error retrieving invoice:', error.message);
    res.status(404).json({
      success: false,
      error: 'Invoice not found'
    });
  }
});

// Initialize and start server
initBitPay().then(() => {
  const PORT = process.env.PORT || 3000;
  app.listen(PORT, () => {
    console.log(`Payment processing server running on port ${PORT}`);
  });
}).catch(error => {
  console.error('Failed to start server:', error);
  process.exit(1);
});