payment-kit 1.18.30 → 1.18.32

package/api/src/routes/connect/shared.ts

@@ -7,23 +7,30 @@ import { BN, fromTokenToUnit, toBase58 } from '@ocap/util';
 import { fromPublicKey } from '@ocap/wallet';
 import type { Request } from 'express';
 import { isEmpty } from 'lodash';
-
+import dayjs from '../../libs/dayjs';
 import { estimateMaxGasForTx, hasStakedForGas } from '../../integrations/arcblock/stake';
 import { encodeApproveItx } from '../../integrations/ethereum/token';
 import { blocklet, ethWallet, wallet } from '../../libs/auth';
 import logger from '../../libs/logger';
 import { getGasPayerExtra, getTokenLimitsForDelegation } from '../../libs/payment';
-import { getFastCheckoutAmount, getStatementDescriptor, isDonationCheckoutSession } from '../../libs/session';
+import { 
+  getCheckoutAmount, 
+  getCheckoutSessionSubscriptionIds, 
+  getFastCheckoutAmount, 
+  getStatementDescriptor, 
+  getSubscriptionCreateSetup, 
+  isDonationCheckoutSession,
+  getSubscriptionLineItems
+} from '../../libs/session';
 import {
   expandSubscriptionItems,
-  getSubscriptionCreateSetup,
   getSubscriptionPaymentAddress,
   getSubscriptionStakeSetup,
 } from '../../libs/subscription';
 import { getCustomerStakeAddress, OCAP_PAYMENT_TX_TYPE } from '../../libs/util';
 
 import { invoiceQueue } from '../../queues/invoice';
-import type { TLineItemExpanded } from '../../store/models';
+import { type TLineItemExpanded } from '../../store/models';
 import { CheckoutSession } from '../../store/models/checkout-session';
 import { Customer } from '../../store/models/customer';
 import { Invoice, TInvoice } from '../../store/models/invoice';
