payment-kit 1.15.15 → 1.15.17

package/api/src/integrations/stripe/resource.ts

@@ -44,7 +44,7 @@ export async function ensureStripeProduct(internal: Product, method: PaymentMeth
     attrs.unit_label = internal.unit_label;
   }
   if (internal.statement_descriptor) {
-    attrs.statement_descriptor_suffix = '';
+    attrs.statement_descriptor = '';
   }
 
   const product = await client.products.create(attrs);
@@ -176,7 +176,7 @@ export async function ensureStripePaymentIntent(
         enabled: true,
         allow_redirects: 'never',
       },
-      statement_descriptor_suffix: '',
+      statement_descriptor: '',
       metadata: {
         appPid: env.appPid,
         id: internal.id,

package/api/src/libs/notification/template/subscription-renewed.ts

@@ -93,7 +93,7 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
     const userDid: string = customer.did;
     const locale = await getUserLocale(userDid);
     const productName = await getMainProductName(subscription.id);
-    const at: string = formatTime(Date.now());
+    const at: string = formatTime((invoice?.status_transitions?.paid_at ?? Math.floor(Date.now() / 1000)) * 1000);
 
     const hasNft: boolean = checkoutSession?.nft_mint_status === 'minted';
     const nftMintItem: NftMintItem | undefined = hasNft

package/api/src/libs/notification/template/subscription-trial-will-end.ts

@@ -13,6 +13,7 @@ import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+import dayjs from '../../dayjs';
 
 export interface SubscriptionTrialWillEndEmailTemplateOptions {
   subscriptionId: string;
@@ -164,6 +165,11 @@ export class SubscriptionTrialWilEndEmailTemplate
       viewSubscriptionLink,
     } = await this.getContext();
 
+    // 如果当前时间大于试用结束时间，那么不发送通知
+    if (dayjs().utc().isAfter(dayjs.utc(at))) {
+      return null;
+    }
+
     const canPay: boolean = paymentDetail.balance >= paymentDetail.price;
     if (canPay && !this.options.required) {
       // 当余额足够支付并且本封邮件不是必须发送时,可以不发送邮件

package/api/src/libs/notification/template/subscription-upgraded.ts

@@ -40,6 +40,7 @@ interface SubscriptionUpgradedEmailTemplateContext {
   viewSubscriptionLink: string;
   viewInvoiceLink: string;
   viewTxHashLink: string | undefined;
+  skipInvoice: boolean;
 }
 
 export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<SubscriptionUpgradedEmailTemplateContext> {
@@ -54,7 +55,7 @@ export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<Subs
     if (!subscription) {
       throw new Error(`Subscription not found: ${this.options.subscriptionId}`);
     }
-    if (subscription.status !== 'active') {
+    if (!subscription.isActive()) {
       throw new Error(`Subscription not active: ${this.options.subscriptionId}`);
     }
 
@@ -63,7 +64,10 @@ export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<Subs
       throw new Error(`Customer not found: ${subscription.customer_id}`);
     }
 
-    const invoice = (await Invoice.findByPk(subscription.latest_invoice_id)) as Invoice;
+    // invoice应该是最新的subscription_update invoice
+    const invoiceId = subscription.pending_update?.updates?.latest_invoice_id || subscription.latest_invoice_id;
+    const invoice = (await Invoice.findByPk(invoiceId)) as Invoice;
+    const skipInvoice = subscription.status === 'trialing' || invoice.billing_reason !== 'subscription_update';
     const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
     const paymentCurrency = (await PaymentCurrency.findOne({
       where: {
@@ -90,8 +94,12 @@ export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<Subs
     const nftMintItem: NftMintItem | undefined = hasNft
       ? checkoutSession?.nft_mint_details?.[checkoutSession?.nft_mint_details?.type as 'arcblock' | 'ethereum']
       : undefined;
-    const currentPeriodStart: string = formatTime(invoice.period_start * 1000);
-    const currentPeriodEnd: string = formatTime(invoice.period_end * 1000);
+    const currentPeriodStart: string = formatTime(
+      skipInvoice ? subscription.current_period_start * 1000 : invoice.period_start * 1000
+    );
+    const currentPeriodEnd: string = formatTime(
+      skipInvoice ? subscription.current_period_end * 1000 : invoice.period_end * 1000
+    );
     const duration: string = prettyMsI18n(
       new Date(currentPeriodEnd).getTime() - new Date(currentPeriodStart).getTime(),
       {
@@ -139,6 +147,7 @@ export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<Subs
       viewSubscriptionLink,
       viewInvoiceLink,
       viewTxHashLink,
+      skipInvoice,
     };
   }
 
@@ -157,6 +166,7 @@ export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<Subs
       viewSubscriptionLink,
       viewInvoiceLink,
       viewTxHashLink,
+      skipInvoice,
     } = await this.getContext();
 
     const template: BaseEmailTemplateType = {
@@ -210,21 +220,25 @@ export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<Subs
                 text: productName,
               },
             },
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                color: '#9397A1',
-                text: translate('notification.common.paymentAmount', locale),
-              },
-            },
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                text: paymentInfo,
-              },
-            },
+            ...(skipInvoice
+              ? []
+              : [
+                  {
+                    type: 'text',
+                    data: {
+                      type: 'plain',
+                      color: '#9397A1',
+                      text: translate('notification.common.paymentAmount', locale),
+                    },
+                  },
+                  {
+                    type: 'text',
+                    data: {
+                      type: 'plain',
+                      text: paymentInfo,
+                    },
+                  },
+                ]),
             {
               type: 'text',
               data: {
@@ -250,16 +264,17 @@ export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<Subs
           title: translate('notification.common.viewSubscription', locale),
           link: viewSubscriptionLink,
         },
-        {
+        !skipInvoice && {
           name: translate('notification.common.viewInvoice', locale),
           title: translate('notification.common.viewInvoice', locale),
           link: viewInvoiceLink,
         },
-        viewTxHashLink && {
-          name: translate('notification.common.viewTxHash', locale),
-          title: translate('notification.common.viewTxHash', locale),
-          link: viewTxHashLink,
-        },
+        !skipInvoice &&
+          viewTxHashLink && {
+            name: translate('notification.common.viewTxHash', locale),
+            title: translate('notification.common.viewTxHash', locale),
+            link: viewTxHashLink,
+          },
       ].filter(Boolean),
     };
 

package/api/src/libs/notification/template/subscription-will-canceled.ts

@@ -3,6 +3,7 @@
 import { fromUnitToToken } from '@ocap/util';
 import type { ManipulateType } from 'dayjs';
 
+import dayjs from '../../dayjs';
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
 import { Customer, Invoice, Subscription } from '../../../store/models';
@@ -143,6 +144,11 @@ export class SubscriptionWillCanceledEmailTemplate
       viewInvoiceLink,
     } = await this.getContext();
 
