Comprehensive comparison for Payment Processing technology in Software Development applications

const express = require('express');
const bitpay = require('bitpay-rest-client').default;
const crypto = require('crypto');
const app = express();

app.use(express.json());

const BITPAY_ENV = process.env.BITPAY_ENV || 'test';
const BITPAY_PRIVATE_KEY = process.env.BITPAY_PRIVATE_KEY;
const BITPAY_TOKEN = process.env.BITPAY_TOKEN;
const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET;

let bitpayClient;

async function initializeBitPay() {
  try {
    bitpayClient = new bitpay(BITPAY_PRIVATE_KEY, {
      environment: BITPAY_ENV,
      token: BITPAY_TOKEN
    });
    console.log('BitPay client initialized successfully');
  } catch (error) {
    console.error('Failed to initialize BitPay client:', error.message);
    throw error;
  }
}

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

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

    const invoice = {
      price: amount,
      currency: currency,
      orderId: orderId,
      notificationURL: `${process.env.BASE_URL}/api/bitpay-webhook`,
      redirectURL: `${process.env.BASE_URL}/payment-success`,
      buyer: {
        email: buyerEmail
      },
      extendedNotifications: true,
      transactionSpeed: 'medium'
    };

    const createdInvoice = await bitpayClient.create_invoice(invoice);

    res.json({
      success: true,
      invoiceId: createdInvoice.id,
      invoiceUrl: createdInvoice.url,
      status: createdInvoice.status
    });
  } catch (error) {
    console.error('Error creating invoice:', error.message);
    res.status(500).json({ error: 'Failed to create invoice', details: error.message });
  }
});

app.post('/api/bitpay-webhook', async (req, res) => {
  try {
    const signature = req.headers['x-signature'];
    const payload = JSON.stringify(req.body);

    const expectedSignature = crypto
      .createHmac('sha256', WEBHOOK_SECRET)
      .update(payload)
      .digest('hex');

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

    const { event, data } = req.body;

    if (event === 'invoice_confirmed' || event === 'invoice_completed') {
      console.log(`Payment confirmed for order: ${data.orderId}`);
      await processPaymentConfirmation(data.orderId, data.id);
    } else if (event === 'invoice_expired') {
      console.log(`Invoice expired for order: ${data.orderId}`);
      await handleExpiredInvoice(data.orderId);
    } else if (event === 'invoice_failed_to_confirm') {
      console.log(`Payment failed for order: ${data.orderId}`);
      await handleFailedPayment(data.orderId);
    }

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

async function processPaymentConfirmation(orderId, invoiceId) {
  console.log(`Processing payment confirmation for order ${orderId}`);
}

async function handleExpiredInvoice(orderId) {
  console.log(`Handling expired invoice for order ${orderId}`);
}

async function handleFailedPayment(orderId) {
  console.log(`Handling failed payment for order ${orderId}`);
}

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