payment-kit 1.20.14 → 1.20.16

package/api/src/libs/discount/coupon.ts

@@ -1,10 +1,19 @@
-import { BN } from '@ocap/util';
+import { BN, fromUnitToToken } from '@ocap/util';
 
 import pick from 'lodash/pick';
-import { Coupon, Customer, Discount, PromotionCode, Subscription } from '../../store/models';
-import type { CheckoutSession, TLineItemExpanded } from '../../store/models';
+import {
+  Coupon,
+  Customer,
+  Discount,
+  PromotionCode,
+  Subscription,
+  CheckoutSession,
+  PaymentCurrency,
+} from '../../store/models';
+import type { TLineItemExpanded } from '../../store/models';
 import logger from '../logger';
 import { emitAsync } from '../event';
+import { formatNumber } from '../util';
 
 export function validCoupon(coupon: Coupon, lineItems?: TLineItemExpanded[]) {
   if (!coupon.valid) {
@@ -75,13 +84,20 @@ export async function validPromotionCode(
         ? promotionCode.restrictions?.minimum_amount
         : promotionCode.restrictions?.currency_options?.[currencyId]?.minimum_amount;
 
+    const currency = await PaymentCurrency.findByPk(currencyId);
     if (minimumAmount) {
       const amountBN = new BN(amount);
       const minimumBN = new BN(minimumAmount);
       if (amountBN.lt(minimumBN)) {
+        if (!currency) {
+          return {
+            valid: false,
+            reason: 'This promotion requires a minimum purchase amount. Please add more items to your cart.',
+          };
+        }
         return {
           valid: false,
-          reason: 'This promotion requires a minimum purchase amount. Please add more items to your cart.',
+          reason: `This promotion requires a minimum purchase amount of ${formatNumber(fromUnitToToken(minimumBN, currency?.decimal || 2))} ${currency?.symbol}. Please add more items to your cart.`,
         };
       }
     }
@@ -296,7 +312,7 @@ async function processSubscriptionDiscount({
   baseDiscountData: any;
   existingDiscountMap: Map<string, any>;
   checkoutSessionId: string;
-}): Promise<{ discountRecord: any; shouldUpdateUsage: boolean }> {
+}): Promise<{ discountRecord: Discount; shouldUpdateUsage: boolean }> {
   try {
     const existingDiscount = existingDiscountMap.get(subscriptionId);
 
@@ -342,6 +358,7 @@ async function processSubscriptionDiscount({
     const newDiscount = await Discount.create({
       ...baseDiscountData,
       subscription_id: subscriptionId,
+      confirmed: false,
       metadata: {
         ...baseDiscountData.metadata,
         subscription_id: subscriptionId,
@@ -375,7 +392,7 @@ async function processNonSubscriptionDiscount(
   baseDiscountData: any,
   existingDiscountMap: Map<string, any>,
   checkoutSessionId: string
-): Promise<{ discountRecord: any; shouldUpdateUsage: boolean }> {
+): Promise<{ discountRecord: Discount; shouldUpdateUsage: boolean }> {
   try {
     const existingDiscount = existingDiscountMap.get('no_subscription');
 
@@ -412,7 +429,10 @@ async function processNonSubscriptionDiscount(
     }
 
     // Create new discount record
-    const newDiscount = await Discount.create(baseDiscountData);
+    const newDiscount = await Discount.create({
+      ...baseDiscountData,
+      confirmed: false,
+    });
 
     // Lock coupon and promotion code when discount is created
     await lockDiscountResources(baseDiscountData.coupon_id, baseDiscountData.promotion_code_id);
@@ -710,6 +730,13 @@ export async function createDiscountRecordsForCheckout({
               updatedPromotionCodes,
               checkoutSessionId: checkoutSession.id,
             });
+            await Promise.all(
+              discountRecords.map(async (discountRecord) => {
+                await discountRecord.update({
+                  confirmed: true,
+                });
+              })
+            );
           } catch (error) {
             logger.error('Failed to update usage counts, but continuing', {
               couponId: coupon.id,

package/api/src/libs/discount/discount.ts

@@ -1,8 +1,9 @@
 import { BN } from '@ocap/util';
-import { Coupon, Discount, PaymentCurrency, PromotionCode } from '../../store/models';
+import { Coupon, Discount, PaymentCurrency, PromotionCode, CheckoutSession } from '../../store/models';
 import type { TLineItemExpanded } from '../../store/models';
 import { getPriceUintAmountByCurrency } from '../price';
 import { validCoupon, checkPromotionCodeEligibility, calculateDiscountAmount } from './coupon';
+import { emitAsync } from '../event';
 import logger from '../logger';
 
 const getItemsTotalAmount = (lineItems: TLineItemExpanded[], currencyId: string, options?: { trialing?: boolean }) => {
@@ -347,3 +348,84 @@ export async function applySubscriptionDiscount({
 
   return result;
 }
+
+async function rollbackUsageForResource<T extends Coupon | PromotionCode>(
+  resource: T,
+  resourceType: 'coupon' | 'promotion-code'
+): Promise<void> {
+  const currentUsage = resource.times_redeemed || 0;
+  if (currentUsage <= 0) return;
+
+  if (resourceType === 'coupon') {
+    await (resource as Coupon).update({
+      times_redeemed: currentUsage - 1,
+      valid: true,
+    });
+  } else {
+    await (resource as PromotionCode).update({
+      times_redeemed: currentUsage - 1,
+      active: true,
+    });
+  }
+
+  logger.info('Updated usage for resource', {
+    resourceId: resource.id,
+    resourceType,
+    currentUsage: currentUsage - 1,
+  });
+
+  emitAsync('discount-status.queued', resource, resourceType, true);
+}
+
+export async function rollbackDiscountUsageForCheckoutSession(checkoutSessionId: string): Promise<void> {
+  try {
+    const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
+    if (!checkoutSession) {
+      logger.error('Checkout session not found', { checkoutSessionId });
+      return;
+    }
+
+    if (checkoutSession.status === 'complete') {
+      logger.error('Cannot rollback completed session', { checkoutSessionId });
+      return;
+    }
+
+    const discounts = (await Discount.findAll({
+      where: { checkout_session_id: checkoutSessionId },
+      include: [
+        { model: Coupon, as: 'coupon' },
+        { model: PromotionCode, as: 'promotionCode', required: false },
+      ],
+    })) as (Discount & { coupon: Coupon; promotionCode?: PromotionCode })[];
+
+    if (discounts.length === 0) {
+      logger.info('No discounts found for checkout session', { checkoutSessionId });
+      return;
+    }
+
+    const uniqueCoupons = new Map<string, Coupon>();
+    const uniquePromotionCodes = new Map<string, PromotionCode>();
+
+    discounts.forEach((discount) => {
+      if (discount.confirmed) {
+        if (discount.coupon?.id && !uniqueCoupons.has(discount.coupon.id)) {
+          uniqueCoupons.set(discount.coupon.id, discount.coupon);
+        }
+        if (discount.promotionCode?.id && !uniquePromotionCodes.has(discount.promotionCode.id)) {
+          uniquePromotionCodes.set(discount.promotionCode.id, discount.promotionCode);
+        }
+      }
+    });
+
+    const rollbackPromises = [
+      ...Array.from(uniquePromotionCodes.values()).map((pc) => rollbackUsageForResource(pc, 'promotion-code')),
+      ...Array.from(uniqueCoupons.values()).map((c) => rollbackUsageForResource(c, 'coupon')),
+    ];
+
+    await Promise.all(rollbackPromises);
+
+    await Promise.all(discounts.map((discount) => discount.destroy()));
+  } catch (error) {
+    logger.error('Discount rollback failed', { checkoutSessionId, error: error.message });
+  }
+}

package/api/src/libs/env.ts

@@ -21,6 +21,7 @@ export const vendorTimeoutMinutes: number = process.env.VENDOR_TIMEOUT_MINUTES
   : 10; // 默认 10 分钟超时
 
 export const shortUrlApiKey: string = process.env.SHORT_URL_API_KEY || '';
+export const shortUrlDomain: string = process.env.SHORT_URL_DOMAIN || 's.abtnet.io';
 
 // sequelize 配置相关
 export const sequelizeOptionsPoolMin: number = process.env.SEQUELIZE_OPTIONS_POOL_MIN

package/api/src/libs/payment.ts

@@ -368,7 +368,7 @@ export function isCreditSufficientForPayment(args: {
   const balance = tokens[paymentCurrency.id] || '0';
 
   if (amount === '0') {
-    return { sufficient: false, balance, reason: 'NO_REQUIREMENT' };
+    return { sufficient: true, balance };
   }
 
   if (new BN(balance).lt(new BN(amount))) {

package/api/src/libs/url.ts

@@ -1,5 +1,5 @@
 import logger from './logger';
-import { shortUrlApiKey } from './env';
+import { shortUrlApiKey, shortUrlDomain } from './env';
 
 interface ShortUrlResponse {
   shortUrl: string;
@@ -43,14 +43,14 @@ export async function formatToShortUrl({
       maxVisits,
       tags: [],
       shortCodeLength: 8,
-      domain: 's.abtnet.io',
+      domain: shortUrlDomain,
       findIfExists: true,
       validateUrl: true,
       forwardQuery: true,
       crawlable: true,
     };
 
-    const response = await fetch('https://s.abtnet.io/rest/v3/short-urls', {
+    const response = await fetch(`https://${shortUrlDomain}/rest/v3/short-urls`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',

package/api/src/libs/vendor-util/adapters/launcher-adapter.ts

@@ -89,7 +89,7 @@ export class LauncherAdapter implements VendorAdapter {
           amount: params.amount,
           currency: params.currency,
           quantity: params.quantity,
-          paymentIntentId: params.paymentIntentId,
+          invoiceId: params.invoiceId,
           customParams: params.customParams,
         },
         installationInfo: {

package/api/src/libs/vendor-util/adapters/types.ts

@@ -14,7 +14,7 @@ export interface FulfillOrderParams {
   productCode: string;
   customerId: string;
   quantity: number;
-  paymentIntentId: string;
+  invoiceId: string;
   amount: string;
   currency: string;
 
@@ -38,7 +38,7 @@ export interface OrderDetails {
   amount: string;
   currency: string;
   quantity: number;
-  paymentIntentId: string;
+  invoiceId: string;
   customParams?: Record<string, any>;
 }
 
@@ -66,7 +66,6 @@ export interface ReturnRequestParams {
   orderId: string;
   vendorOrderId?: string;
   reason: string;
-  paymentIntentId: string;
   customParams?: Record<string, any>;
 }
 

package/api/src/libs/vendor-util/fulfillment.ts

@@ -43,7 +43,7 @@ export class VendorFulfillmentService {
       checkoutSessionId: string;
       amount_total: string;
       customer_id: string;
-      payment_intent_id: string | null;
+      invoiceId: string;
       currency_id: string;
       customer_did: string;
     },
@@ -75,7 +75,7 @@ export class VendorFulfillmentService {
         productCode: vendorConfig.vendor_id,
         customerId: orderInfo.customer_id || '',
         quantity: 1,
-        paymentIntentId: orderInfo.payment_intent_id || '',
+        invoiceId: orderInfo.invoiceId,
         amount: orderInfo.amount_total,
         currency: orderInfo.currency_id,
 
@@ -124,34 +124,18 @@ export class VendorFulfillmentService {
     }
   }
 
-  static async createVendorPayouts(
-    checkoutSessionId: string,
-    fulfillmentResults?: VendorFulfillmentResult[]
-  ): Promise<void> {
+  static async createVendorPayouts(checkoutSession: CheckoutSession, paymentIntent: PaymentIntent): Promise<void> {
     try {
-      const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
-      if (!checkoutSession) {
-        throw new Error(`CheckoutSession not found: ${checkoutSessionId}`);
-      }
-
-      let paymentMethodId = '';
-      if (checkoutSession.payment_intent_id) {
-        const paymentIntent = await PaymentIntent.findByPk(checkoutSession.payment_intent_id);
-        if (paymentIntent) {
-          paymentMethodId = paymentIntent.payment_method_id;
-        }
-      }
+      const paymentMethodId = paymentIntent.payment_method_id;
+      const paymentIntentId = paymentIntent.id;
 
       // If fulfillmentResults not provided, calculate commission info
-      let commissionData = fulfillmentResults;
-      if (!commissionData) {
-        commissionData = checkoutSession.vendor_info?.map((vendorInfo: any) => ({
-          vendorId: vendorInfo.vendor_id,
-          orderId: vendorInfo.order_id,
-          status: vendorInfo.status,
-          commissionAmount: vendorInfo.commissionAmount,
-        })) as VendorFulfillmentResult[];
-      }
+      const commissionData = checkoutSession.vendor_info?.map((vendorInfo: any) => ({
+        vendorId: vendorInfo.vendor_id,
+        orderId: vendorInfo.order_id,
+        status: vendorInfo.status,
+        commissionAmount: vendorInfo.commissionAmount,
+      })) as VendorFulfillmentResult[];
 
       const payoutPromises = commissionData
         .filter((result) => result.status !== 'failed' && new BN(result.commissionAmount).gt(new BN('0')))
@@ -170,7 +154,7 @@ export class VendorFulfillmentService {
             amount: result.commissionAmount,
             currency_id: checkoutSession.currency_id,
             customer_id: checkoutSession.customer_id || '',
-            payment_intent_id: checkoutSession.payment_intent_id || '',
+            payment_intent_id: paymentIntentId,
             payment_method_id: paymentMethodId,
             status: paymentMethod?.type === 'stripe' ? 'deferred' : 'pending',
             attempt_count: 0,
@@ -187,12 +171,14 @@ export class VendorFulfillmentService {
       await Promise.all(payoutPromises);
 
       logger.info('Vendor payouts created', {
-        checkoutSessionId,
+        checkoutSessionId: checkoutSession.id,
+        paymentIntentId: paymentIntent.id,
         payoutCount: commissionData.filter((r) => r.status !== 'failed').length,
       });
     } catch (error: any) {
       logger.error('Failed to create vendor payouts', {
-        checkoutSessionId,
+        checkoutSessionId: checkoutSession.id,
+        paymentIntentId: paymentIntent.id,
         error: error.message,
       });
       throw error;

package/api/src/queues/checkout-session.ts

@@ -21,6 +21,7 @@ import {
   SubscriptionItem,
 } from '../store/models';
 import { getCheckoutSessionSubscriptionIds } from '../libs/session';
+import { rollbackDiscountUsageForCheckoutSession } from '../libs/discount/discount';
 
 type CheckoutSessionJob = {
   id: string;
@@ -240,6 +241,8 @@ events.on('checkout.session.expired', async (checkoutSession: CheckoutSession) =
     );
   }
 
+  await rollbackDiscountUsageForCheckoutSession(checkoutSession.id);
+
   // update price lock status
   for (const item of checkoutSession.line_items) {
     const price = await Price.findByPk(item.price_id);

package/api/src/queues/payment.ts

@@ -914,6 +914,11 @@ export const handlePayment = async (job: PaymentJob) => {
       return;
     }
 
+    if (paymentIntent.amount === '0') {
+      await handlePaymentSucceed(paymentIntent);
+      return;
+    }
+
     await paymentIntent.update({ status: 'processing', last_payment_error: null });
 
     if (paymentMethod.type === 'arcblock') {

package/api/src/queues/vendors/commission.ts

@@ -1,29 +1,26 @@
 import { events } from '../../libs/event';
 import logger from '../../libs/logger';
 import createQueue from '../../libs/queue';
+import { Invoice } from '../../store/models';
 import { CheckoutSession } from '../../store/models/checkout-session';
 import { PaymentIntent } from '../../store/models/payment-intent';
-import { Product } from '../../store/models/product';
 import { Price } from '../../store/models/price';
+import { Product } from '../../store/models/product';
 import { depositVaultQueue } from '../payment';
 import { startVendorFulfillment, triggerCommissionProcess, triggerCoordinatorCheck } from './fulfillment-coordinator';
 
 type VendorCommissionJob = {
-  paymentIntentId: string;
+  invoiceId: string;
   retryOnError?: boolean;
 };
 
-async function checkIfPaymentIntentHasVendors(
-  paymentIntent: PaymentIntent,
-  checkoutSession: CheckoutSession
-): Promise<boolean> {
+async function checkIfPaymentIntentHasVendors(checkoutSession: CheckoutSession): Promise<boolean> {
   try {
     // Extract price_ids from line_items, then find corresponding product_ids
     const priceIds = checkoutSession.line_items.map((item: any) => item.price_id).filter(Boolean);
 
     if (priceIds.length === 0) {
       logger.warn('No price IDs found in checkout session line items', {
-        paymentIntentId: paymentIntent.id,
         checkoutSessionId: checkoutSession.id,
       });
       return false;
@@ -39,7 +36,6 @@ async function checkIfPaymentIntentHasVendors(
 
     if (productIds.length === 0) {
       logger.warn('No product IDs found from prices', {
-        paymentIntentId: paymentIntent.id,
         checkoutSessionId: checkoutSession.id,
         priceIds,
       });
@@ -57,28 +53,28 @@ async function checkIfPaymentIntentHasVendors(
     return hasVendorConfig;
   } catch (error: any) {
     logger.error('Failed to check vendor configuration', {
-      paymentIntentId: paymentIntent.id,
       error,
     });
     return false;
   }
 }
 
-async function executeDirectDepositVault(paymentIntent: PaymentIntent): Promise<void> {
-  const exist = await depositVaultQueue.get(`deposit-vault-${paymentIntent.currency_id}`);
+async function executeDirectDepositVault(invoice: Invoice): Promise<void> {
+  const currencyId = invoice.currency_id;
+  const exist = await depositVaultQueue.get(`deposit-vault-${currencyId}`);
   if (!exist) {
     depositVaultQueue.push({
-      id: `deposit-vault-${paymentIntent.currency_id}`,
-      job: { currencyId: paymentIntent.currency_id },
+      id: `deposit-vault-${currencyId}`,
+      job: { currencyId },
     });
     logger.info('Deposit vault job queued', {
-      paymentIntentId: paymentIntent.id,
-      currencyId: paymentIntent.currency_id,
+      paymentIntentId: invoice.payment_intent_id,
+      currencyId,
     });
   } else {
     logger.info('Deposit vault job already exists', {
-      paymentIntentId: paymentIntent.id,
-      currencyId: paymentIntent.currency_id,
+      paymentIntentId: invoice.payment_intent_id,
+      currencyId,
     });
   }
 }
@@ -88,53 +84,53 @@ export const handleVendorCommission = async (job: VendorCommissionJob) => {
 
   let checkoutSession: CheckoutSession | null = null;
   try {
-    const paymentIntent = await PaymentIntent.findByPk(job.paymentIntentId);
-    if (!paymentIntent) {
-      logger.warn('PaymentIntent not found', { id: job.paymentIntentId });
+    const invoice = await Invoice.findByPk(job.invoiceId);
+    if (!invoice) {
+      logger.warn('invoice not found', { id: job.invoiceId });
       return;
     }
 
     // Find CheckoutSession through PaymentIntent
-    checkoutSession = await CheckoutSession.findByPaymentIntentId(paymentIntent.id);
+    checkoutSession = await CheckoutSession.findByInvoiceId(invoice.id);
     if (!checkoutSession) {
-      await executeDirectDepositVault(paymentIntent);
+      await executeDirectDepositVault(invoice);
       return;
     }
 
-    const hasVendorConfig = await checkIfPaymentIntentHasVendors(paymentIntent, checkoutSession);
+    const hasVendorConfig = await checkIfPaymentIntentHasVendors(checkoutSession);
     if (!hasVendorConfig) {
-      await executeDirectDepositVault(paymentIntent);
+      await executeDirectDepositVault(invoice);
       return;
     }
 
     logger.info('Vendor configuration found, starting fulfillment process', {
-      paymentIntentId: paymentIntent.id,
+      invoiceId: invoice.id,
     });
 
     if (checkoutSession.fulfillment_status === 'completed') {
       logger.info('CheckoutSession already completed, directly trigger commission process', {
         checkoutSessionId: checkoutSession.id,
       });
-      await triggerCommissionProcess(checkoutSession.id, paymentIntent.id);
+      await triggerCommissionProcess(checkoutSession.id, invoice.id);
       return;
     }
 
-    await startVendorFulfillment(checkoutSession.id, paymentIntent.id);
+    await startVendorFulfillment(checkoutSession.id, invoice.id);
   } catch (error: any) {
     logger.error('Vendor commission decision failed, fallback to direct deposit vault', {
-      paymentIntentId: job.paymentIntentId,
+      invoiceId: job.invoiceId,
       error,
     });
 
     if (!checkoutSession) {
       logger.error('CheckoutSession not found via any method[handleVendorCommission]', {
-        paymentIntentId: job.paymentIntentId,
+        invoiceId: job.invoiceId,
       });
       return;
     }
 
     try {
-      triggerCoordinatorCheck(checkoutSession.id, job.paymentIntentId, 'vendor_commission_decision_failed');
+      triggerCoordinatorCheck(checkoutSession.id, job.invoiceId, 'vendor_commission_decision_failed');
     } catch (err: any) {
       logger.error('Failed to trigger coordinator check[handleVendorCommission]', { error: err });
     }
@@ -160,23 +156,17 @@ export const startVendorCommissionQueue = async () => {
   });
 
   payments.forEach(async (x) => {
-    const exist = await vendorCommissionQueue.get(`vendor-commission-${x.id}`);
-    if (!exist) {
-      vendorCommissionQueue.push({ id: x.id, job: { paymentIntentId: x.id, retryOnError: true } });
+    const id = `vendor-commission-${x.invoice_id}`;
+    const exist = await vendorCommissionQueue.get(id);
+    if (!exist && x.invoice_id) {
+      vendorCommissionQueue.push({ id, job: { invoiceId: x.invoice_id, retryOnError: true } });
     }
   });
 };
 
 events.on('invoice.paid', async (invoice) => {
   try {
-    const paymentIntent = await PaymentIntent.findOne({ where: { invoice_id: invoice.id } });
-
-    if (!paymentIntent) {
-      logger.warn('PaymentIntent not found', { id: invoice.id });
-      return;
-    }
-
-    const id = `vendor-commission-${paymentIntent.id}`;
+    const id = `vendor-commission-${invoice.id}`;
     const exist = await vendorCommissionQueue.get(id);
     if (exist) {
       logger.info('Vendor commission job already exists, skipping', { id });
@@ -185,7 +175,7 @@ events.on('invoice.paid', async (invoice) => {
 
     vendorCommissionQueue.push({
       id,
-      job: { paymentIntentId: paymentIntent.id, retryOnError: true },
+      job: { invoiceId: invoice.id, retryOnError: true },
     });
   } catch (error) {
     logger.error('Failed to trigger vendor commission queue', { invoiceId: invoice.id, error });