payment-kit 1.18.24 → 1.18.26

package/api/src/locales/en.ts

@@ -212,5 +212,10 @@ export default flat({
       title: 'Insufficient Credit for SubGuard™',
       body: 'Your subscription to {productName} has insufficient staked credit for SubGuard™. Please increase your stake to maintain the service or disable it if no longer needed.',
     },
+
+    aggregatedSubscriptionRenewed: {
+      title: '{count} Subscriptions Renewed',
+      body: 'During {startTime} - {endTime}, {count} subscriptions were successfully renewed, total amount: {totalAmount}.\n\nSubscription List:\n{subscriptionList}',
+    },
   },
 });

package/api/src/locales/zh.ts

@@ -206,5 +206,10 @@ export default flat({
       title: '订阅守护服务额度不足',
       body: '您订阅的 {productName} 订阅守护服务额度不足，为了避免影响您的使用，请及时充值。如不再需要订阅守护服务，可关闭该功能。',
     },
+
+    aggregatedSubscriptionRenewed: {
+      title: '{count} 个订阅续费成功',
+      body: '在 {startTime} - {endTime} 期间，共有 {count} 个订阅成功续费，总金额：{totalAmount}。\n\n订阅清单：\n{subscriptionList}',
+    },
   },
 });

package/api/src/queues/invoice.ts

@@ -289,16 +289,30 @@ events.on('invoice.queued', async (id, job, args = {}) => {
         job,
         ...extraArgs,
       });
-      events.emit('invoice.queued.done');
+      events.emit('invoice.queued.done', { id });
     } catch (error) {
       logger.error('Error in invoice.queued', { id, job, error });
-      events.emit('invoice.queued.error', error);
+      events.emit('invoice.queued.error', { id, job, error });
     }
     return;
   }
-  invoiceQueue.push({
-    id,
-    job,
-    ...extraArgs,
-  });
+  try {
+    const existJob = await invoiceQueue.get(id);
+    if (existJob) {
+      await invoiceQueue.delete(id);
+      logger.info('Removed existing invoice job for immediate execution', {
+        id,
+        originalRunAt: existJob.runAt,
+      });
+    }
+    invoiceQueue.push({
+      id,
+      job,
+      ...extraArgs,
+    });
+    events.emit('invoice.queued.done', { id });
+  } catch (error) {
+    logger.error('Error in invoice.queued', { id, job, error });
+    events.emit('invoice.queued.error', { id, job, error });
+  }
 });

package/api/src/queues/notification.ts

@@ -1,6 +1,8 @@
 /* eslint-disable @typescript-eslint/indent */
+import { Op } from 'sequelize';
 import { events } from '../libs/event';
 import logger from '../libs/logger';
