Payment Gateways

const response = await fetch('https://api.gatepass.app/api/orders/initialize', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    eventId: 'clx123abc',
    tierId: 'tier_vip_001',
    quantity: 2,
    paymentMethod: 'FIAT',
    gateway: 'flutterwave',  // or 'paystack'
    customerEmail: '[email protected]',
    customerName: 'John Doe'
  })
});

const data = await response.json();
console.log(data.orderId);      // Order ID for tracking
console.log(data.checkoutUrl);  // Redirect URL (Flutterwave)
console.log(data.reference);    // Payment reference (Paystack)

<script src="https://js.paystack.co/v2/inline.js"></script>

async function initiateFlutterwavePayment(orderData) {
  // Step 1: Initialize order on backend
  const response = await fetch('https://api.gatepass.app/api/orders/initialize', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      eventId: orderData.eventId,
      tierId: orderData.tierId,
      quantity: orderData.quantity,
      paymentMethod: 'FIAT',
      gateway: 'flutterwave',
      customerEmail: orderData.email,
      customerName: orderData.name
    })
  });

  const { ok, orderId, checkoutUrl } = await response.json();

  if (ok && checkoutUrl) {
    // Step 2: Redirect to Flutterwave hosted page
    window.location.href = checkoutUrl;
  }
}

// On payment success page
const urlParams = new URLSearchParams(window.location.search);
const transactionId = urlParams.get('transaction_id');
const txRef = urlParams.get('tx_ref');

if (transactionId && txRef) {
  const response = await fetch(
    `/api/orders/verify-flutterwave?transaction_id=${transactionId}&tx_ref=${txRef}`,
    {
      headers: {
        'Authorization': `Bearer ${accessToken}`
      }
    }
  );

  const { ok, status } = await response.json();
  
  if (ok && status === 'COMPLETED') {
    console.log('Payment verified successfully');
    // Show success message and tickets
  }
}

// From: ~/workspace/source/src/packages/server/src/routes/webhooks.ts:79-102

router.post('/paystack', async (req, res) => {
  const secret = process.env.PAYSTACK_SECRET_KEY;
  const signature = req.headers['x-paystack-signature'];

  // Verify signature
  const hash = crypto
    .createHmac('sha512', secret)
    .update(JSON.stringify(req.body))
    .digest('hex');

  if (hash !== signature) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const body = req.body;
  
  if (body.event === 'charge.success') {
    const order = await prisma.order.findFirst({
      where: { paystackReference: body.data.reference }
    });

    if (order) {
      // Update order status to COMPLETED
      // Mint NFT tickets if wallet connected
      await finalizeOrder(order.id, String(body.data.id));
    }
  }

  res.json({ ok: true });
});

// From: ~/workspace/source/src/packages/server/src/routes/webhooks.ts:104-123

router.post('/flutterwave', async (req, res) => {
  const signature = req.headers['verif-hash'];
  const secretHash = process.env.FLW_SECRET_HASH;

  // Verify signature
  if (signature !== secretHash) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const { event, data } = req.body;

  if (event === 'charge.completed' && data.status === 'successful') {
    const order = await prisma.order.findFirst({
      where: { flutterwaveReference: data.tx_ref }
    });

    if (order) {
      // Update order and mint tickets
      await finalizeOrder(order.id, String(data.id));
    }
  }

  res.json({ ok: true });
});

// From: ~/workspace/source/src/packages/server/src/routes/webhooks.ts:13-77

async function finalizeOrder(orderId: string, txId: string) {
  const order = await prisma.order.findUnique({
    where: { id: orderId },
    include: { event: true }
  });

  if (!order || order.paymentStatus === 'COMPLETED') return;

  // Update payment status
  await prisma.order.update({
    where: { id: order.id },
    data: { 
      paymentStatus: 'COMPLETED',
      paymentTxId: txId,
      updatedAt: new Date()
    }
  });

  // Mint NFT tickets if wallet connected
  const user = await prisma.user.findUnique({ where: { id: order.userId } });
  const walletAddress = user?.walletAddress;

  if (walletAddress && order.event.contractAddress) {
    try {
      const { txHash, tokenIds } = await mintTicketsFor(
        order.event.contractAddress,
        abi,
        walletAddress,
        order.quantity
      );

      // Save blockchain transaction
      await prisma.order.update({
        where: { id: order.id },
        data: { blockchainTxHash: txHash }
      });

      // Create ticket records
      for (const tokenId of tokenIds) {
        await prisma.ticket.create({
          data: {
            tokenId,
            contractAddress: order.event.contractAddress,
            chainId: order.event.chainId,
            txHash,
            eventId: order.eventId,
            orderId: order.id
          }
        });
      }
    } catch (err) {
      console.error('Blockchain minting failed:', err);
    }
  }

  // Send notification
  await prisma.notification.create({
    data: {
      userId: order.userId,
      title: 'Ticket Purchase Successful',
      message: `You successfully purchased ${order.quantity} ticket(s).`,
      type: 'SUCCESS'
    }
  });
}