payment-kit 1.19.17 → 1.19.19

package/api/src/queues/auto-recharge.ts

@@ -0,0 +1,343 @@
+import { BN } from '@ocap/util';
+
+import { CustomError } from '@blocklet/error';
+import { Op } from 'sequelize';
+import createQueue from '../libs/queue';
+import {
+  AutoRechargeConfig,
+  CreditGrant,
+  Customer,
+  Invoice,
+  PaymentCurrency,
+  PaymentMethod,
+  Price,
+  Product,
+  TPriceExpanded,
+} from '../store/models';
+import logger from '../libs/logger';
+import { getPriceUintAmountByCurrency } from '../libs/session';
+import { isDelegationSufficientForPayment } from '../libs/payment';
+import { createStripeInvoiceForAutoRecharge } from '../integrations/stripe/resource';
+import { ensureInvoiceAndItems } from '../libs/invoice';
+import dayjs from '../libs/dayjs';
+import { invoiceQueue } from './invoice';
+
+export interface AutoRechargeJobData {
+  customer_id: string;
+  currency_id: string;
+}
+
+export interface AutoRechargeJobResult {
+  success: boolean;
+  invoice_id?: string;
+  error_message?: string;
+  recharge_amount?: string;
+  credit_amount?: string;
+  payment_method_type?: string;
+}
+
+export async function processAutoRecharge(job: AutoRechargeJobData) {
+  logger.info('Processing auto recharge job', { job });
+  const { customer_id: customerId, currency_id: currencyId } = job;
+
+  const customer = await Customer.findByPk(customerId);
+  if (!customer) {
+    logger.error('Customer not found', { customerId });
+    return;
+  }
+
+  const currency = await PaymentCurrency.findByPk(currencyId);
+  if (!currency) {
+    logger.error('Currency not found', { currencyId });
+    return;
+  }
+
+  // 1. find auto recharge config
+  const config = (await AutoRechargeConfig.findOne({
+    where: {
+      customer_id: customerId,
+      currency_id: currencyId,
+    },
+    include: [
+      { model: PaymentCurrency, as: 'rechargeCurrency', required: false },
+      { model: Price, as: 'price', include: [{ model: Product, as: 'product' }] },
+      { model: PaymentMethod, as: 'paymentMethod' },
+    ],
+  })) as AutoRechargeConfig & {
+    paymentMethod: PaymentMethod;
+    price: TPriceExpanded;
+    rechargeCurrency: PaymentCurrency;
+  };
+
+  if (!config || !config.enabled) {
+    logger.info('No auto recharge config found', { customerId, currencyId });
+    return;
+  }
+
+  if (!config.rechargeCurrency) {
+    logger.error('Recharge currency not found', { customerId, currencyId });
+    return;
+  }
+
+  const availableGrants = await CreditGrant.getAvailableCreditsForCustomer(customerId, currencyId, [config.price_id]);
+
+  const totalAvailable = availableGrants.reduce((sum, grant) => sum.add(new BN(grant.remaining_amount)), new BN(0));
+
+  // 2. check if available balance is above threshold
+  if (new BN(totalAvailable).gt(new BN(config.threshold))) {
+    logger.info('Available balance is above threshold, skipping auto recharge', {
+      customerId,
+      currencyId,
+      totalAvailable: totalAvailable.toString(),
+      threshold: config.threshold,
+    });
+    return;
+  }
+
+  const priceAmount = await getPriceUintAmountByCurrency(config.price, config.rechargeCurrency.id);
+  if (!priceAmount) {
+    logger.error('Price amount is not valid', {
+      customerId,
+      currencyId,
+    });
+    return;
+  }
+  const totalAmount = new BN(priceAmount).mul(new BN(config.quantity ?? 0)).toString();
+
+  // 3. check daily limit
+  if (!config.canRechargeToday(totalAmount)) {
+    logger.info('Daily recharge limit exceeded, skipping auto recharge', {
+      customerId,
+      currencyId,
+    });
+    return;
+  }
+
+  // 4. execute auto recharge
+  await executeAutoRecharge(customer, config, currency);
+}
+
+async function createInvoiceForAutoRecharge({
+  customer,
+  config,
+  currency,
+  price,
+  totalAmount,
+  paymentMethod,
+  rechargeCurrency,
+}: {
+  customer: Customer;
+  config: AutoRechargeConfig;
+  currency: PaymentCurrency;
+  price: TPriceExpanded;
+  totalAmount: BN;
+  paymentMethod: PaymentMethod;
+  rechargeCurrency: PaymentCurrency;
+}) {
+  const now = dayjs().unix();
+  const expandedItems = await Price.expand([{ price_id: price.id, quantity: config.quantity }], {
+    product: true,
+  });
+  let status = 'open';
+  if (paymentMethod.type === 'stripe') {
+    status = 'draft'; // stripe invoice will be finalized and paid automatically
+  }
+  const existInvoice = await Invoice.findOne({
+    where: {
+      customer_id: customer.id,
+      currency_id: rechargeCurrency.id,
+      status: {
+        [Op.in]: ['open', 'draft'],
+      },
+    },
+  });
+  if (existInvoice) {
+    logger.info('Auto recharge invoice already exists, skipping', {
+      customerId: customer.id,
+      configId: config.id,
+    });
+    return existInvoice;
+  }
+  const { invoice } = await ensureInvoiceAndItems({
+    customer,
+    currency: rechargeCurrency,
+    trialing: false,
+    metered: false,
+    lineItems: expandedItems,
+    applyCredit: false,
+    props: {
+      status,
+      total: totalAmount.toString(),
+      livemode: rechargeCurrency.livemode,
+      description: `Auto Top-up for ${currency.name}`,
+      statement_descriptor: '',
+      period_start: now,
+      period_end: now,
+      auto_advance: true,
+      billing_reason: 'auto_recharge',
+      currency_id: rechargeCurrency.id,
+      default_payment_method_id: paymentMethod.id,
+      custom_fields: [],
+      footer: '',
+      payment_settings: config.payment_settings,
+      metadata: {
+        auto_recharge: {
+          config_id: config.id,
+          currency_id: rechargeCurrency.id,
+        },
+      },
+    } as unknown as Invoice,
+  });
+  logger.info('New invoice created for auto recharge', {
+    customerId: customer.id,
+    configId: config.id,
+    invoiceId: invoice.id,
+    amount: totalAmount,
+  });
+  if (status !== 'draft') {
+    invoiceQueue.push({
+      id: invoice.id,
+      job: { invoiceId: invoice.id, retryOnError: true },
+    });
+    logger.info('Invoice job scheduled for auto recharge', { invoice: invoice.id, customerId: customer.id });
+  }
+  return invoice;
+}
+
+async function executeAutoRecharge(
+  customer: Customer,
+  config: AutoRechargeConfig & {
+    paymentMethod: PaymentMethod;
+    price: TPriceExpanded;
+    rechargeCurrency: PaymentCurrency;
+  },
+  currency: PaymentCurrency
+) {
+  const paymentMethod = config.paymentMethod!;
+  const price = config.price! as TPriceExpanded;
+  const rechargeCurrency = config.rechargeCurrency!;
+
+  try {
+    const priceAmount = await getPriceUintAmountByCurrency(price, rechargeCurrency.id);
+    const totalAmount = new BN(priceAmount).mul(new BN(config.quantity ?? 0));
+    const paymentSettings = config.payment_settings;
+    if (!paymentSettings) {
+      throw new Error('No payment settings found for auto recharge');
+    }
+    const payer = (paymentSettings.payment_method_options as any)?.[paymentMethod.type]?.payer;
+    if (!payer) {
+      throw new Error('No payer found for auto recharge');
+    }
+    if (paymentMethod.type !== 'stripe') {
+      const delegationCheck = await isDelegationSufficientForPayment({
+        paymentMethod,
+        paymentCurrency: rechargeCurrency,
+        userDid: payer,
+        amount: totalAmount.toString(),
+      });
+      if (!delegationCheck.sufficient) {
+        throw new CustomError(delegationCheck.reason, 'insufficient delegation or balance');
+      }
+    }
+    const invoice = await createInvoiceForAutoRecharge({
+      customer,
+      config,
+      currency,
+      price,
+      totalAmount,
+      paymentMethod,
+      rechargeCurrency,
+    });
+    if (paymentMethod.type === 'stripe') {
+      await createStripeInvoiceForAutoRecharge({
+        autoRechargeConfig: config,
+        customer,
+        paymentMethod,
+        currency: rechargeCurrency,
+        invoice,
+      });
+    }
+  } catch (error: any) {
+    logger.error('Auto recharge execution failed', {
+      customerId: customer.id,
+      configId: config.id,
+      paymentMethodType: paymentMethod.type,
+      error: error.message,
+    });
+    throw error;
+  }
+}
+
+// 创建自动充值队列
+export const autoRechargeQueue = createQueue<AutoRechargeJobData>({
+  name: 'auto-recharge',
+  onJob: processAutoRecharge,
+  options: {
+    concurrency: 5,
+    maxRetries: 3,
+  },
+});
+
+/**
+ * 检查并触发自动充值 (添加到队列)
+ */
+export async function checkAndTriggerAutoRecharge(
+  customer: Customer,
+  currencyId: string,
+  currentBalance: string
+): Promise<void> {
+  try {
+    // 查找自动充值配置
+    const config = await AutoRechargeConfig.findOne({
+      where: {
+        customer_id: customer.id,
+        currency_id: currencyId,
+        enabled: true,
+        livemode: customer.livemode,
+      },
+    });
+
+    if (!config) {
+      logger.debug('No auto recharge config found', {
+        customerId: customer.id,
+        currencyId,
+      });
+      return;
+    }
+
+    //  check if balance is above threshold
+    if (new BN(currentBalance).gte(new BN(config.threshold))) {
+      logger.debug('Balance above threshold, skipping auto recharge', {
+        customerId: customer.id,
+        currentBalance,
+        threshold: config.threshold,
+      });
+      return;
+    }
+
+    const jobData: AutoRechargeJobData = {
+      customer_id: customer.id,
+      currency_id: currencyId,
+    };
+
+    await autoRechargeQueue.push({
+      job: jobData,
+      id: `auto-recharge-${customer.id}-${currencyId}}`,
+      persist: true,
+    });
+
+    logger.info('Added auto recharge job to queue', {
+      customerId: customer.id,
+      currencyId,
+      currentBalance,
+      threshold: config.threshold,
+    });
+  } catch (error: any) {
+    logger.error('Failed to trigger auto recharge', {
+      customerId: customer.id,
+      currencyId,
+      currentBalance,
+      error: error.message,
+    });
+  }
+}

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