+    // 如果当前时间大于订阅终止时间，那么不发送通知
+    if (dayjs().utc().isAfter(dayjs.utc(at))) {
+      return null;
+    }
+
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptWillCanceled.title', locale, {
         productName,

package/api/src/libs/notification/template/subscription-will-renew.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/brace-style */
 /* eslint-disable @typescript-eslint/indent */
 import type { ManipulateType } from 'dayjs';
-import dayjs from 'dayjs';
 import prettyMsI18n from 'pretty-ms-i18n';
 import type { LiteralUnion } from 'type-fest';
 
 import { fromUnitToToken } from '@ocap/util';
+import dayjs from '../../dayjs';
 import { getTokenSummaryByDid } from '../../../integrations/arcblock/stake';
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
@@ -251,6 +251,10 @@ export class SubscriptionWillRenewEmailTemplate
       paymentMethod,
     } = await this.getContext();
 
+    // 如果当前时间大于预计扣费时间，那么不发送通知
+    if (dayjs().utc().isAfter(dayjs.utc(at))) {
+      return null;
+    }
     const canPay: boolean = paymentDetail.balance >= paymentDetail.price;
     if (canPay) {
       // 当余额足够支付并且本封邮件不是必须发送时,可以不发送邮件
@@ -260,7 +264,6 @@ export class SubscriptionWillRenewEmailTemplate
       // 如果预估的价格是 0 并且货币不是 USD，那么直接不发送
       return null;
     }
-
     const isStripe = paymentMethod?.type === 'stripe';
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionWillRenew.title', locale, {

package/api/src/libs/queue/index.ts

@@ -5,9 +5,12 @@ import EventEmitter from 'events';
 import fastq from 'fastq';
 import { nanoid } from 'nanoid';
 
+import { AsyncLocalStorage } from 'async_hooks';
 import logger from '../logger';
 import { sleep, tryWithTimeout } from '../util';
 import createQueueStore from './store';
+import { Job } from '../../store/models/job';
+import { sequelize } from '../../store/sequelize';
 
 const CANCELLED = '__CANCELLED__';
 const MIN_DELAY = process.env.NODE_ENV === 'test' ? 2 : 8;
@@ -50,26 +53,56 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
   const getJobId = (id: string | undefined, job: any) => id || (options.id ? options.id(job) : nanoid()) || nanoid();
 
   const queueEvents = new EventEmitter();