+import dayjs from '../libs/dayjs';
 import { Notification } from '../libs/notification';
 import type { BaseEmailTemplate } from '../libs/notification/template/base';
 import {
@@ -56,7 +58,16 @@ import {
   SubscriptionStakeSlashSucceededEmailTemplateOptions,
 } from '../libs/notification/template/subscription-stake-slash-succeeded';
 import createQueue from '../libs/queue';
-import { CheckoutSession, EventType, Invoice, PaymentLink, Payout, Refund, Subscription } from '../store/models';
+import {
+  CheckoutSession,
+  EventType,
+  Invoice,
+  PaymentLink,
+  Payout,
+  Refund,
+  Subscription,
+  Customer,
+} from '../store/models';
 import {
   UsageReportEmptyEmailTemplate,
   UsageReportEmptyEmailTemplateOptions,
@@ -73,9 +84,22 @@ import {
   CustomerRevenueSucceededEmailTemplate,
   CustomerRevenueSucceededEmailTemplateOptions,
 } from '../libs/notification/template/customer-revenue-succeeded';
+import {
+  AggregatedSubscriptionRenewedEmailTemplate,
+  AggregatedSubscriptionRenewedEmailTemplateOptions,
+} from '../libs/notification/template/aggregated-subscription-renewed';
+import type { TJob } from '../store/models/job';
 
 export type NotificationQueueJobOptions = any;
 
+interface NotificationPreference {
+  frequency: 'default' | 'daily' | 'weekly' | 'monthly';
+  schedule?: {
+    time: string; // HH:mm 格式
+    date?: number; // weekly: 0-6, monthly: 1-31
+  };
+}
+
 export type NotificationQueueJobType =
   | EventType
   | 'customer.subscription.will_renew'
@@ -91,6 +115,62 @@ export type NotificationQueueJob = {
   options: NotificationQueueJobOptions;
 };
 
+export interface AggregatedNotificationJob {
+  type: NotificationQueueJobType;
+  options: {
+    customer_id: string;
+    items: NotificationItem[];
+    time_range: {
+      start: number;
+      end: number;
+    };
+  };
+}
+
+function calculateNextNotificationTime(preference: NotificationPreference): number {
+  if (preference.frequency === 'default' || !preference.schedule) {
+    return Math.floor(Date.now() / 1000);
+  }
+
+  const now = dayjs();
+  const [hour = 10, minute = 0] = preference.schedule?.time ? preference.schedule.time.split(':').map(Number) : [10, 0];
+  let nextTime = dayjs().hour(hour).minute(minute).second(0);
+  const targetDate = preference.schedule?.date ?? 1;
+
+  switch (preference.frequency) {
+    case 'daily':
+      if (nextTime.isBefore(now)) {
+        nextTime = nextTime.add(1, 'day');
+      }
+      break;
+
+    case 'weekly':
+      nextTime = nextTime.day(targetDate);
+      if (nextTime.isBefore(now)) {
+        nextTime = nextTime.add(1, 'week');
+      }
+      break;
+
+    case 'monthly':
+      nextTime = nextTime.date(targetDate);
+      // if the date is not the same, set to the end of the month
+      if (nextTime.date() !== targetDate) {
+        nextTime = nextTime.endOf('month').hour(hour).minute(minute);
+      }
+      if (nextTime.isBefore(now)) {
+        nextTime = nextTime.add(1, 'month');
+        if (nextTime.date() !== targetDate) {
+          nextTime = nextTime.endOf('month').hour(hour).minute(minute);
+        }
+      }
+      break;
+    default:
+      throw new Error(`Unknown frequency: ${preference.frequency}`);
+  }
+
+  return Math.floor(nextTime.valueOf() / 1000);
+}
+
 function getNotificationTemplate(job: NotificationQueueJob): BaseEmailTemplate {
   if (job.type === 'usage.report.empty') {
     return new UsageReportEmptyEmailTemplate(job.options as UsageReportEmptyEmailTemplateOptions);
@@ -156,10 +236,158 @@ async function handleNotificationJob(job: NotificationQueueJob): Promise<void> {
   try {
     const template = getNotificationTemplate(job);
     await new Notification(template).send();
-    logger.info('handleNotificationJob.success', { job });
+    logger.info('handleImmediateNotificationJob.success', { job });
   } catch (error) {
-    logger.error('handleNotificationJob.error.$job', job);
-    logger.error('handleNotificationJob.error', error);
+    logger.error('handleImmediateNotificationJob.error', error);
+    throw error;
+  }
+}
+
+const MAX_AGGREGATED_ITEMS = 1000;
+
+interface NotificationItem<T = Record<string, any>> {
+  event_id: string;
+  occurred_at: number;
+  data: T;
+}
+
+/**
+ * Handles immediate notifications by pushing them directly to the notification queue
+ */
+function handleImmediateNotification(type: string, data: Record<string, any>, extraIds: string[] = []) {
+  const idParts = [type];
+  if (extraIds.length) {
+    idParts.push(...extraIds);
+  } else {
+    idParts.push(Date.now().toString());
+  }
+
+  return notificationQueue.push({
+    id: idParts.join('.'),
+    job: {
+      type,
+      options: data,
+    },
+  });
+}
+
+/**
+ * Handles aggregated notifications with support for:
+ * - Automatic fallback to immediate notification on error
+ * - Item limit enforcement
+ * - Time range tracking
+ */
+async function handleAggregatedNotification<T extends Record<string, any>>({
+  type,
+  customerId,
+  preference,
+  newItem,
+  extraIds,
+}: {
+  type: NotificationQueueJobType;
+  customerId: string;
+  preference: NotificationPreference;
+  newItem: NotificationItem<T>;
+  extraIds: string[];
+}) {
+  try {
+    const nextNotificationTime = calculateNextNotificationTime(preference);
+    const jobId = `${type}.${customerId}.${nextNotificationTime}`;
+    const existingJob = await aggregatedNotificationQueue.get(jobId);
+
+    if (existingJob) {
+      const updatedItems = [...(existingJob.options.items || []), newItem];
+
+      if (updatedItems.length >= MAX_AGGREGATED_ITEMS) {
+        await aggregatedNotificationQueue.push({
+          id: `${jobId}.immediate`,
+          job: {
+            type,
+            options: {
+              customer_id: customerId,
+              items: existingJob.options.items,
+              time_range: {
+                start: existingJob.options.time_range.start,
+                end: Math.floor(Date.now() / 1000),
+              },
+            },
+          },
+        });
+        logger.info('immediate aggregated notification job', { jobId });
+
+        await aggregatedNotificationQueue.update(jobId, {
+          job: {
+            type,
+            options: {
+              customer_id: customerId,
+              items: [newItem],
+              time_range: {
+                start: Math.floor(Date.now() / 1000),
+                end: nextNotificationTime,
+              },
+            },
+          },
+          runAt: nextNotificationTime,
+        });
+        logger.info('update aggregated notification job', { jobId });
+      } else {
+        await aggregatedNotificationQueue.update(jobId, {
+          job: {
+            type,
+            options: {
+              customer_id: customerId,
+              items: updatedItems,
+              time_range: {
+                start: existingJob.options.time_range.start,
+                end: nextNotificationTime,
+              },
+            },
+          },
+          runAt: nextNotificationTime,
+        });
+      }
+      logger.info('updated aggregated notification job', { jobId });
+    } else {
+      // Create new aggregation task
+      await aggregatedNotificationQueue.push({
+        id: jobId,
+        job: {
+          type,
+          options: {
+            customer_id: customerId,
+            items: [newItem],
+            time_range: {
+              start: Math.floor(Date.now() / 1000),
+              end: nextNotificationTime,
+            },
+          },
+        },
+        runAt: nextNotificationTime,
+      });
+    }
+    logger.info('created aggregated notification job', { jobId });
+  } catch (error) {
+    logger.error('Failed to handle aggregated notification', { error });
+    await handleImmediateNotification(type, newItem.data, extraIds);
+  }
+}
+
+function getAggregatedNotificationTemplate(job: AggregatedNotificationJob): BaseEmailTemplate {
+  if (job.type === 'customer.subscription.renewed') {
+    return new AggregatedSubscriptionRenewedEmailTemplate(
+      job.options as AggregatedSubscriptionRenewedEmailTemplateOptions
+    );
+  }
+  throw new Error(`Unknown aggregated notification type: ${job.type}`);
+}
+
+async function handleAggregatedNotificationJob(job: AggregatedNotificationJob): Promise<void> {
+  try {
+    const template = await getAggregatedNotificationTemplate(job);
+    await new Notification(template).send();
+    logger.info('handleAggregatedNotificationJob.success', { job });
+  } catch (error) {
+    logger.error('handleAggregatedNotificationJob.error', error);
     throw error;
   }
 }
@@ -174,6 +402,16 @@ export const notificationQueue = createQueue<NotificationQueueJob>({
   },
 });
 
+export const aggregatedNotificationQueue = createQueue<AggregatedNotificationJob>({
+  name: 'aggregated_notification',
+  onJob: handleAggregatedNotificationJob,
+  options: {
+    concurrency: 10,
+    maxRetries: 3,
+    enableScheduledJob: true,
+  },
+});
+
 /**
  *
  * @see https://team.arcblock.io/comment/discussions/0fba06ff-75b4-47d2-8c5c-f0379540ce03
@@ -239,16 +477,39 @@ export async function startNotificationQueue() {
     }
   });
 
-  events.on('customer.subscription.renewed', (subscription: Subscription) => {
-    notificationQueue.push({
-      id: `customer.subscription.renewed.${subscription.id}.${subscription.latest_invoice_id}`,
-      job: {
-        type: 'customer.subscription.renewed',
-        options: {
+  events.on('customer.subscription.renewed', async (subscription: Subscription) => {
+    const customer = await Customer.findByPk(subscription.customer_id);
+    const preference = customer?.preference?.notification;
+    if (!subscription.latest_invoice_id) {
+      logger.warn('Missing latest_invoice_id for subscription', { subscriptionId: subscription.id });
+      return;
+    }
+
+    if (!preference || preference.frequency === 'default') {
+      handleImmediateNotification(
+        'customer.subscription.renewed',
+        {
+          subscriptionId: subscription.id,
+          invoiceId: subscription.latest_invoice_id,
+        },
+        [subscription.id, subscription.latest_invoice_id]
+      );
+      return;
+    }
+
+    await handleAggregatedNotification({
+      type: 'customer.subscription.renewed',
+      customerId: customer.id,
+      preference,
+      newItem: {
+        event_id: `${subscription.id}.${subscription.latest_invoice_id}`,
+        occurred_at: Math.floor(Date.now() / 1000),
+        data: {
           subscriptionId: subscription.id,
           invoiceId: subscription.latest_invoice_id,
-        } as SubscriptionRenewedEmailTemplateOptions,
+        },
       },
+      extraIds: [subscription.id, subscription.latest_invoice_id],
     });
   });
 
@@ -362,3 +623,84 @@ export async function startNotificationQueue() {
     }
   });
 }
+
+export async function handleNotificationPreferenceChange(
+  customerId: string,
+  newPreference?: NotificationPreference
+): Promise<void> {
+  // 1. get pending scheduled jobs for this customer
+  const pendingJobs = await aggregatedNotificationQueue.store.findJobs({
+    delay: { [Op.not]: -1 },
+    will_run_at: { [Op.gt]: Date.now() },
+  });
+
+  const customerJobs = pendingJobs.filter((job: TJob) => job.job?.options?.customer_id === customerId);
+
+  if (!customerJobs.length) {
+    return;
+  }
+
+  // 2. if changed to immediate notification, delete the old job and create a new one immediately
+  if (newPreference?.frequency === 'default') {
+    /* eslint-disable no-await-in-loop */
+    for (const job of customerJobs) {
+      try {
+        await aggregatedNotificationQueue.delete(job.id);
+        aggregatedNotificationQueue.push({
+          id: job.id,
+          job: {
+            ...job.job,
+            options: {
+              ...job.job.options,
+              time_range: {
+                start: job.job.options.time_range.start,
+                end: Math.floor(Date.now() / 1000),
+              },
+            },
+          },
+        });
+      } catch (error) {
+        logger.error('Failed to process immediate notification job', { error, jobId: job.id });
+      }
+    }
+    /* eslint-enable no-await-in-loop */
+    return;
+  }
+
+  // 3. for other frequency changes, recalculate the send time
+  if (newPreference) {
+    /* eslint-disable no-await-in-loop */
+    for (const job of customerJobs) {
+      try {
+        const nextTime = calculateNextNotificationTime(newPreference);
+        const oldScheduleTime = job.will_run_at ? job.will_run_at / 1000 : 0;
+
+        // if next notification time is different from the old schedule time, update the job
+        if (nextTime !== oldScheduleTime) {
+          // Keep the original job id format but update the timestamp
+          const jobIdParts = job.id.split('.');
+          const jobId = `${jobIdParts.slice(0, -1).join('.')}.${nextTime}`;
+
+          await aggregatedNotificationQueue.delete(job.id);
+          aggregatedNotificationQueue.push({
+            id: jobId,
+            job: {
+              ...job.job,
+              options: {
+                ...job.job.options,
+                time_range: {
+                  start: job.job.options.time_range.start,
+                  end: nextTime,
+                },
+              },
+            },
+            runAt: nextTime,
+          });
+        }
+      } catch (error) {
+        logger.error('Failed to process notification job', { error, jobId: job.id });
+      }
+    }
+    /* eslint-enable no-await-in-loop */
+  }
+}

package/api/src/queues/payment.ts

@@ -45,6 +45,8 @@ type PaymentJob = {
   paymentIntentId: string;
   paymentSettings?: PaymentSettings;
   retryOnError?: boolean;
+  ignoreMaxRetryCheck?: boolean;
+  immediateRetry?: boolean;
 };
 
 type DepositVaultJob = {
@@ -721,7 +723,7 @@ export const handlePayment = async (job: PaymentJob) => {
   }
 
   // check max retry before doing any hard work
-  if (invoice && invoice.attempt_count >= MAX_RETRY_COUNT) {
+  if (invoice && invoice.attempt_count >= MAX_RETRY_COUNT && !job.ignoreMaxRetryCheck) {
     logger.info('PaymentIntent capture aborted since max retry exceeded', { id: paymentIntent.id });
     const updates = await handlePaymentFailed(
       paymentIntent,
@@ -882,7 +884,7 @@ export const handlePayment = async (job: PaymentJob) => {
     };
 
     if (!job.retryOnError) {
-      // To a final state without any retry
+      //  To a final state without any retry
       await paymentIntent.update({ status: 'requires_action', last_payment_error: error });
       if (invoice) {
         await invoice.update({
@@ -924,7 +926,6 @@ export const handlePayment = async (job: PaymentJob) => {
           }
         }
       }
-
       // reschedule next attempt
       const retryAt = updates.invoice.next_payment_attempt;
       if (retryAt) {
@@ -993,16 +994,31 @@ events.on('payment.queued', async (id, job, args = {}) => {
         job,
         ...extraArgs,
       });
-      events.emit('payment.queued.done');
+      events.emit('payment.queued.done', { id, job });
     } catch (error) {
       logger.error('Error in payment.queued', { id, job, error });
-      events.emit('payment.queued.error', error);
+      events.emit('payment.queued.error', { id, job, error });
     }
     return;
   }
-  paymentQueue.push({
-    id,
-    job,
-    ...extraArgs,
-  });
+
+  try {
+    const existingJob = await paymentQueue.get(id);
+    if (existingJob) {
+      await paymentQueue.delete(id);
+      logger.info('Removed existing payment job for immediate execution', {
+        id,
+        originalRunAt: existingJob.runAt,
+      });
+    }
+    paymentQueue.push({
+      id,
+      job,
+      ...extraArgs,
+    });
+    events.emit('payment.queued.done', { id, job });
+  } catch (error) {
+    logger.error('Error in payment.queued', { id, job, error });
+    events.emit('payment.queued.error', { id, job, error });
+  }
 });

package/api/src/queues/payout.ts

@@ -282,16 +282,30 @@ events.on('payout.queued', async (id, job, args = {}) => {
         job,
         ...extraArgs,
       });
-      events.emit('payout.queued.done');
+      events.emit('payout.queued.done', { id, job });
     } catch (error) {
       logger.error('Error in payout.queued', { id, job, error });
-      events.emit('payout.queued.error', error);
+      events.emit('payout.queued.error', { id, job, error });
     }
     return;
   }
-  payoutQueue.push({
-    id,
-    job,
-    ...extraArgs,
-  });
+  try {
+    const existJob = await payoutQueue.get(id);
+    if (existJob) {
+      await payoutQueue.delete(id);
+      logger.info('Removed existing payout job for immediate execution', {
+        id,
+        originalRunAt: existJob.runAt,
+      });
+    }
+    payoutQueue.push({
+      id,
+      job,
+      ...extraArgs,
+    });
+    events.emit('payout.queued.done', { id, job });
+  } catch (error) {
+    logger.error('Error in payout.queued', { id, job, error });
+    events.emit('payout.queued.error', { id, job, error });
+  }
 });

