Build a 0Gate payment flow that survives real users, retries, and settlement delays.

type PaymentAttemptStatus =
  | 'pending_session'
  | 'requires_action'
  | 'processing'
  | 'fulfilled'
  | 'failed'
  | 'expired'
  | 'cancelled';

type PaymentAttempt = {
  id: string;
  gateSessionId: string | null;
  userReference: string;
  status: PaymentAttemptStatus;
  fulfilledAt: Date | null;
};

async function startPaymentFlow(input: PaymentInput) {
  const attempt = await paymentAttempts.create({
    amount: input.amount,
    currency: input.currency,
    userReference: input.orderId,
    status: 'pending_session',
  });

  const session = await gateSessions.createForAttempt({
    attempt,
    flow: input.flow,
    returnUrl: input.returnUrl,
    cancelUrl: input.cancelUrl,
    idempotencyKey: `payment-attempt:${attempt.id}`,
  });

  await paymentAttempts.attachGateSession(attempt.id, {
    gateSessionId: session.id,
    status: 'requires_action',
  });

  return {
    attemptId: attempt.id,
    clientSecret: session.clientSecret,
  };
}

async function handleGateEvent(rawBody: string, headers: Headers) {
  const event = verifyGateWebhook(rawBody, headers);

  const inserted = await webhookEvents.insertOnce({
    id: event.id,
    type: event.type,
    gateSessionId: event.data.id,
  });

  if (!inserted) return { received: true };

  await paymentEventQueue.enqueue({
    eventId: event.id,
    gateSessionId: event.data.id,
    type: event.type,
  });

  return { received: true };
}

async function reconcilePaymentAttempt(attempt: PaymentAttempt) {
  const session = await gateSessions.retrieve(attempt.gateSessionId);

  if (session.status === 'completed') {
    await fulfillOnce({
      attemptId: attempt.id,
      gateSessionId: session.id,
      source: 'reconciliation',
    });
  }

  if (['failed', 'expired', 'cancelled'].includes(session.status)) {
    await paymentAttempts.close(attempt.id, session.status);
  }
}