+  const asyncLocalStorage = new AsyncLocalStorage();
+  const runningJobs = new Set();
+  const cancelledJobs = new Set();
+
+  const ensureUniqueExecution = async (id: string, fn: () => Promise<any>) => {
+    if (runningJobs.has(id)) {
+      logger.warn('Job already running, skipping', { id });
+      return;
+    }
+
+    runningJobs.add(id);
+    try {
+      await asyncLocalStorage.run({ id }, fn);
+    } finally {
+      runningJobs.delete(id);
+      logger.info(`Running job deleted: ${id}`);
+    }
+  };
+
   const queue = fastq(async ({ job, id, persist }: { job: any; id: string; persist: boolean }, cb: Function) => {
-    if (persist) {
-      try {
-        const cancelled = await store.isCancelled(id);
-        if (cancelled) {
-          cb(null, CANCELLED);
+    logger.info('execute job', { id, job, persist });
+    await ensureUniqueExecution(id, async () => {
+      if (persist) {
+        try {
+          const cancelled = await store.isCancelled(id);
+          if (cancelled) {
+            cb(null, CANCELLED);
+            return;
+          }
+        } catch (err) {
+          cb(err);
           return;
         }
-      } catch (err) {
-        cb(err);
+      }
+
+      if (cancelledJobs.has(id)) {
+        cb(null, CANCELLED);
+        logger.info(`Job skipped because it is cancelled: ${id}`);
+        cancelledJobs.delete(id);
         return;
       }
-    }
 
-    try {
-      const result = await tryWithTimeout(() => onJob(job), maxTimeout);
-      cb(null, result);
-    } catch (err) {
-      cb(err);
-    }
+      try {
+        const result = await tryWithTimeout(() => onJob(job), maxTimeout);
+        logger.info('job finished', { id, result });
+        cb(null, result);
+      } catch (err) {
+        cb(err);
+      }
+    });
     // @ts-ignore
   }, concurrency);
 
@@ -109,7 +142,8 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
       store
         .addJob(jobId, job, attrs)
         .then(() => {
-          emit('queued', { id: jobId, job, attrs });
+          emit('queued', { id: jobId, job, attrs, persist });
+          logger.info('delayed or scheduled job queued', { id: jobId, job, attrs, persist });
         })
         .catch((err) => {
           console.error(err);
@@ -157,7 +191,7 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
         logger.info('retry job', { id: jobId, count: doc.retry_count + 1 });
         setTimeout(() => {
           emit('retry', { id: jobId, job, doc });
-          queue.unshift({ id: jobId, job }, onJobComplete);
+          queue.unshift({ id: jobId, job, persist }, onJobComplete);
         }, retryDelay);
         // eslint-disable-next-line no-shadow, @typescript-eslint/no-shadow
       } catch (err: any) {
@@ -171,6 +205,9 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
       setImmediate(() => {
         emit('queued', { id: jobId, job, persist });
         logger.info('queue job', { id: jobId, job });
+        if (cancelledJobs.has(jobId)) {
+          cancelledJobs.delete(jobId);
+        }
         queue.push({ id: jobId, job, persist }, onJobComplete);
       });
 
@@ -208,6 +245,7 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
 
   const cancel = async (id: string) => {
     const doc = await store.updateJob(id, { cancelled: true });
+    cancelledJobs.add(id);
     return doc ? doc.job : null;
   };
 
@@ -219,18 +257,26 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
   const deleteJob = async (id: string): Promise<boolean> => {
     const exists = await getJob(id);
 
-    if (exists) {
+    if (!exists) {
+      return false;
+    }
+    try {
       await cancel(id);
       await store.deleteJob(id);
+      logger.info(`Job deleted successfully: ${id}`);
       return true;
+    } catch (error) {
+      console.error(`Error during job deletion process for ${id}:`, error);
+      return false;
     }
-
-    return false;
   };
 
   // Populate the queue on startup
   process.nextTick(async () => {
     try {
+      if (!Job.isInitialized()) {
+        Job.initialize(sequelize);
+      }
       const jobs = await store.getJobs();
       logger.info(`${name} jobs to populate`, { count: jobs.length });
       jobs.forEach((x) => {
@@ -260,6 +306,10 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
             if (x.job && x.id) {
               // fix: https://github.com/blocklet/payment-kit/issues/287
               await cancel(x.id);
+              logger.info('reschedule delayed or scheduled job', {
+                id: x.id,
+                job: x.job,
+              });
               push({ job: x.job, id: x.id, persist: false });
             } else {
               logger.info('skip invalid job from db', { job: x });

package/api/src/libs/queue/store.ts

@@ -13,7 +13,11 @@ export default function createQueueStore(queue: string) {
       return Job.findOne({ where: { queue, id }, transaction: null });
     },
     getJobs(): Promise<TJob[]> {
-      return Job.findAll({ where: { queue, delay: -1 }, order: [['created_at', 'ASC']], transaction: null });
+      return Job.findAll({
+        where: { queue, delay: -1, cancelled: false },
+        order: [['created_at', 'ASC']],
+        transaction: null,
+      });
     },
     getScheduledJobs(): Promise<TJob[]> {
       return Job.findAll({
@@ -31,12 +35,31 @@ export default function createQueueStore(queue: string) {
       return job.update(updates);
     },
     async addJob(id: string, job: any, attrs: Partial<TJob> = {}): Promise<TJob> {
-      const exist = await Job.findOne({ where: { queue, id }, transaction: null });
-      if (exist) {
-        throw new CustomError('JOB_DUPLICATE', `Job ${queue}#${id} already exist`);
+      const existingJob = await Job.findOne({ where: { id } });
+
+      if (existingJob) {
+        throw new CustomError(
+          'JOB_DUPLICATE',
+          `Job with id ${id} already exists ${existingJob.queue === queue ? 'in the same queue' : `in queue ${existingJob.queue}`}`
+        );
       }
 
-      return Job.create({ id, job, queue, retry_count: 1, cancelled: false, ...attrs });
+      try {
+        const newJob = await Job.create({
+          id,
+          job,
+          queue,
+          retry_count: 1,
+          cancelled: false,
+          ...attrs,
+        });
+        return newJob;
+      } catch (error) {
+        if (error.name === 'SequelizeUniqueConstraintError') {
+          throw new CustomError('JOB_DUPLICATE', `Job with id ${id} was created concurrently`);
+        }
+        throw error;
+      }
     },
     async deleteJob(id: string): Promise<boolean> {
       const data = await Job.destroy({ where: { queue, id } });

package/api/src/libs/subscription.ts

@@ -473,7 +473,7 @@ export async function finalizeSubscriptionUpdate({
 }: {
   subscription: Subscription;
   customer: Customer;
-  invoice: Invoice;
+  invoice: Invoice | null;
   paymentCurrency: PaymentCurrency;
   appliedCredit: string;
   newCredit: string;
@@ -522,27 +522,31 @@ export async function finalizeSubscriptionUpdate({
   // update customer credits
   if (appliedCredit !== '0') {
     const creditResult = await customer.decreaseTokenBalance(paymentCurrency.id, appliedCredit);
-    await invoice.update({
-      starting_token_balance: creditResult.starting,
-      ending_token_balance: creditResult.ending,
-    });
-    logger.info('customer credit applied to invoice after proration', {
-      subscription: subscription.id,
-      appliedCredit,
-      creditResult,
-    });
+    if (invoice) {
+      await invoice.update({
+        starting_token_balance: creditResult.starting,
+        ending_token_balance: creditResult.ending,
+      });
+      logger.info('customer credit applied to invoice after proration', {
+        subscription: subscription.id,
+        appliedCredit,
+        creditResult,
+      });
+    }
   }
   if (newCredit !== '0') {
     const creditResult = await customer.increaseTokenBalance(paymentCurrency.id, newCredit);
-    await invoice.update({
-      starting_token_balance: creditResult.starting,
-      ending_token_balance: creditResult.ending,
-    });
-    logger.info('subscription proration credit applied to customer', {
-      subscription: subscription.id,
-      newCredit,
-      creditResult,
-    });
+    if (invoice) {
+      await invoice.update({
+        starting_token_balance: creditResult.starting,
+        ending_token_balance: creditResult.ending,
+      });
+      logger.info('subscription proration credit applied to customer', {
+        subscription: subscription.id,
+        newCredit,
+        creditResult,
+      });
+    }
   }
 
   // lock for next update
@@ -866,3 +870,42 @@ export async function getSubscriptionStakeCancellation(
   }
   return cancellation;
 }
+
+export async function getSubscriptionStakeAmountSetup(subscription: Subscription, paymentMethod: PaymentMethod) {
+  if (paymentMethod.type !== 'arcblock') {
+    return null;
+  }
+  const txHash = subscription?.payment_details?.arcblock?.staking?.tx_hash;
+  if (!txHash) {
+    return null;
+  }
+  const client = paymentMethod.getOcapClient();
+  const { info } = await client.getTx({ hash: txHash });
+  if (!info) {
+    return null;
+  }
+  // @ts-ignore
+  const inputs = info?.tx?.itxJson?.inputs || [];
+  if (!inputs || inputs.length === 0) {
+    logger.info('getSubscriptionStakeAmountSetup failed, no inputs', { txHash, info });
+    return null;
+  }
+  const amountRes: { [key: string]: BN } = {};
+  // calculate stake amount for each address
+  inputs.forEach((input: any) => {
+    const { tokens } = input;
+    tokens.forEach((token: any) => {
+      const { address, value } = token;
+      if (amountRes[address]) {
+        amountRes[address] = amountRes[address].add(new BN(value));
+      } else {
+        amountRes[address] = new BN(value);
+      }
+    });
+  });
+  Object.keys(amountRes).forEach((address) => {
+    amountRes[address] = amountRes[address].toString();
+  });
+  logger.info('get subscription stake amount setup success', { txHash, amountRes });
+  return amountRes;
+}

package/api/src/queues/invoice.ts

@@ -5,13 +5,14 @@ import { createEvent } from '../libs/audit';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
-import { PaymentMethod } from '../store/models';
+import { PaymentMethod, Invoice } from '../store/models';
 import { CheckoutSession } from '../store/models/checkout-session';
-import { Invoice } from '../store/models/invoice';
 import { PaymentIntent } from '../store/models/payment-intent';
 import { Subscription } from '../store/models/subscription';
 import { paymentQueue } from './payment';
 
+import { getLock } from '../libs/lock';
+
 type InvoiceJob = {
   invoiceId: string;
   justCreate?: boolean;
@@ -195,26 +196,45 @@ export const invoiceQueue = createQueue<InvoiceJob>({
 });
 
 export const startInvoiceQueue = async () => {
-  const invoices = await Invoice.findAll({
-    where: {
-      status: 'open',
-      collection_method: 'charge_automatically',
-      amount_remaining: { [Op.gt]: '0' },
-    },
-  });
-
-  invoices.forEach(async (x) => {
-    const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
-    if (supportAutoCharge === false) {
-      return;
-    }
-    const exist = await invoiceQueue.get(x.id);
-    if (!exist) {
-      invoiceQueue.push({ id: x.id, job: { invoiceId: x.id, retryOnError: true } });
+  const lock = getLock('startInvoiceQueue');
+  if (lock.locked) {
+    return;
+  }
+
+  try {
+    await lock.acquire();
+    const invoices = await Invoice.findAll({
+      where: {
+        status: 'open',
+        collection_method: 'charge_automatically',
+        amount_remaining: { [Op.gt]: '0' },
+      },
+    });
+
+    const results = await Promise.allSettled(
+      invoices.map(async (x) => {
+        const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
+        if (supportAutoCharge === false) {
+          return;
+        }
+        const exist = await invoiceQueue.get(x.id);
+        if (!exist) {
+          await invoiceQueue.push({ id: x.id, job: { invoiceId: x.id, retryOnError: true } });
+        }
+      })
+    );
+
+    const failed = results.filter((r) => r.status === 'rejected').length;
+    if (failed > 0) {
+      logger.warn(`Failed to process ${failed} invoices in startInvoiceQueue`);
     }
-  });
 
-  await batchHandleStripeInvoices();
+    await batchHandleStripeInvoices();
+  } catch (error) {
+    logger.error('Error in startInvoiceQueue:', error);
+  } finally {
+    lock.release();
+  }
 };
 
 invoiceQueue.on('failed', ({ id, job, error }) => {

package/api/src/queues/payment.ts

@@ -210,7 +210,7 @@ export const handlePaymentSucceed = async (
         }
       }
 
-      if (triggerRenew) {
+      if (triggerRenew && invoice.billing_reason !== 'subscription_update') {
         if (invoice.billing_reason === 'subscription_cycle' || paymentIntent.capture_method === 'manual') {
           createEvent('Subscription', 'customer.subscription.renewed', subscription).catch(console.error);
         }
@@ -323,6 +323,10 @@ export const handlePaymentFailed = async (
     return updates.terminate;
   }
 
+  if (subscription.isImmutable()) {
+    logger.info('Subscription is immutable, no need to check due', { subscription: subscription.id });
+    return updates.terminate;
+  }
   // check days until cancel
   const dueUnit = getDueUnit(interval);
   const daysUntilCancel = getDaysUntilCancel(subscription);

package/api/src/queues/subscription.ts

@@ -177,6 +177,8 @@ const doHandleSubscriptionInvoice = async ({
     } as Invoice,
   });
 
+  logger.info('Invoice created for subscription', { invoice: invoice.id, subscription: subscription.id });
+
   return invoice;
 };
 
@@ -401,6 +403,7 @@ const handleStakeSlashAfterCancel = async (subscription: Subscription) => {
     amount: invoice.amount_remaining,
     address,
     txHash,
+    invoice: invoice.id,
   });
 
   await paymentIntent.update({
@@ -645,7 +648,7 @@ export const handleSubscription = async (job: SubscriptionJob) => {
         previousStatus,
       });
 
-      if (previousStatus === 'past_due') {
+      if (previousStatus === 'past_due' && job.action === 'cancel') {
         await handleStakeSlashAfterCancel(subscription);
       }
       return;
@@ -689,21 +692,48 @@ export const subscriptionQueue = createQueue<SubscriptionJob>({
 });
 
 export const startSubscriptionQueue = async () => {
-  const subscriptions = await Subscription.findAll({
-    where: {
-      status: EXPECTED_SUBSCRIPTION_STATUS,
-    },
-  });
+  const lock = getLock('startSubscriptionQueue');
+  if (lock.locked) {
+    return;
+  }
+  logger.info('startSubscriptionQueue');
+  try {
+    await lock.acquire();
+    const subscriptions = await Subscription.findAll({
+      where: {
+        status: EXPECTED_SUBSCRIPTION_STATUS,
+      },
+    });
 
-  subscriptions.forEach(async (x) => {
-    const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
-    if (supportAutoCharge === false) {
-      return;
+    const results = await Promise.allSettled(
+      subscriptions.map(async (x) => {
+        const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
+        if (supportAutoCharge === false) {
+          return;
+        }
+        if (['past_due', 'paused'].includes(x.status)) {
+          logger.info(`skip add cycle subscription job because status is ${x.status}`, {
+            subscription: x.id,
+            action: 'cycle',
+          });
+          return;
+        }
+        logger.info('add subscription job', { subscription: x.id, action: 'cycle' });
+        await addSubscriptionJob(x, 'cycle', process.env.PAYMENT_RELOAD_SUBSCRIPTION_JOBS === '1');
+      })
+    );
+
+    const failed = results.filter((r) => r.status === 'rejected').length;
+    if (failed > 0) {
+      logger.warn(`Failed to process ${failed} subscriptions in startSubscriptionQueue`);
     }
-    await addSubscriptionJob(x, 'cycle', process.env.PAYMENT_RELOAD_SUBSCRIPTION_JOBS === '1');
-  });
 
-  await batchHandleStripeSubscriptions();
+    await batchHandleStripeSubscriptions();
+  } catch (error) {
+    logger.error('Error in startSubscriptionQueue:', error);
+  } finally {
+    lock.release();
+  }
 };
 
 export const slashStakeQueue = createQueue({

package/api/src/routes/invoices.ts

@@ -20,6 +20,7 @@ import { PaymentMethod } from '../store/models/payment-method';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
 import { Subscription } from '../store/models/subscription';
+import { getSubscriptionStakeAmountSetup } from '../libs/subscription';
 
 const router = Router();
 const authAdmin = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
@@ -131,44 +132,23 @@ router.get('/', authMine, async (req, res) => {
         if (subscription?.payment_details?.arcblock?.staking?.tx_hash) {
           const method = await PaymentMethod.findOne({ where: { type: 'arcblock', livemode: subscription.livemode } });
           if (method) {
-            const client = method.getOcapClient();
             const { address } = subscription.payment_details.arcblock.staking;
-            const { state } = await client.getStakeState({ address });
             const firstInvoice = await Invoice.findOne({
               where: { subscription_id: subscription.id },
               order: [['created_at', 'ASC']],
+              include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
             });
             const last = query.o === 'asc' ? list?.[list.length - 1] : list?.[0];
-            if (state && firstInvoice) {
-              const data = JSON.parse(state.data?.value || '{}');
+            if (subscription.payment_details.arcblock.staking.tx_hash && firstInvoice) {
               const customer = await Customer.findByPk(firstInvoice.customer_id);
-              const currency = await PaymentCurrency.findOne({
-                where: { payment_method_id: method.id, is_base_currency: true },
-              });
-
-              let stakeAmount = data[subscription.id];
-              if (state.nonce) {
-                stakeAmount = state.tokens?.find((x: any) => x.address === currency?.contract)?.value;
-                // stakeAmount should not be zero if nonce exist
-                if (!Number(stakeAmount)) {
-                  if (subscription.cancelation_details?.return_stake) {
-                    const refund = await Refund.findOne({
-                      where: { subscription_id: subscription.id, status: 'succeeded', type: 'stake_return' },
-                    });
-                    if (refund) {
-                      stakeAmount = refund.amount;
-                    }
-                  }
-                  if (subscription.cancelation_details?.slash_stake) {
-                    const invoice = await Invoice.findOne({
-                      where: { subscription_id: subscription.id, status: 'paid', billing_reason: 'slash_stake' },
-                    });
-                    if (invoice) {
-                      stakeAmount = invoice.total;
-                    }
-                  }
-                }
-              }
+              const currency =
+                // @ts-ignore
+                firstInvoice?.paymentCurrency ||
+                (await PaymentCurrency.findOne({
+                  where: { payment_method_id: method.id, is_base_currency: true },
+                }));
+              const stakeAmountResult = await getSubscriptionStakeAmountSetup(subscription, method);
+              const stakeAmount = stakeAmountResult?.[currency?.contract] || '0';
 
               list.push({
                 id: address as string,

package/api/src/routes/subscriptions.ts

@@ -7,6 +7,7 @@ import pick from 'lodash/pick';
 import uniq from 'lodash/uniq';
 
 import { literal, OrderItem } from 'sequelize';
+import { createEvent } from '../libs/audit';
 import { ensureStripeCustomer, ensureStripePrice, ensureStripeSubscription } from '../integrations/stripe/resource';
 import { createListParamSchema, getWhereFromKvQuery, getWhereFromQuery, MetadataSchema } from '../libs/api';
 import dayjs from '../libs/dayjs';
@@ -510,7 +511,7 @@ router.put('/:id/resume', auth, async (req, res) => {
   if (!doc) {
     return res.status(404).json({ error: 'Subscription not found' });
   }
-  if (doc.status !== 'paused' || doc.pause_collection === null) {
+  if (doc.status !== 'paused' && doc.pause_collection === null) {
     return res.status(400).json({ error: 'Subscription not paused' });
   }
 
@@ -851,10 +852,15 @@ router.put('/:id', authPortal, async (req, res) => {
         // update subscription period settings
         // HINT: if we are adding new items, we need to reset the anchor to now
         const setup = getSubscriptionCreateSetup(newItems, paymentCurrency.id, 0);
+        // Check if the subscription is currently in trial
+        const isInTrial =
+          subscription.status === 'trialing' && subscription.trial_end && subscription.trial_end > dayjs().unix();
         if (newItems.some((x) => x.price.type === 'recurring' && addedItems.find((y) => y.price_id === x.price_id))) {
           updates.pending_invoice_item_interval = setup.recurring;
-          updates.current_period_start = setup.period.start;
-          updates.current_period_end = setup.period.end;
+          if (!isInTrial) {
+            updates.current_period_start = setup.period.start;
+            updates.current_period_end = setup.period.end;
+          }
           updates.billing_cycle_anchor = setup.cycle.anchor;
           logger.info('subscription updates on reset anchor', { subscription: req.params.id, updates });
         }
@@ -869,12 +875,30 @@ router.put('/:id', authPortal, async (req, res) => {
           }
 
           // 1. create proration
-          const { lastInvoice, due, newCredit, appliedCredit, prorations } = await createProration(
+          const { lastInvoice, due, newCredit, appliedCredit, prorations, total } = await createProration(
             subscription,
             setup,
             dayjs().unix()
           );
 
+          if ((total === '0' && isInTrial) || newCredit !== '0') {
+            // 0 amount or new credit means no need to create invoice
+            await subscription.update(updates);
+            await finalizeSubscriptionUpdate({
+              subscription,
+              customer,
+              invoice: null,
+              paymentCurrency,
+              appliedCredit,
+              newCredit,
+              addedItems,
+              deletedItems,
+              updatedItems,
+              updates,
+            });
+            await createEvent('Subscription', 'customer.subscription.upgraded', subscription).catch(console.error);
+            return res.json({ ...subscription.toJSON(), connectAction });
+          }
           // 2. create new invoice: amount according to new subscription items
           // 3. create new invoice items: amount according to new subscription items
           const result = await ensureInvoiceAndItems({
@@ -894,7 +918,7 @@ router.put('/:id', authPortal, async (req, res) => {
               period_end: setup.period.end,
               auto_advance: true,
               billing_reason: 'subscription_update',
-              total: setup.amount.setup,
+              total,
               currency_id: paymentCurrency.id,
               default_payment_method_id: subscription.default_payment_method_id,
               custom_fields: lastInvoice.custom_fields || [],
@@ -977,6 +1001,16 @@ router.put('/:id', authPortal, async (req, res) => {
               invoice: invoice.id,
             });
           } else {
+            await subscription.update({
+              pending_update: {
+                updates,
+                appliedCredit,
+                newCredit,
+                addedItems,
+                deletedItems,
+                updatedItems,
+              },
+            });
             await invoiceQueue.pushAndWait({
               id: invoice.id,
               job: { invoiceId: invoice.id, retryOnError: false, waitForPayment: true },

package/api/src/store/models/job.ts

@@ -70,6 +70,10 @@ export class Job extends Model<InferAttributes<Job>, InferCreationAttributes<Job
   public static associate() {
     // Do nothing
   }
+
+  public static isInitialized(): boolean {
+    return this.sequelize !== undefined;
+  }
 }
 
 export type TJob = InferAttributes<Job>;

package/api/tests/libs/subscription.spec.ts

@@ -9,7 +9,9 @@ import {
   getSubscriptionStakeSetup,
   getSubscriptionTrialSetup,
   shouldCancelSubscription,
+  getSubscriptionStakeAmountSetup,
 } from '../../src/libs/subscription';
+import type { PaymentMethod, Subscription } from '../../src/store/models';
 
 describe('getDueUnit', () => {
   it('should return 60 for recurring interval of "hour"', () => {
@@ -411,3 +413,98 @@ describe('getSubscriptionTrialSetup', () => {
     expect(result).toEqual({ trialInDays: 0, trialEnd: 0 });
   });
 });
+
+describe('getSubscriptionStakeAmountSetup', () => {
+  let mockSubscription: Subscription;
+  let mockPaymentMethod: PaymentMethod;
+  let mockGetOcapClient: jest.Mock;
+  let mockGetTx: jest.Mock;
+
+  beforeEach(() => {
+    mockSubscription = {
+      payment_details: {
+        arcblock: {
+          staking: {
+            tx_hash: 'mock_tx_hash',
+          },
+        },
+      },
+    } as Subscription;
+
+    mockGetTx = jest.fn();
+    mockGetOcapClient = jest.fn().mockReturnValue({
+      getTx: mockGetTx,
+    });
+
+    // @ts-ignore
+    mockPaymentMethod = {
+      type: 'arcblock',
+      getOcapClient: mockGetOcapClient,
+    };
+  });
+
+  it('should return null if payment method is not arcblock', async () => {
+    mockPaymentMethod.type = 'other';
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toBeNull();
+  });
+
+  it('should return null if tx_hash is missing', async () => {
+    // @ts-ignore
+    mockSubscription.payment_details.arcblock.staking.tx_hash = undefined;
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toBeNull();
+  });
+
+  it('should return null if getTx info is null', async () => {
+    mockGetTx.mockResolvedValue({ info: null });
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toBeNull();
+  });
+
+  it('should return null if inputs are empty', async () => {
+    mockGetTx.mockResolvedValue({
+      info: {
+        tx: {
+          itxJson: {
+            inputs: [],
+          },
+        },
+      },
+    });
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toBeNull();
+  });
+
+  it('should calculate stake amount correctly', async () => {
+    mockGetTx.mockResolvedValue({
+      info: {
+        tx: {
+          itxJson: {
+            inputs: [
+              {
+                tokens: [
+                  { address: 'addr1', value: '100' },
+                  { address: 'addr2', value: '200' },
+                ],
+              },
+              {
+                tokens: [
+                  { address: 'addr1', value: '300' },
+                  { address: 'addr3', value: '400' },
+                ],
+              },
+            ],
+          },
+        },
+      },
+    });
+
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toEqual({
+      addr1: '400',
+      addr2: '200',
+      addr3: '400',
+    });
+  });
+});

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.15.15
+version: 1.15.17
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.15.15",
+  "version": "1.15.17",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -45,18 +45,18 @@
     "@abtnode/cron": "^1.16.32",
     "@arcblock/did": "^1.18.135",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
-    "@arcblock/did-connect": "^2.10.39",
+    "@arcblock/did-connect": "^2.10.45",
     "@arcblock/did-util": "^1.18.135",
     "@arcblock/jwt": "^1.18.135",
-    "@arcblock/ux": "^2.10.39",
+    "@arcblock/ux": "^2.10.45",
     "@arcblock/validator": "^1.18.135",
     "@blocklet/js-sdk": "^1.16.32",
     "@blocklet/logger": "^1.16.32",
-    "@blocklet/payment-react": "1.15.15",
+    "@blocklet/payment-react": "1.15.17",
     "@blocklet/sdk": "^1.16.32",
-    "@blocklet/ui-react": "^2.10.39",
-    "@blocklet/uploader": "^0.1.40",
-    "@blocklet/xss": "^0.1.7",
+    "@blocklet/ui-react": "^2.10.45",
+    "@blocklet/uploader": "^0.1.43",
+    "@blocklet/xss": "^0.1.9",
     "@mui/icons-material": "^5.16.6",
     "@mui/lab": "^5.0.0-alpha.173",
     "@mui/material": "^5.16.6",
@@ -118,7 +118,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.32",
     "@arcblock/eslint-config-ts": "^0.3.2",
-    "@blocklet/payment-types": "1.15.15",
+    "@blocklet/payment-types": "1.15.17",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -144,7 +144,7 @@
     "typescript": "^4.9.5",
     "vite": "^5.3.5",
     "vite-node": "^2.0.4",
-    "vite-plugin-blocklet": "^0.9.8",
+    "vite-plugin-blocklet": "^0.9.11",
     "vite-plugin-node-polyfills": "^0.21.0",
     "vite-plugin-svgr": "^4.2.0",
     "vite-tsconfig-paths": "^4.3.2",
@@ -160,5 +160,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "a4661fedeb5c77d1c89736f9030f89cb2fc03474"
+  "gitHead": "746e67a4e0542f308289edd4e2d6bdd64e49e53e"
 }

package/src/pages/customer/subscription/change-plan.tsx

@@ -200,7 +200,7 @@ export default function CustomerSubscriptionChangePlan() {
   };
 
   const table = { ...data.table, currency: data.subscription.paymentCurrency };
-  table.items.forEach((x: any) => {
+  (table.items || []).forEach((x: any) => {
     x.is_selected = x.price_id === state.priceId;
     if (data.subscription.items.find((y) => y.price_id === x.price_id)) {
       x.is_highlight = true;

package/vite-server.config.ts

@@ -6,6 +6,14 @@ import tsconfigPaths from 'vite-tsconfig-paths';
 // https://vitejs.dev/config/
 export default defineConfig(() => {
   return {
+    resolve: {
+      alias: {
+        crypto: 'node:crypto',
+      },
+    },
     plugins: [tsconfigPaths()],
+    server: {
+      hmr: false,
+    },
   };
 });