package/api/src/routes/checkout-sessions.ts

@@ -856,10 +856,17 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       });
       logger.info('customer created on checkout session submit', { did: req.user.did, id: customer.id });
       try {
-        await blocklet.updateUserAddress({
-          did: customer.did,
-          address: Customer.formatAddressFromCustomer(customer),
-        });
+        await blocklet.updateUserAddress(
+          {
+            did: customer.did,
+            address: Customer.formatAddressFromCustomer(customer),
+          },
+          {
+            headers: {
+              cookie: req.headers.cookie || '',
+            },
+          }
+        );
         logger.info('updateUserAddress success', {
           did: customer.did,
         });
@@ -870,14 +877,14 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         });
       }
     } else {
-      const updates: Record<string, string> = {};
+      const updates: Record<string, any> = {};
       if (checkoutSession.customer_update?.name) {
         updates.name = req.body.customer_name;
         updates.email = req.body.customer_email;
         updates.phone = req.body.customer_phone;
       }
       if (checkoutSession.customer_update?.address) {
-        updates.address = req.body.billing_address;
+        updates.address = Customer.formatUpdateAddress(req.body.billing_address, customer);
       }
       if (!customer.invoice_prefix) {
         updates.invoice_prefix = Customer.getInvoicePrefix();
@@ -885,12 +892,19 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
 
       await customer.update(updates);
       try {
-        await blocklet.updateUserAddress({
-          did: customer.did,
-          address: Customer.formatAddressFromCustomer(customer),
-          // @ts-ignore
-          phone: customer.phone,
-        });
+        await blocklet.updateUserAddress(
+          {
+            did: customer.did,
+            address: Customer.formatAddressFromCustomer(customer),
+            // @ts-ignore
+            phone: customer.phone,
+          },
+          {
+            headers: {
+              cookie: req.headers.cookie || '',
+            },
+          }
+        );
         logger.info('updateUserAddress success', {
           did: customer.did,
         });

package/api/src/routes/connect/recharge-account.ts

@@ -6,7 +6,7 @@ import { getGasPayerExtra } from '../../libs/payment';
 import { getTxMetadata } from '../../libs/util';
 import { ensureAccountRecharge, getAuthPrincipalClaim } from './shared';
 import logger from '../../libs/logger';
-import { ensureRechargeInvoice } from '../../libs/invoice';
+import { ensureRechargeInvoice, retryUncollectibleInvoices } from '../../libs/invoice';
 
 export default {
   action: 'recharge-account',
@@ -86,6 +86,18 @@ export default {
         paymentMethod,
         customer!
       );
+      try {
+        retryUncollectibleInvoices({
+          customerId: customer.id,
+          currencyId: paymentCurrency.id,
+        });
+      } catch (err) {
+        logger.error('Failed to retry uncollectible invoices', {
+          error: err,
+          customerId: customer.id,
+          currencyId: paymentCurrency.id,
+        });
+      }
     };
     if (paymentMethod.type === 'arcblock') {
       try {