payment-kit 1.20.5 → 1.20.7

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

@@ -0,0 +1,317 @@
+import { BN } from '@ocap/util';
+import { CheckoutSession } from '../../store/models/checkout-session';
+import { Product } from '../../store/models/product';
+import { ProductVendor } from '../../store/models/product-vendor';
+import { Payout } from '../../store/models/payout';
+import { PaymentIntent } from '../../store/models/payment-intent';
+import { Price } from '../../store/models/price';
+import { calculateVendorCommission, VendorAdapterFactory } from './adapters/factory';
+import { Customer } from '../../store/models';
+import logger from '../logger';
+
+export interface VendorFulfillmentResult {
+  vendorId: string;
+  vendorKey: string;
+  orderId: string;
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  commissionAmount: string;
+  commissionType: 'percentage' | 'fixed_amount';
+  commissionRate: number;
+  productId?: string; // Add product ID for multi-product tracking
+  errorMessage?: string;
+  serviceUrl?: string;
+  estimatedTime?: number;
+  vendorOrderId?: string;
+  progress?: number;
+  orderDetails?: any;
+  installationInfo?: any;
+}
+
+export interface MultiVendorFulfillmentResult {
+  checkoutSessionId: string;
+  success: boolean;
+  results: VendorFulfillmentResult[];
+  totalCommissionAmount: string;
+  errorMessage?: string;
+}
+
+export class VendorFulfillmentService {
+  // Execute single vendor fulfillment (public interface for coordinator system)
+  static async fulfillSingleVendorOrder(
+    orderInfo: {
+      checkoutSessionId: string;
+      amount_total: string;
+      customer_id: string;
+      payment_intent_id: string | null;
+      currency_id: string;
+      customer_did: string;
+    },
+    vendorConfig: any
+  ): Promise<VendorFulfillmentResult> {
+    try {
+      const vendor = await ProductVendor.findByPk(vendorConfig.vendor_id);
+
+      if (!vendor) {
+        throw new Error(`Vendor not found: ${vendorConfig.vendor_id}`);
+      }
+
+      const adapter = this.getVendorAdapter(vendor.vendor_key);
+
+      // Calculate commission amount
+      const commissionRate = vendorConfig.commission_rate || vendor.default_commission_rate;
+      const commissionType = vendorConfig.commission_type || vendor.default_commission_type;
+      const commissionAmount = calculateVendorCommission(
+        orderInfo.amount_total,
+        commissionRate,
+        commissionType,
+        vendorConfig.amount
+      );
+
+      const userEmail = (await Customer.findByPk(orderInfo.customer_id))?.email || '';
+
+      const fulfillmentResult = await adapter.fulfillOrder({
+        checkoutSessionId: orderInfo.checkoutSessionId,
+        productCode: vendorConfig.vendor_id,
+        customerId: orderInfo.customer_id || '',
+        quantity: 1,
+        paymentIntentId: orderInfo.payment_intent_id || '',
+        amount: orderInfo.amount_total,
+        currency: orderInfo.currency_id,
+
+        description: 'This is build a instance for Third Party',
+        userInfo: {
+          userDid: orderInfo.customer_did!,
+          email: userEmail,
+          description: 'This is build a instance for Third Party',
+        },
+        deliveryParams: {
+          blockletMetaUrl: vendor.metadata?.blockletMetaUrl,
+          customParams: vendorConfig.custom_params,
+        },
+      });
+
+      logger.info('Single vendor fulfillment completed', {
+        vendorId: vendorConfig.vendor_id,
+        orderId: fulfillmentResult.orderId,
+        status: fulfillmentResult.status,
+        commissionAmount,
+      });
+
+      return {
+        vendorId: vendorConfig.vendor_id,
+        vendorKey: vendorConfig.vendor_id,
+        orderId: fulfillmentResult.orderId,
+        status: fulfillmentResult.status,
+        commissionAmount,
+        commissionType,
+        commissionRate,
+        errorMessage: fulfillmentResult.message,
+        serviceUrl: fulfillmentResult.serviceUrl,
+        estimatedTime: fulfillmentResult.estimatedTime,
+        vendorOrderId: fulfillmentResult.vendorOrderId,
+        progress: fulfillmentResult.progress,
+        orderDetails: fulfillmentResult.orderDetails,
+        installationInfo: fulfillmentResult.installationInfo,
+      };
+    } catch (error: any) {
+      logger.error('Single vendor fulfillment failed', {
+        vendorId: vendorConfig.vendor_id,
+        error: error.message,
+      });
+
+      throw error;
+    }
+  }
+
+  // Calculate commission data (no fulfillment, only calculate commission)
+  private static async calculateCommissionData(checkoutSessionId: string): Promise<VendorFulfillmentResult[]> {
+    try {
+      logger.info('Calculating commission data for checkout session', { checkoutSessionId });
+
+      const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
+      if (!checkoutSession) {
+        throw new Error(`CheckoutSession not found: ${checkoutSessionId}`);
+      }
+
+      const priceIds = checkoutSession.line_items.map((item: any) => item.price_id).filter(Boolean);
+
+      if (priceIds.length === 0) {
+        throw new Error(`No price IDs found in checkout session line items: ${checkoutSessionId}`);
+      }
+
+      // Find corresponding product_ids through price_ids
+      const prices = await Price.findAll({
+        where: { id: priceIds },
+        attributes: ['id', 'product_id'],
+      });
+
+      // Create a map of price_id to line_item for amount calculation
+      const priceToLineItemMap = new Map();
+      checkoutSession.line_items.forEach((item: any) => {
+        if (item.price_id) {
+          priceToLineItemMap.set(item.price_id, item);
+        }
+      });
+
+      const productIds = prices.map((price: any) => price.product_id).filter(Boolean);
+
+      if (productIds.length === 0) {
+        throw new Error(`No product IDs found from prices: ${checkoutSessionId}`);
+      }
+
+      // Get all products with vendor configurations
+      const products = await Product.findAll({
+        where: { id: productIds },
+        attributes: ['id', 'vendor_config'],
+      });
+
+      const commissionResults: VendorFulfillmentResult[] = [];
+
+      // Process each product separately
+      for (const product of products) {
+        if (!product.vendor_config || product.vendor_config.length === 0) {
+          logger.debug('No vendor configuration found for product', {
+            productId: product.id,
+            checkoutSessionId,
+          });
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        // Find all prices for this product
+        const productPrices = prices.filter((price: any) => price.product_id === product.id);
+
+        // Calculate total amount for this product across all line items
+        let productTotalAmount = '0';
+        for (const price of productPrices) {
+          const lineItem = priceToLineItemMap.get(price.id);
+          if (lineItem && lineItem.amount_total) {
+            productTotalAmount = new BN(productTotalAmount).add(new BN(lineItem.amount_total || '0')).toString();
+          }
+        }
+
+        // Calculate commission for each vendor of this product
+        for (const vendorConfig of product.vendor_config) {
+          const commissionAmount = calculateVendorCommission(
+            productTotalAmount, // Use product-specific amount instead of total order amount
+            vendorConfig.commission_rate || 0,
+            vendorConfig.commission_type || 'percentage',
+            vendorConfig.amount
+          );
+
+          commissionResults.push({
+            vendorId: vendorConfig.vendor_key || vendorConfig.vendor_id,
+            vendorKey: vendorConfig.vendor_key || vendorConfig.vendor_id,
+            orderId: `commission_${checkoutSessionId}_${product.id}_${vendorConfig.vendor_id}`,
+            status: 'completed',
+            commissionAmount,
+            commissionType: vendorConfig.commission_type || 'percentage',
+            commissionRate: vendorConfig.commission_rate || 0,
+            productId: product.id, // Add product ID for tracking
+          });
+        }
+      }
+
+      if (commissionResults.length === 0) {
+        logger.warn('No vendor configurations found for any products', {
+          productIds,
+          checkoutSessionId,
+        });
+      }
+
+      logger.info('Commission data calculated', {
+        checkoutSessionId,
+        commissionCount: commissionResults.length,
+      });
+
+      return commissionResults;
+    } catch (error: any) {
+      logger.error('Failed to calculate commission data', {
+        checkoutSessionId,
+        error: error.message,
+      });
+      throw error;
+    }
+  }
+
+  static async createVendorPayouts(
+    checkoutSessionId: string,
+    fulfillmentResults?: VendorFulfillmentResult[]
+  ): 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;
+        }
+      }
+
+      // If fulfillmentResults not provided, calculate commission info
+      let commissionData = fulfillmentResults;
+      if (!commissionData) {
+        commissionData = await this.calculateCommissionData(checkoutSessionId);
+      }
+
+      const payoutPromises = commissionData
+        .filter((result) => result.status !== 'failed' && new BN(result.commissionAmount).gt(new BN('0')))
+        .map(async (result) => {
+          const vendor = await ProductVendor.findByPk(result.vendorId);
+
+          const appPid = vendor?.app_pid;
+          const destination = appPid || vendor?.metadata?.wallet_address || vendor?.metadata?.destination || '';
+
+          await Payout.create({
+            livemode: checkoutSession.livemode,
+            automatic: true,
+            description: `Vendor commission for ${result.vendorId}${appPid ? ` (${appPid})` : ''}`,
+            destination,
+            amount: result.commissionAmount,
+            currency_id: checkoutSession.currency_id,
+            customer_id: checkoutSession.customer_id || '',
+            payment_intent_id: checkoutSession.payment_intent_id || '',
+            payment_method_id: paymentMethodId,
+            status: 'pending',
+            attempt_count: 0,
+            attempted: false,
+            vendor_info: {
+              vendor_id: result.vendorId,
+              app_pid: appPid,
+              order_id: result.orderId,
+              commission_amount: result.commissionAmount,
+            },
+          });
+        });
+
+      await Promise.all(payoutPromises);
+
+      logger.info('Vendor payouts created', {
+        checkoutSessionId,
+        payoutCount: commissionData.filter((r) => r.status !== 'failed').length,
+      });
+    } catch (error: any) {
+      logger.error('Failed to create vendor payouts', {
+        checkoutSessionId,
+        error: error.message,
+      });
+      throw error;
+    }
+  }
+
+  static getVendorAdapter(vendorKey: string) {
+    try {
+      return VendorAdapterFactory.create(vendorKey);
+    } catch (error: any) {
+      logger.error('Failed to get vendor adapter', {
+        vendorKey,
+        error: error.message,
+      });
+      throw error;
+    }
+  }
+}

