確認

DETECTED → CONFIRMED → FINALIZED
   ↓           ↓
REVERTED    REVERTED

app.post('/webhooks/stableops', async (req, res) => {
  const event = req.body

  if (event.type === 'payment.reverted') {
    const orderId = event.data.payment_order_id

    // 1. 沖銷已經做的履約
    await reverseOrderFulfillment(orderId)

    // 2. 通知客戶
    await sendEmail(customer, '支付失敗，請重試')

    // 3. 更新資料庫
    await db.orders.update({
      id: orderId,
      status: 'payment_failed',
      reason: event.data.reason,
    })

    // 4. 可選：建立新訂單
    const newOrder = await stableops.paymentOrders.create({
      merchantOrderId: `${orderId}_retry`,
      amount: originalAmount,
      expiresAt: new Date(Date.now() + 30 * 60 * 1000).toISOString(),
      // ...
    })
  }

  res.sendStatus(200)
})

// 一筆支付的事件時間線
12:00:00 - payment.detected
12:00:12 - payment.confirmed
12:13:00 - payment.finalized

const checkPaymentStatus = async (orderId: string) => {
  const order = await stableops.paymentOrders.retrieve(orderId)

  switch (order.status) {
    case 'detected':
      console.log('已收到，等待確認...')
      break
    case 'confirmed':
      console.log('已確認，等待 finality...')
      break
    case 'finalized':
      console.log('已 finalize，可安全履約')
      await fulfillOrder(order)
      break
    case 'reverted':
      console.log('已回滾，處理失敗流程')
      await handleRevert(order)
      break
  }
}

// 每 5 秒輪詢
const interval = setInterval(() => checkPaymentStatus(orderId), 5000)

重組前：
Block 100 → Block 101 → Block 102 （你的交易）
                     ↘ Block 102' （競爭鏈）

重組後：
Block 100 → Block 101 → Block 102' → Block 103'
                     ✗ Block 102 （被孤立）

// ✅ 正確：等 finality
app.post('/webhooks/stableops', async (req, res) => {
  const event = req.body

  if (event.type === 'payment.finalized') {
    await fulfillOrder(event.data.payment_order_id)
  }

  res.sendStatus(200)
})

// ❌ 錯誤：在 detected 就履約
app.post('/webhooks/stableops', async (req, res) => {
  const event = req.body

  if (event.type === 'payment.detected') {
    await fulfillOrder(event.data.payment_order_id) // 危險！
  }

  res.sendStatus(200)
})

const handlePaymentWebhook = async (event: WebhookEvent) => {
  switch (event.type) {
    case 'payment.detected':
      await updateUI('已收到，確認中…')
      break
    case 'payment.confirmed':
      await updateUI('已確認，最終化中…')
      break
    case 'payment.finalized':
      await fulfillOrder(event.data.payment_order_id)
      break
    case 'payment.reverted':
      await handleRevert(event.data.payment_order_id)
      break
  }
}

const PaymentStatus = ({ order }) => {
  switch (order.status) {
    case 'detected':
      return (
        <div>
          <Spinner />
          <p>已收到，確認中…</p>
        </div>
      )
    case 'confirmed':
      return (
        <div>
          <Spinner />
          <p>已確認，最終化中…</p>
        </div>
      )
    case 'finalized':
      return (
        <div>
          <CheckIcon />
          <p>支付完成！訂單正在處理。</p>
        </div>
      )
  }
}

app.post('/webhooks/stableops', async (req, res) => {
  const event = req.body

  await db.webhookLogs.create({
    type: event.type,
    orderId: event.data.payment_order_id,
    fromStatus: event.data.from_status,
    toStatus: event.data.to_status,
    timestamp: new Date(),
  })

  // 業務處理...

  res.sendStatus(200)
})

describe('支付重組處理', () => {
  it('應在重組時沖銷履約', async () => {
    // 1. 建立訂單
    const order = await createOrder()

    // 2. 模擬 detected
    await handleWebhook({ type: 'payment.detected', data: order })

    // 3. 模擬 confirmed
    await handleWebhook({ type: 'payment.confirmed', data: order })

    // 4. 模擬回滾
    await handleWebhook({ type: 'payment.reverted', data: order })

    // 5. 驗證已沖銷
    const dbOrder = await db.orders.findOne({ id: order.id })
    expect(dbOrder.status).toBe('payment_failed')
  })
})

app.post('/webhooks/stableops', async (req, res) => {
  const event = req.body
  const orderId = event.data.payment_order_id

  switch (event.type) {
    case 'payment.confirmed':
      // 臨時權益
      await grantTrialAccess(orderId)
      break

    case 'payment.finalized':
      // 完整權益
      await grantFullAccess(orderId)
      break

    case 'payment.reverted':
      // 全部撤銷
      await revokeAccess(orderId)
      break
  }

  res.sendStatus(200)
})

const shouldFulfill = (order: PaymentOrder): boolean => {
  const amount = parseFloat(order.amount)

  if (amount < 100) {
    // 小額：confirmed 即可
    return order.status === 'confirmed' || order.status === 'finalized'
  } else {
    // 大額：等 finalized
    return order.status === 'finalized'
  }
}