@@ -19,6 +19,7 @@ import { MAX_RETRY_COUNT, getNextRetry } from '../libs/util';
 import { getDaysUntilCancel, getDueUnit, getMeterPriceIdsFromSubscription } from '../libs/subscription';
 import { events } from '../libs/event';
 import { handlePastDueSubscriptionRecovery } from './payment';
+import { checkAndTriggerAutoRecharge } from './auto-recharge';
 
 type CreditConsumptionJob = {
   meterEventId: string;
@@ -41,6 +42,38 @@ type CreditConsumptionResult = {
   fully_consumed: boolean;
 };
 
+async function checkLowBalance(
+  customerId: string,
+  currencyId: string,
+  totalCreditAmount: string,
+  remainingBalance: string,
+  context: CreditConsumptionContext
+): Promise<void> {
+  try {
+    const totalCreditAmountBn = new BN(totalCreditAmount);
+    if (totalCreditAmountBn.lte(new BN(0))) return;
+    const remainingAmountBn = new BN(remainingBalance);
+    const threshold = totalCreditAmountBn.mul(new BN(10)).div(new BN(100));
+    if (remainingAmountBn.gt(new BN(0)) && remainingAmountBn.lte(threshold)) {
+      const percentage = remainingAmountBn.mul(new BN(100)).div(totalCreditAmountBn).toString();
+      await createEvent('Customer', 'customer.credit.low_balance', context.customer, {
+        metadata: {
+          currency_id: currencyId,
+          available_amount: remainingAmountBn.toString(),
+          total_amount: totalCreditAmountBn.toString(),
+          percentage,
+          subscription_id: context.subscription?.id,
+        },
+      }).catch(console.error);
+    }
+  } catch (error: any) {
+    logger.error('Failed to check low balance', {
+      customerId,
+      currencyId,
+      error: error.message,
+    });
+  }
+}
 async function validateAndLoadData(meterEventId: string): Promise<CreditConsumptionContext | null> {
   const meterEvent = await MeterEvent.findByPk(meterEventId);
   if (!meterEvent) {
@@ -171,6 +204,8 @@ async function consumeAvailableCredits(
   // Get all available grants sorted by priority
   const availableGrants = await CreditGrant.getAvailableCreditsForCustomer(customerId, currencyId, context.priceIds);
 
+  const totalCreditAmountBN = availableGrants.reduce((sum, grant) => sum.add(new BN(grant.amount)), new BN(0));
+
   // Calculate total available balance
   const totalAvailable = availableGrants.reduce((sum, grant) => sum.add(new BN(grant.remaining_amount)), new BN(0));
   logger.debug('Total available credits calculated', { totalAvailable: totalAvailable.toString() });
@@ -275,6 +310,8 @@ async function consumeAvailableCredits(
     }).catch(console.error);
   }
 
+  await checkLowBalance(customerId, currencyId, totalCreditAmountBN.toString(), remainingBalance, context);
+
   return {
     consumed: totalConsumed.toString(),
     pending: pendingAmount,
@@ -449,7 +486,20 @@ 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(
+        context.customer,
+        context.meter.currency_id!,
+        consumptionResult.available_balance
+      );
+    } catch (error: any) {
+      logger.warn('Auto recharge check failed after credit consumption', {
+        meterEventId,
+        customerId,
+        error: error.message,
+      });
+    }
     // Update MeterEvent with consumption details
     await context.meterEvent.update({
       credit_consumed: consumptionResult.consumed,

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

@@ -5,6 +5,7 @@ import { BN, fromTokenToUnit } from '@ocap/util';
 import dayjs from '../libs/dayjs';
 import createQueue from '../libs/queue';
 import {
+  AutoRechargeConfig,
   CreditGrant,
   Customer,
   Invoice,
@@ -285,6 +286,20 @@ async function handleInvoiceCredit(invoiceId: string) {
       return;
     }
 
+    // Handle auto recharge invoice - use standard processing since we now create proper InvoiceItems
+    if (invoice.metadata?.auto_recharge) {
+      logger.info('Processing auto recharge invoice with standard logic', {
+        invoiceId: invoice.id,
+        customerId: invoice.customer.id,
+      });
+      if (invoice.metadata?.auto_recharge?.config_id) {
+        const autoRechargeConfig = await AutoRechargeConfig.findByPk(invoice.metadata?.auto_recharge?.config_id);
+        if (autoRechargeConfig) {
+          await autoRechargeConfig.updateDailyStats(invoice.total);
+        }
+      }
+    }
+
     const lineItems = invoice.lines || [];
 
     if (!Array.isArray(lineItems) || lineItems.length === 0) {

package/api/src/queues/notification.ts

@@ -93,10 +93,11 @@ import {
   CustomerCreditGrantGrantedEmailTemplate,
   CustomerCreditGrantGrantedEmailTemplateOptions,
 } from '../libs/notification/template/customer-credit-grant-granted';
+
 import {
-  CustomerCreditGrantLowBalanceEmailTemplate,
-  CustomerCreditGrantLowBalanceEmailTemplateOptions,
-} from '../libs/notification/template/customer-credit-grant-low-balance';
+  CustomerCreditLowBalanceEmailTemplate,
+  CustomerCreditLowBalanceEmailTemplateOptions,
+} from '../libs/notification/template/customer-credit-low-balance';
 import {
   CustomerRevenueSucceededEmailTemplate,
   CustomerRevenueSucceededEmailTemplateOptions,
@@ -128,7 +129,7 @@ export type NotificationQueueJobType =
   | 'subscription.overdraftProtection.exhausted'
   | 'customer.credit.insufficient'
   | 'customer.credit_grant.granted'
-  | 'customer.credit_grant.low_balance';
+  | 'customer.credit.low_balance';
 
 export type NotificationQueueJob = {
   type: NotificationQueueJobType;
@@ -266,10 +267,8 @@ async function getNotificationTemplate(job: NotificationQueueJob): Promise<BaseE
     return new CustomerCreditGrantGrantedEmailTemplate(job.options as CustomerCreditGrantGrantedEmailTemplateOptions);
   }
 
-  if (job.type === 'customer.credit_grant.low_balance') {
-    return new CustomerCreditGrantLowBalanceEmailTemplate(
-      job.options as CustomerCreditGrantLowBalanceEmailTemplateOptions
-    );
+  if (job.type === 'customer.credit.low_balance') {
+    return new CustomerCreditLowBalanceEmailTemplate(job.options as CustomerCreditLowBalanceEmailTemplateOptions);
   }
 
   throw new Error(`Unknown job type: ${job.type}`);
@@ -600,15 +599,19 @@ export async function startNotificationQueue() {
     );
   });
 
-  events.on('customer.credit_grant.low_balance', (creditGrant: CreditGrant) => {
+  events.on('customer.credit.low_balance', (customer: Customer, { metadata }: { metadata: any }) => {
     addNotificationJob(
-      'customer.credit_grant.low_balance',
+      'customer.credit.low_balance',
       {
-        creditGrantId: creditGrant.id,
+        customerId: customer.id,
+        currencyId: metadata.currency_id,
+        availableAmount: metadata.available_amount,
+        totalAmount: metadata.total_amount,
+        percentage: metadata.percentage,
       },
-      [creditGrant.id],
+      [customer.id, metadata.currency_id],
       true,
-      24 * 3600 // 1 天
+      24 * 3600
     );
   });
 

package/api/src/queues/payment.ts

@@ -36,7 +36,7 @@ import { SubscriptionItem } from '../store/models/subscription-item';
 import type { EVMChainType, PaymentError, PaymentSettings } from '../store/models/types';
 import { notificationQueue } from './notification';
 import { ensureOverdraftProtectionInvoiceAndItems } from '../libs/invoice';
-import { Lock, MeterEvent } from '../store/models';
+import { AutoRechargeConfig, Lock, MeterEvent } from '../store/models';
 import { ensureOverdraftProtectionPrice } from '../libs/overdraft-protection';
 import createQueue from '../libs/queue';
 import { CHARGE_SUPPORTED_CHAIN_TYPES, EVM_CHAIN_TYPES } from '../libs/constants';
@@ -663,6 +663,19 @@ export const handlePaymentFailed = async (
       attempt_count: invoice.attempt_count,
     });
 
+    if (invoice.billing_reason === 'auto_recharge' && invoice.metadata?.recharge_config?.recharge_id) {
+      const autoRechargeConfig = await AutoRechargeConfig.findByPk(invoice.metadata?.recharge_config?.recharge_id);
+      if (autoRechargeConfig && autoRechargeConfig.enabled) {
+        autoRechargeConfig.update({
+          enabled: false,
+          metadata: {
+            ...autoRechargeConfig.metadata,
+            failReason: 'Payment failed',
+          },
+        });
+      }
+    }
+
     return updates.terminate;
   }
 

package/api/src/queues/space.ts

@@ -58,6 +58,7 @@ const categoryMap = {
   stake_overdraft_protection: 'stake',
   recharge: 'recharge',
   return_stake: 'returnStake',
+  auto_recharge: 'recharge',
 } as const;
 
 const getBillingCategory = (billingReason: string): string => {