package/api/src/queues/payment.ts

@@ -26,11 +26,13 @@ import { MAX_RETRY_COUNT, MIN_RETRY_MAIL, getNextRetry } from '../libs/util';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
+
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { PaymentIntent } from '../store/models/payment-intent';
 import { PaymentMethod } from '../store/models/payment-method';
 import { Payout } from '../store/models/payout';
 import { Price } from '../store/models/price';
+
 import { Subscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
 import type { EVMChainType, PaymentError, PaymentSettings } from '../store/models/types';
@@ -371,13 +373,11 @@ export const handlePaymentSucceed = async (
       );
   }
 
-  const exist = await depositVaultQueue.get(`deposit-vault-${paymentIntent.currency_id}`);
-  if (!exist) {
-    depositVaultQueue.push({
-      id: `deposit-vault-${paymentIntent.currency_id}`,
-      job: { currencyId: paymentIntent.currency_id },
-    });
-  }
+  // Trigger vendor commission queue
+  events.emit('vendor.commission.queued', `vendor-commission-${paymentIntent.id}`, {
+    paymentIntentId: paymentIntent.id,
+    retryOnError: true,
+  });
 
   let invoice;
   if (paymentIntent.invoice_id) {
@@ -929,19 +929,21 @@ export const handlePayment = async (job: PaymentJob) => {
 
       const payer = paymentSettings?.payment_method_options.arcblock?.payer as string;
 
-      // check balance before capture with transaction
       result = await isDelegationSufficientForPayment({
         paymentMethod,
         paymentCurrency,
         userDid: payer || customer.did,
         amount: paymentIntent.amount,
       });
+
       if (result.sufficient === false) {
-        logger.error('PaymentIntent capture aborted on preCheck', { id: paymentIntent.id, result });
+        logger.error('PaymentIntent capture aborted on preCheck', {
+          id: paymentIntent.id,
+          result,
+        });
         throw new CustomError(result.reason, 'payer balance or delegation not sufficient for this payment');
       }
 
-      // do the capture
       const signed = await client.signTransferV2Tx({
         tx: {
           itx: {
@@ -963,8 +965,10 @@ export const handlePayment = async (job: PaymentJob) => {
         wallet,
         delegator: result.delegator,
       });
+
       // @ts-ignore
       const { buffer } = await client.encodeTransferV2Tx({ tx: signed });
+
       const txHash = await client.sendTransferV2Tx(
         // @ts-ignore
         { tx: signed, wallet, delegator: result.delegator },

package/api/src/queues/payout.ts

@@ -78,6 +78,7 @@ async function processArcblockPayout(payout: Payout, paymentMethod: PaymentMetho
     },
     wallet,
   });
+
   // @ts-ignore
   const { buffer } = await client.encodeTransferV2Tx({ tx: signed });
   // @ts-ignore

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

@@ -0,0 +1,192 @@
+import { events } from '../../libs/event';
+import logger from '../../libs/logger';
+import createQueue from '../../libs/queue';
+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 { depositVaultQueue } from '../payment';
+import { startVendorFulfillment, triggerCommissionProcess, triggerCoordinatorCheck } from './fulfillment-coordinator';
+
+type VendorCommissionJob = {
+  paymentIntentId: string;
+  retryOnError?: boolean;
+};
+
+async function checkIfPaymentIntentHasVendors(
+  paymentIntent: PaymentIntent,
+  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;
+    }
+
+    // Find corresponding product_ids through price_ids
+    const prices = await Price.findAll({
+      where: { id: priceIds },
+      attributes: ['id', 'product_id'],
+    });
+
+    const productIds = prices.map((price) => price.product_id).filter(Boolean);
+
+    if (productIds.length === 0) {
+      logger.warn('No product IDs found from prices', {
+        paymentIntentId: paymentIntent.id,
+        checkoutSessionId: checkoutSession.id,
+        priceIds,
+      });
+      return false;
+    }
+
+    // Get product information
+    const products = await Product.findAll({
+      where: { id: productIds },
+      attributes: ['id', 'vendor_config'],
+    });
+
+    // Check if any product has vendor configuration
+    const hasVendorConfig = products.some((product) => product.vendor_config && product.vendor_config.length > 0);
+    return hasVendorConfig;
+  } catch (error: any) {
+    logger.error('Failed to check vendor configuration', {
+      paymentIntentId: paymentIntent.id,
+      error: error.message,
+    });
+    return false;
+  }
+}
+
+async function executeDirectDepositVault(paymentIntent: PaymentIntent): Promise<void> {
+  const exist = await depositVaultQueue.get(`deposit-vault-${paymentIntent.currency_id}`);
+  if (!exist) {
+    depositVaultQueue.push({
+      id: `deposit-vault-${paymentIntent.currency_id}`,
+      job: { currencyId: paymentIntent.currency_id },
+    });
+    logger.info('Deposit vault job queued', {
+      paymentIntentId: paymentIntent.id,
+      currencyId: paymentIntent.currency_id,
+    });
+  } else {
+    logger.info('Deposit vault job already exists', {
+      paymentIntentId: paymentIntent.id,
+      currencyId: paymentIntent.currency_id,
+    });
+  }
+}
+
+export const handleVendorCommission = async (job: VendorCommissionJob) => {
+  logger.info('handle vendor commission', job);
+
+  let checkoutSession: CheckoutSession | null = null;
+  try {
+    const paymentIntent = await PaymentIntent.findByPk(job.paymentIntentId);
+    if (!paymentIntent) {
+      logger.warn('PaymentIntent not found', { id: job.paymentIntentId });
+      return;
+    }
+
+    // Find CheckoutSession through PaymentIntent
+    checkoutSession = await CheckoutSession.findByPaymentIntentId(paymentIntent.id);
+    if (!checkoutSession) {
+      await executeDirectDepositVault(paymentIntent);
+      return;
+    }
+
+    const hasVendorConfig = await checkIfPaymentIntentHasVendors(paymentIntent, checkoutSession);
+    if (!hasVendorConfig) {
+      await executeDirectDepositVault(paymentIntent);
+      return;
+    }
+
+    logger.info('Vendor configuration found, starting fulfillment process', {
+      paymentIntentId: paymentIntent.id,
+    });
+
+    if (checkoutSession.fulfillment_status === 'completed') {
+      logger.info('CheckoutSession already completed, directly trigger commission process', {
+        checkoutSessionId: checkoutSession.id,
+      });
+      await triggerCommissionProcess(checkoutSession.id, paymentIntent.id);
+      return;
+    }
+
+    await startVendorFulfillment(checkoutSession.id, paymentIntent.id);
+  } catch (error: any) {
+    logger.error('Vendor commission decision failed, fallback to direct deposit vault', {
+      paymentIntentId: job.paymentIntentId,
+      error: error.message,
+      stack: error.stack,
+    });
+
+    if (!checkoutSession) {
+      logger.error('CheckoutSession not found via any method[handleVendorCommission]', {
+        paymentIntentId: job.paymentIntentId,
+      });
+      return;
+    }
+
+    try {
+      triggerCoordinatorCheck(checkoutSession.id, job.paymentIntentId, 'vendor_commission_decision_failed');
+    } catch (err: any) {
+      logger.error('Failed to trigger coordinator check[handleVendorCommission]', { error: err.message });
+    }
+  }
+};
+
+export const vendorCommissionQueue = createQueue<VendorCommissionJob>({
+  name: 'vendor-commission',
+  onJob: handleVendorCommission,
+  options: {
+    concurrency: 3,
+    maxRetries: 3,
+    enableScheduledJob: true,
+  },
+});
+
+export const startVendorCommissionQueue = async () => {
+  const payments = await PaymentIntent.findAll({
+    where: {
+      status: ['requires_capture', 'processing'],
+      capture_method: 'automatic',
+    },
+  });
+
+  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 } });
+    }
+  });
+};
+
+events.on('vendor.commission.queued', async (id, job, args = {}) => {
+  try {
+    const { ...extraArgs } = args;
+    const exist = await vendorCommissionQueue.get(id);
+
+    if (!exist) {
+      logger.info('Vendor commission job added successfully', { id });
+      vendorCommissionQueue.push({
+        id,
+        job,
+        ...extraArgs,
+      });
+    } else {
+      logger.info('Vendor commission job already exists, skipping', { id });
+    }
+  } catch (error: any) {
+    logger.error('Failed to handle vendor commission queue event', {
+      id,
+      error: error.message,
+    });
+  }
+});