payment-kit 1.22.31 → 1.23.0

package/api/src/queues/credit-consume.ts

@@ -20,6 +20,7 @@ import { getDaysUntilCancel, getDueUnit, getMeterPriceIdsFromSubscription } from
 import { events } from '../libs/event';
 import { handlePastDueSubscriptionRecovery } from './payment';
 import { checkAndTriggerAutoRecharge } from './auto-recharge';
+import { addTokenTransferJob } from './token-transfer';
 
 type CreditConsumptionJob = {
   meterEventId: string;
@@ -329,11 +330,30 @@ async function processGrantConsumption(
     creditGrantId: creditGrant.id,
     consumeAmount,
   });
+
   const result = await creditGrant.consumeCredit(consumeAmount, {
     subscription_id: context.subscription?.id,
     meter_event_id: context.meterEvent.id,
   });
-  await createCreditTransaction(context, creditGrant, consumeAmount, result);
+
+  const transactionId = await createCreditTransaction(context, creditGrant, consumeAmount, result);
+
+  if (CreditGrant.hasOnchainToken(creditGrant)) {
+    addTokenTransferJob({
+      creditTransactionId: transactionId,
+      creditGrantId: creditGrant.id,
+      customerDid: context.customer.did,
+      amount: consumeAmount,
+      paymentCurrencyId: context.meter.paymentCurrency.id,
+      meterEventId: context.meterEvent.id,
+      subscriptionId: context.meterEvent.getSubscriptionId(),
+    }).catch((error) => {
+      logger.error('Failed to add token transfer job', {
+        creditTransactionId: transactionId,
+        error,
+      });
+    });
+  }
 }
 
 async function createCreditTransaction(
@@ -341,7 +361,7 @@ async function createCreditTransaction(
   creditGrant: CreditGrant,
   consumeAmount: string,
   consumeResult: any
-): Promise<void> {
+): Promise<string> {
   const meterEventId = context.meterEvent.id;
   const creditGrantId = creditGrant.id;
 
@@ -360,7 +380,7 @@ async function createCreditTransaction(
       existingTransactionId: existingTransaction.id,
     });
     context.transactions.push(existingTransaction.id);
-    return;
+    return existingTransaction.id;
   }
 
   logger.debug('start to create credit transaction', {
@@ -392,6 +412,8 @@ async function createCreditTransaction(
       remaining_balance: consumeResult.remaining,
       source: context.meterEvent.id,
       description,
+      // 如果是链上 grant，会在后续 transfer 成功之后更新为 completed
+      transfer_status: CreditGrant.hasOnchainToken(creditGrant) ? 'pending' : 'completed',
       metadata: {
         ...(context.meterEvent.metadata || {}),
         meter_event_id: context.meterEvent.id,
@@ -407,6 +429,8 @@ async function createCreditTransaction(
       meterEventId: context.meterEvent.id,
     });
     context.transactions.push(transaction.id);
+
+    return transaction.id;
   } catch (error: any) {
     // 处理唯一约束违反错误
     if (error.name === 'SequelizeUniqueConstraintError' || error.message.includes('UNIQUE constraint failed')) {
@@ -426,8 +450,8 @@ async function createCreditTransaction(
 
       if (duplicateTransaction) {
         context.transactions.push(duplicateTransaction.id);
+        return duplicateTransaction.id;
       }
-      return;
     }
 
     // 其他错误重新抛出
@@ -486,6 +510,7 @@ export async function handleCreditConsumption(job: CreditConsumptionJob) {
 
     // Consume available credits (handles existing transactions internally)
     const consumptionResult = await consumeAvailableCredits(context, totalRequiredAmount);
+
     // Check for auto recharge after successful consumption
     try {
       await checkAndTriggerAutoRecharge(

package/api/src/queues/credit-grant.ts

@@ -1,7 +1,7 @@
 // create credit grant
 
 import { Op } from 'sequelize';
-import { BN, fromTokenToUnit } from '@ocap/util';
+import { BN, fromTokenToUnit, fromUnitToToken } from '@ocap/util';
 import dayjs from '../libs/dayjs';
 import createQueue from '../libs/queue';
 import {
@@ -19,6 +19,7 @@ import {
 } from '../store/models';
 import { events } from '../libs/event';
 import { calculateExpiresAt, createCreditGrant } from '../libs/credit-grant';
+import { mintToken, transferTokenFromCustomer } from '../integrations/arcblock/token';
 import logger from '../libs/logger';
 
 type CreditGrantJob =
@@ -31,8 +32,217 @@ type CreditGrantJob =
       action: 'create_from_invoice';
     };
 
+/**
+ * Activate credit grants and handle on-chain minting when required.
+ * Non on-chain credits finish immediately; on-chain credits wait for mint success
+ */
+async function activateGrant(creditGrant: CreditGrant) {
+  const paymentCurrency = await PaymentCurrency.findByPk(creditGrant.currency_id);
+  const isOnChainCredit = paymentCurrency && PaymentCurrency.isOnChainCredit(paymentCurrency);
+
+  logger.info('Activating credit grant', {
+    creditGrantId: creditGrant.id,
+    customerId: creditGrant.customer_id,
+    currencyId: creditGrant.currency_id,
+    amount: creditGrant.amount,
+  });
+
+  if (!isOnChainCredit) {
+    await finalizeGrant(creditGrant);
+    return;
+  }
+
+  // Skip mint for already granted credits (legacy grants or already minted)
+  // New grants that need mint will have status='pending' until mint succeeds
+  if (creditGrant.status === 'granted' || creditGrant.chain_status === 'mint_completed') {
+    logger.info('Grant already in granted status, skipping mint', {
+      creditGrantId: creditGrant.id,
+      status: creditGrant.status,
+      chainStatus: creditGrant.chain_status,
+    });
+    await finalizeGrant(creditGrant);
+    return;
+  }
+
+  // Verify customer
+  const customer = await Customer.findByPk(creditGrant.customer_id);
+  if (!customer?.did) {
+    throw new Error(`Customer DID not found for credit grant ${creditGrant.id}`);
+  }
+
+  // Step 1: Mint token on-chain
+  // TODO: check if already minted
+  const mintAmount = fromUnitToToken(creditGrant.amount, paymentCurrency.decimal);
+  const hash = await mintToken({
+    paymentCurrency,
+    amount: mintAmount,
+    receiver: customer.did,
+    creditGrantId: creditGrant.id,
+  });
+
+  // Step 2: Finalize grant with mint result
+  await finalizeGrant(creditGrant, {
+    chain_status: 'mint_completed',
+    chain_detail: {
+      ...(creditGrant.chain_detail || {}),
+      mint: {
+        hash,
+        at: dayjs().unix(),
+      },
+    },
+  });
+
+  // Step 3: Emit mint success event for reconciliation
+  events.emit('customer.credit_grant.minted', creditGrant, { mintHash: hash });
+}
+
+async function finalizeGrant(
+  creditGrant: CreditGrant,
+  updates?: Partial<Pick<CreditGrant, 'chain_status' | 'chain_detail'>>
+) {
+  await creditGrant.update({ ...updates, status: 'granted' });
+  logger.info('Credit grant finalized', {
+    creditGrantId: creditGrant.id,
+    customerId: creditGrant.customer_id,
+  });
+
+  if (creditGrant.expires_at) {
+    await addCreditGrantJob(creditGrant, 'expire');
+    logger.info('Credit grant expire job ensured', {
+      creditGrantId: creditGrant.id,
+      expiresAt: creditGrant.expires_at,
+    });
+  }
+}
+
+/**
+ * Expire credit grants and handle on-chain token transfer when required.
+ * Transfers remaining tokens to system wallet for grants that have been minted (chain_status === 'mint_completed').
+ * This is consistent with credit consumption - expired credits are treated the same as consumed credits.
+ */
+export async function expireGrant(creditGrant: CreditGrant) {
+  // Only transfer for grants that have been minted on-chain
+  const isOnChain = creditGrant.hasOnchainToken();
+
+  logger.info('Expiring credit grant', {
+    creditGrantId: creditGrant.id,
+    isOnChain,
+    chainStatus: creditGrant.chain_status,
+    remainingAmount: creditGrant.remaining_amount,
+  });
+
+  // For grants without on-chain tokens, just update status
+  if (!isOnChain) {
+    await creditGrant.update({ status: 'expired' });
+    return;
+  }
+
+  const remainingAmount = new BN(creditGrant.remaining_amount || '0');
+  if (remainingAmount.lte(new BN(0))) {
+    // No remaining amount to transfer, just update status
+    await creditGrant.update({ status: 'expired' });
+    logger.info('Credit grant expired (no remaining amount to transfer)', {
+      creditGrantId: creditGrant.id,
+      customerId: creditGrant.customer_id,
+    });
+    return;
+  }
+
+  const paymentCurrency = await PaymentCurrency.findByPk(creditGrant.currency_id);
+  if (!paymentCurrency) {
+    logger.error('Payment currency not found for credit grant transfer', {
+      creditGrantId: creditGrant.id,
+      currencyId: creditGrant.currency_id,
+      customerId: creditGrant.customer_id,
+    });
+    await creditGrant.update({ status: 'expired' });
+    return;
+  }
+
+  // Get customer DID
+  const customer = await Customer.findByPk(creditGrant.customer_id);
+  if (!customer?.did) {
+    logger.error('Customer DID not found for credit grant transfer', {
+      creditGrantId: creditGrant.id,
+      customerId: creditGrant.customer_id,
+    });
+    await creditGrant.update({ status: 'expired' });
+    return;
+  }
+
+  // Transfer remaining tokens to system wallet (same as consumption flow)
+  const chainDetail = creditGrant.chain_detail || {};
+
+  try {
+    const hash = await transferTokenFromCustomer({
+      paymentCurrency,
+      customerDid: customer.did,
+      amount: remainingAmount.toString(),
+      data: {
+        reason: 'credit_expired',
+        creditGrantId: creditGrant.id,
+      },
+      checkBalance: false, // Don't check balance as we're transferring expired tokens
+    });
+
+    logger.info('Successfully transferred expired credit tokens to system wallet', {
+      creditGrantId: creditGrant.id,
+      customerId: creditGrant.customer_id,
+      amount: remainingAmount.toString(),
+      hash,
+    });
+
+    // Update status and chain_detail with transfer result
+    await creditGrant.update({
+      status: 'expired',
+      chain_status: 'transfer_completed',
+      chain_detail: {
+        ...chainDetail,
+        expired_transfer: {
+          hash,
+          at: dayjs().unix(),
+          amount: remainingAmount.toString(),
+        },
+        voided_reason: 'expired',
+      },
+    });
+
+    // Emit expired event for reconciliation
+    events.emit('customer.credit_grant.expired', creditGrant, {
+      transferHash: hash,
+      expiredAmount: remainingAmount.toString(),
+    });
+  } catch (error) {
+    logger.error('Failed to transfer expired credit tokens', {
+      creditGrantId: creditGrant.id,
+      customerId: creditGrant.customer_id,
+      amount: remainingAmount.toString(),
+      error: error.message,
+      stack: error.stack,
+    });
+
+    // Update status to expired and record error, but don't fail the expiration
+    await creditGrant.update({
+      status: 'expired',
+      chain_status: 'transfer_failed',
+      chain_detail: {
+        ...chainDetail,
+        expired_transfer: {
+          ...chainDetail.expired_transfer,
+          error: error.message,
+          failed_at: dayjs().unix(),
+        },
+        voided_reason: 'expired',
+      },
+    });
+  }
+}
+
 const handleCreditGrantJob = async (job: CreditGrantJob) => {
-  logger.info('Handling credit grant job', { job });
+  logger.info('Handling credit grant job', {
+    action: job.action,
+    ...(job.action === 'create_from_invoice' ? { invoiceId: job.invoiceId } : { creditGrantId: job.creditGrantId }),
+  });
   if (job.action === 'create_from_invoice') {
     await handleInvoiceCredit(job.invoiceId);
     return;
@@ -50,37 +260,17 @@ const handleCreditGrantJob = async (job: CreditGrantJob) => {
 
   if (action === 'activate') {
     if (creditGrant.status !== 'pending') {
-      logger.warn('Credit grant not in pending status for activation', {
+      logger.warn('Credit grant not in pending status for activation, skipping', {
         creditGrantId,
         status: creditGrant.status,
       });
       return;
     }
-    if (creditGrant.status === 'granted') {
-      logger.info('Credit grant already granted', {
-        creditGrantId,
-      });
-      return;
-    }
     if (
       (!creditGrant.effective_at || creditGrant.effective_at <= now) &&
       (!creditGrant.expires_at || creditGrant.expires_at > now)
     ) {
-      await creditGrant.update({
-        status: 'granted',
-      });
-
-      logger.info('Credit grant activated', {
-        creditGrantId,
-      });
-
-      if (creditGrant.expires_at) {
-        await addCreditGrantJob(creditGrant, 'expire', creditGrant.expires_at);
-        logger.info('Credit grant expire job scheduled', {
-          creditGrantId,
-          expiresAt: creditGrant.expires_at,
-        });
-      }
+      await activateGrant(creditGrant);
     }
   }
 
@@ -93,12 +283,7 @@ const handleCreditGrantJob = async (job: CreditGrantJob) => {
       return;
     }
     if (creditGrant.expires_at && creditGrant.expires_at <= now) {
-      await creditGrant.update({
-        status: 'expired',
-      });
-      logger.info('Credit grant expired', {
-        creditGrantId,
-      });
+      await expireGrant(creditGrant);
     }
   }
 };
@@ -163,6 +348,13 @@ export async function addCreditGrantJob(creditGrant: CreditGrant, action: 'activ
 export async function scheduleCreditGrantJobs(creditGrant: CreditGrant) {
   const now = dayjs().unix();
 
+  logger.info('Scheduling credit grant jobs', {
+    creditGrantId: creditGrant.id,
+    status: creditGrant.status,
+    effective_at: creditGrant.effective_at,
+    expires_at: creditGrant.expires_at,
+  });
+
   if (creditGrant.status === 'pending') {
     if (creditGrant.effective_at && creditGrant.effective_at > now) {
       await addCreditGrantJob(creditGrant, 'activate');
@@ -170,16 +362,9 @@ export async function scheduleCreditGrantJobs(creditGrant: CreditGrant) {
     }
     if (!creditGrant.effective_at || creditGrant.effective_at <= now) {
       if (!creditGrant.expires_at || creditGrant.expires_at > now) {
-        await creditGrant.update({ status: 'granted' });
-        logger.info('Credit grant immediately activated', {
-          creditGrantId: creditGrant.id,
-          customerId: creditGrant.customer_id,
-        });
-        if (creditGrant.expires_at) {
-          await addCreditGrantJob(creditGrant, 'expire');
-        }
+        await activateGrant(creditGrant);
       } else {
-        await creditGrant.update({ status: 'expired' });
+        await expireGrant(creditGrant);
         logger.info('Credit grant immediately expired', {
           creditGrantId: creditGrant.id,
           customerId: creditGrant.customer_id,
@@ -187,8 +372,9 @@ export async function scheduleCreditGrantJobs(creditGrant: CreditGrant) {
       }
     }
   }
-  if (creditGrant.status === 'granted' && creditGrant.expires_at) {
-    await addCreditGrantJob(creditGrant, 'expire');
+  if (creditGrant.status === 'granted') {
+    // Retry mint if previously failed, and schedule expiration
+    await activateGrant(creditGrant);
   }
 }
 
@@ -257,8 +443,8 @@ creditGrantQueue.on('failed', ({ id, job, error }) => {
   logger.error('Credit grant job failed', { id, job, error });
 });
 
-creditGrantQueue.on('finished', ({ id, job, result }) => {
-  logger.info('Credit grant job completed', { id, job, result });
+creditGrantQueue.on('finished', ({ id }) => {
+  logger.debug('Credit grant job completed', { id });
 });
 
 async function handleInvoiceCredit(invoiceId: string) {
@@ -277,7 +463,7 @@ async function handleInvoiceCredit(invoiceId: string) {
     })) as TInvoiceExpanded | null;
 
     if (!invoice) {
-      logger.info('Invoice not found', { invoiceId });
+      logger.warn('Invoice not found', { invoiceId });
       return;
     }
 
@@ -354,6 +540,7 @@ async function handleInvoiceCredit(invoiceId: string) {
             },
           };
         }
+
         return {
           price,
           quantity,
@@ -361,7 +548,8 @@ async function handleInvoiceCredit(invoiceId: string) {
           creditAmount,
           applicablePrices,
           expiredAt: calculateExpiresAt(
-            parseInt(String(creditConfig?.valid_duration_value || '0'), 10),
+            // eslint-disable-next-line no-unsafe-optional-chaining
+            +creditConfig?.valid_duration_value || 0,
             creditConfig?.valid_duration_unit || 'days'
           ),
           applicabilityConfig,
@@ -459,7 +647,7 @@ async function handleInvoiceCredit(invoiceId: string) {
     } catch (error) {
       logger.error('Failed to create Credit Grant from invoice', {
         invoiceId,
-        error: error.message,
+        error,
         stack: error.stack,
       });
       await Invoice.update(
@@ -502,10 +690,11 @@ export async function addInvoiceCreditJob(invoiceId: string) {
 
   const existingJob = await creditGrantQueue.get(jobId);
   if (existingJob) {
-    logger.info('Invoice credit job already exists, skipping duplicate', {
+    logger.debug('Invoice credit job already exists, skipping duplicate', {
       invoiceId,
       jobId,
     });
+    return;
   }
 
   await creditGrantQueue.push({
@@ -534,8 +723,14 @@ events.on('invoice.paid', async (invoice: Invoice) => {
   }
 });
 
-events.on('customer.credit_grant.created', async (creditGrant: CreditGrant) => {
+events.on('customer.credit_grant.created', async (data: { id: string }) => {
   try {
+    // Fetch instance since event emits dataValues (plain object)
+    const creditGrant = await CreditGrant.findByPk(data.id);
+    if (!creditGrant) {
+      logger.error('Credit grant not found for scheduling', { creditGrantId: data.id });
+      return;
+    }
     await scheduleCreditGrantJobs(creditGrant);
     logger.info('Credit grant jobs scheduled', {
       creditGrantId: creditGrant.id,
@@ -543,8 +738,8 @@ events.on('customer.credit_grant.created', async (creditGrant: CreditGrant) => {
     });
   } catch (error) {
     logger.error('Failed to schedule credit grant jobs', {
-      creditGrantId: creditGrant.id,
-      error: error.message,
+      creditGrantId: data.id,
+      error,
     });
   }
 });