@@ -42,6 +49,7 @@ type Result = {
   customer: Customer;
   paymentIntent?: PaymentIntent;
   subscription?: Subscription;
+  subscriptions?: Subscription[];
   paymentCurrency: PaymentCurrency;
   paymentMethod: PaymentMethod;
   invoice?: Invoice;
@@ -85,20 +93,32 @@ export async function ensurePaymentIntent(checkoutSessionId: string, userDid?: s
     paymentMethodId = paymentIntent.payment_method_id;
   }
 
-  let subscription;
-  if (checkoutSession.subscription_id) {
-    subscription = await Subscription.findByPk(checkoutSession.subscription_id);
-    if (!subscription) {
-      throw new Error('Subscription not found');
+  const subscriptionIds = getCheckoutSessionSubscriptionIds(checkoutSession);
+
+  let subscriptions: Subscription[] = [];
+  let primarySubscription: Subscription | null = null;
+  if (subscriptionIds.length > 0) {
+    // @ts-ignore
+    subscriptions = await Promise.all(
+      subscriptionIds.filter(Boolean) 
+        .map(id => Subscription.findByPk(id))
+    );
+    
+    subscriptions = subscriptions.filter(Boolean);
+    for (const subscription of subscriptions) {
+      if (subscription && subscription.status !== 'incomplete') {
+        throw new Error(`Subscription ${subscription.id} is not in incomplete status: ${subscription.status}`);
+      }
     }
-    if (subscription.status !== 'incomplete') {
-      throw new Error('Subscription is not in incomplete status');
+    if (subscriptions.length > 0) {
+      // @ts-ignore
+      primarySubscription = subscriptions.find((sub) => sub.metadata?.is_primary_subscription) || subscriptions[0];
+      paymentCurrencyId = primarySubscription?.currency_id;
+      paymentMethodId = primarySubscription?.default_payment_method_id;
     }
-
-    paymentCurrencyId = subscription.currency_id;
-    paymentMethodId = subscription.default_payment_method_id;
   }
   let customer = null;
+  
   if (!skipCustomer) {
   // 检查是否为打赏场景
   const isDonation = isDonationCheckoutSession(checkoutSession);  
@@ -195,7 +215,8 @@ export async function ensurePaymentIntent(checkoutSessionId: string, userDid?: s
     checkoutSession,
     paymentIntent,
     customer: customer as Customer,
-    subscription,
+    subscription: primarySubscription as Subscription,
+    subscriptions,
     paymentMethod,
     paymentCurrency,
   };
@@ -345,6 +366,8 @@ type Args = {
   paymentIntent?: PaymentIntent;
   subscription?: Subscription;
   props?: Partial<TInvoice>;
+  subscriptions?: Subscription[];
+  lineItems?: TLineItemExpanded[];
 };
 
 export async function ensureInvoiceForCheckout({
@@ -353,27 +376,32 @@ export async function ensureInvoiceForCheckout({
   paymentIntent,
   subscription,
   props,
+  subscriptions,
+  lineItems,
 }: Args): Promise<{ invoice: Invoice | null; items: InvoiceItem[] }> {
+
+  const isGroupInvoice = subscriptions && subscriptions.length > 1;
   // invoices are optional when checkout session is in payment mode
   if (checkoutSession.mode === 'payment' && !checkoutSession.invoice_creation?.enabled) {
     logger.warn('Invoice creation disabled for payment mode');
     return { invoice: null, items: [] };
   }
 
+  const existingInvoice = checkoutSession.invoice_id || (isGroupInvoice && subscription?.latest_invoice_id);
   // Do not create invoice if it's already created
-  if (checkoutSession.invoice_id) {
-    logger.info(`Invoice already created for checkout session ${checkoutSession.id}: ${checkoutSession.invoice_id}`);
-    const invoice = await Invoice.findByPk(checkoutSession.invoice_id);
+  if (existingInvoice) {
+    logger.info(`Invoice already created for checkout session ${checkoutSession.id}: ${existingInvoice}`);
+    const invoice = await Invoice.findByPk(existingInvoice);
     if (invoice) {
       if (invoice.status === 'paid') {
-        logger.info(`Invoice already paid for checkout session ${checkoutSession.id}: ${checkoutSession.invoice_id}`);
+        logger.info(`Invoice already paid for checkout session ${checkoutSession.id}: ${existingInvoice}`);
         throw new Error('Invoice already paid');
       }
 
       // invoice currency is aligned
       if (invoice.currency_id === checkoutSession.currency_id) {
         await invoice.update({ status: 'open' });
-        logger.info(`Invoice status reset for checkout session ${checkoutSession.id}: ${checkoutSession.invoice_id}`);
+        logger.info(`Invoice status reset for checkout session ${checkoutSession.id}: ${existingInvoice}`);
 
         if (invoice.payment_intent_id) {
           await PaymentIntent.update({ status: 'requires_capture' }, { where: { id: invoice.payment_intent_id } });
@@ -384,13 +412,13 @@ export async function ensureInvoiceForCheckout({
 
         return {
           invoice,
-          items: await InvoiceItem.findAll({ where: { invoice_id: checkoutSession.invoice_id } }),
+          items: await InvoiceItem.findAll({ where: { invoice_id: existingInvoice } }),
         };
       }
 
       // invalid currency not aligned: we should generate new invoice
       await invoice.update({ status: 'void' });
-      logger.info(`Invoice marked void for checkout session ${checkoutSession.id}: ${checkoutSession.invoice_id}`);
+      logger.info(`Invoice marked void for checkout session ${checkoutSession.id}: ${existingInvoice}`);
       const method = await PaymentMethod.findByPk(invoice.default_payment_method_id);
       if (method?.type === 'stripe' && invoice.metadata?.stripe_id) {
         const client = method.getStripeClient();
@@ -398,12 +426,12 @@ export async function ensureInvoiceForCheckout({
           .voidInvoice(invoice.metadata.stripe_id)
           .then(() => {
             logger.info(
-              `Invoice marked void on stripe for checkout session ${checkoutSession.id}: ${checkoutSession.invoice_id}`
+              `Invoice marked void on stripe for checkout session ${checkoutSession.id}: ${existingInvoice}`
             );
           })
           .catch((err) => {
             logger.error(
-              `Invoice marked void on stripe failed for checkout session ${checkoutSession.id}: ${checkoutSession.invoice_id}`,
+              `Invoice marked void on stripe failed for checkout session ${checkoutSession.id}: ${existingInvoice}`,
               err
             );
           });
@@ -412,11 +440,26 @@ export async function ensureInvoiceForCheckout({
   }
 
   const currency = await PaymentCurrency.findByPk(checkoutSession.currency_id);
+  
+  const metadata = {
+    ...(checkoutSession.invoice_creation?.invoice_data?.metadata || {}),
+  };
+  
+  if (isGroupInvoice) {
+    metadata.subscription_ids = subscriptions.map(sub => sub.id);
+    metadata.is_group_invoice = true;
+  }
+  
+  const trialInDays = Number(checkoutSession.subscription_data?.trial_period_days || 0);
+  const trialEnd = Number(checkoutSession.subscription_data?.trial_end || 0);
+  const now = dayjs().unix();
+  const invoiceItems = lineItems || (await Price.expand(checkoutSession.line_items, { product: true }));
+  const totalAmount = getCheckoutAmount(invoiceItems, checkoutSession.currency_id, trialInDays > 0 || trialEnd > now);
   const { invoice, items } = await ensureInvoiceAndItems({
     customer,
     currency: currency as PaymentCurrency,
     subscription,
-    lineItems: await Price.expand(checkoutSession.line_items, { product: true }),
+    lineItems: invoiceItems,
     trialing: !!checkoutSession.subscription_data?.trial_period_days,
     metered: false,
     props: {
@@ -436,21 +479,23 @@ export async function ensureInvoiceForCheckout({
       payment_intent_id: paymentIntent?.id,
       checkout_session_id: checkoutSession.id,
 
-      total: checkoutSession.amount_subtotal,
+      total: totalAmount.subtotal,
 
       default_payment_method_id: (subscription?.default_payment_method_id ||
         paymentIntent?.payment_method_id) as string,
 
       custom_fields: checkoutSession.invoice_creation?.invoice_data?.custom_fields || [],
       footer: checkoutSession.invoice_creation?.invoice_data?.footer || '',
-      metadata: checkoutSession.invoice_creation?.invoice_data?.metadata || {},
+      metadata,
       ...(props || {}),
     } as Invoice,
   });
   logger.info('Invoice created for checkoutSession', { checkoutSessionId: checkoutSession.id, invoiceId: invoice.id });
 
-  // persist invoice id
-  await checkoutSession.update({ invoice_id: invoice.id });
+  // only update invoice_id for single invoice
+  if (!isGroupInvoice) {
+    await checkoutSession.update({ invoice_id: invoice.id });
+  }
   if (paymentIntent) {
     await paymentIntent.update({ invoice_id: invoice.id });
   }
@@ -461,6 +506,46 @@ export async function ensureInvoiceForCheckout({
   return { invoice, items };
 }
 
+
+export async function ensureInvoicesForSubscriptions({
+  checkoutSession,
+  customer,
+  subscriptions,
+}: Omit<Args, 'subscription'> & { subscriptions: Subscription[] }): Promise<{ 
+  invoices: Invoice[]; 
+}> {
+  if (!subscriptions?.length) {
+    logger.warn('No subscriptions provided for invoice creation');
+    return { invoices: [] };
+  }
+
+  const lineItems = await Price.expand(checkoutSession.line_items, { product: true });
+
+  const primarySubscription = (subscriptions.find((x) => x.metadata.is_primary_subscription) || subscriptions[0]) as Subscription;
+  const invoices = await Promise.all(
+    subscriptions.map(async (subscription) => {
+      const subItems = await getSubscriptionLineItems(subscription, lineItems, primarySubscription);
+      const { invoice } = await ensureInvoiceForCheckout({ 
+        checkoutSession, 
+        customer, 
+        subscription, 
+        subscriptions, 
+        lineItems: subItems 
+      });
+      return invoice;
+    })
+  );
+
+  const createdInvoices = invoices.filter(Boolean);
+  
+  logger.info(`Created ${createdInvoices.length} invoices for subscriptions`, {
+    checkoutSessionId: checkoutSession.id,
+    invoiceIds: createdInvoices.map(inv => inv?.id)
+  });
+
+  return { invoices: createdInvoices as Invoice[] };
+}
+
 export async function ensureInvoiceForCollect(invoiceId: string) {
   const invoice = await Invoice.findByPk(invoiceId);
   if (!invoice) {
@@ -701,10 +786,11 @@ export async function getDelegationTxClaim({
 export async function getStakeTxClaim({
   userDid,
   userPk,
-  items,
   subscription,
+  items,
   paymentCurrency,
   paymentMethod,
+  subscriptions,
 }: {
   userDid: string;
   userPk: string;
@@ -712,15 +798,33 @@ export async function getStakeTxClaim({
   items: TLineItemExpanded[];
   paymentCurrency: PaymentCurrency;
   paymentMethod: PaymentMethod;
+  subscriptions?: Subscription[];
 }) {
-  // create staking amount
-  const billingThreshold = Number(subscription.billing_thresholds?.amount_gte || 0);
-  const minStakeAmount = Number(subscription.billing_thresholds?.stake_gte || 0);
+  let billingThreshold = Number(subscription.billing_thresholds?.amount_gte || 0);
+  let minStakeAmount = Number(subscription.billing_thresholds?.stake_gte || 0);
+  
+  const hasGrouping = subscriptions && subscriptions.length > 1;
+  if (hasGrouping) {
+    const primarySubscription = subscriptions[0] as Subscription; 
+    // use the settings of the primary subscription, not the scattered staking
+    billingThreshold = Number(primarySubscription.billing_thresholds?.amount_gte || 0);
+    minStakeAmount = Number(primarySubscription.billing_thresholds?.stake_gte || 0);
+    
+    logger.info('Using primary subscription for staking', {
+      primarySubscriptionId: primarySubscription.id,
+      billingThreshold,
+      minStakeAmount,
+      allSubscriptionIds: subscriptions.map(s => s.id)
+    });
+  }
+  
   const threshold = fromTokenToUnit(Math.max(billingThreshold, minStakeAmount), paymentCurrency.decimal);
   const staking = getSubscriptionStakeSetup(items, paymentCurrency.id, threshold.toString());
   const amount = staking.licensed.add(staking.metered).toString();
+  
   logger.info('getStakeTxClaim', {
     subscriptionId: subscription.id,
+    allSubscriptions: subscriptions?.map(s => s.id) || [],
     billingThreshold,
     minStakeAmount,
     threshold: threshold.toString(),
@@ -731,7 +835,12 @@ export async function getStakeTxClaim({
   if (paymentMethod.type === 'arcblock') {
     // create staking data
     const client = paymentMethod.getOcapClient();
-    const address = await getCustomerStakeAddress(userDid, subscription.id);
+    
+    const stakeId = hasGrouping 
+      ? `stake-group-${subscription.id}` 
+      : subscription.id;
+      
+    const address = await getCustomerStakeAddress(userDid, stakeId);
     const { state } = await client.getStakeState({ address });
     const data = {
       type: 'json',
@@ -739,6 +848,10 @@ export async function getStakeTxClaim({
         {
           appId: wallet.address,
           subscriptionId: subscription.id,
+          ...(hasGrouping ? {
+            subscriptionGroup: true,
+            subscriptionIds: subscriptions.map(s => s.id)
+          } : {})
         },
         JSON.parse(state?.data?.value || '{}')
       ),
@@ -748,7 +861,9 @@ export async function getStakeTxClaim({
 
     return {
       type: 'StakeTx',
-      description: `Stake to complete subscription ${subscription.id}`,
+      description: hasGrouping
+        ? `Stake for ${subscriptions.length} subscriptions`
+        : `Stake for subscription ${subscription.id}`,
       partialTx: {
         from: userDid,
         pk: userPk,
@@ -757,8 +872,10 @@ export async function getStakeTxClaim({
           receiver: wallet.address,
           slashers: [wallet.address],
           revokeWaitingPeriod: setup.cycle.duration / 1000, // wait for at least 1 billing cycle
-          message: `Stake for subscription ${subscription.id}`,
-          nonce: subscription.id,
+          message: hasGrouping
+            ? `Stake for ${subscriptions.length} subscriptions`
+            : `Stake for subscription ${subscription.id}`,
+          nonce: stakeId,
           inputs: [],
           data,
         },
@@ -767,10 +884,15 @@ export async function getStakeTxClaim({
       requirement: {
         tokens: [{ address: paymentCurrency.contract as string, value: amount }],
       },
-      nonce: `stake-${subscription.id}`,
+      nonce: `stake-${stakeId}`,
       meta: {
         purpose: 'staking',
         address,
+        ...(hasGrouping ? {
+          subscriptionGroup: true,
+          primarySubscriptionId: subscription.id,
+          allSubscriptionIds: subscriptions.map(s => s.id)
+        } : {})
       },
       chainInfo: {
         host: paymentMethod.settings?.arcblock?.api_host as string,