payment-kit 1.24.4 → 1.25.1

package/api/src/libs/notification/template/subscription-slippage-exceeded.ts

@@ -0,0 +1,203 @@
+/* eslint-disable @typescript-eslint/brace-style */
+import { getUserLocale } from '../../../integrations/blocklet/notification';
+import { translate } from '../../../locales';
+import { Customer, Invoice, Subscription } from '../../../store/models';
+import { getCustomerInvoicePageUrl } from '../../invoice';
+import { getMainProductName } from '../../product';
+import { getCustomerSubscriptionPageUrl } from '../../subscription';
+import { getSubscriptionNotificationCustomActions } from '../../util';
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+
+export interface SubscriptionSlippageExceededEmailTemplateOptions {
+  subscriptionId: string;
+  invoiceId: string;
+  paymentIntentId: string;
+  currentRate: string;
+  minAcceptableRate: string;
+}
+
+interface SubscriptionSlippageExceededEmailTemplateContext {
+  locale: string;
+  productName: string;
+  userDid: string;
+  currentRate: string;
+  minAcceptableRate: string;
+  viewSubscriptionLink: string;
+  viewInvoiceLink: string;
+  customActions: any[];
+}
+
+export class SubscriptionSlippageExceededEmailTemplate
+  implements BaseEmailTemplate<SubscriptionSlippageExceededEmailTemplateContext>
+{
+  options: SubscriptionSlippageExceededEmailTemplateOptions;
+
+  constructor(options: SubscriptionSlippageExceededEmailTemplateOptions) {
+    this.options = options;
+  }
+
+  async getContext(): Promise<SubscriptionSlippageExceededEmailTemplateContext> {
+    const subscription = await Subscription.findByPk(this.options.subscriptionId);
+    if (!subscription) {
+      throw new Error(`Subscription not found: ${this.options.subscriptionId}`);
+    }
+
+    const customer = await Customer.findByPk(subscription.customer_id);
+    if (!customer) {
+      throw new Error(`Customer not found: ${subscription.customer_id}`);
+    }
+
+    const invoice = await Invoice.findByPk(this.options.invoiceId);
+    if (!invoice) {
+      throw new Error(`Invoice not found: ${this.options.invoiceId}`);
+    }
+
+    const userDid = customer.did;
+    const locale = await getUserLocale(userDid);
+    const productName = await getMainProductName(subscription.id);
+
+    const viewSubscriptionLink = getCustomerSubscriptionPageUrl({
+      subscriptionId: subscription.id,
+      locale,
+      userDid,
+    });
+
+    const viewInvoiceLink = getCustomerInvoicePageUrl({
+      invoiceId: invoice.id,
+      userDid,
+      locale,
+      action: 'pay',
+    });
+
+    const customActions = getSubscriptionNotificationCustomActions(
+      subscription,
+      'subscription.slippage_exceeded',
+      locale
+    );
+
+    return {
+      locale,
+      productName,
+      userDid,
+      currentRate: this.options.currentRate,
+      minAcceptableRate: this.options.minAcceptableRate,
+      viewSubscriptionLink,
+      viewInvoiceLink,
+      customActions,
+    };
+  }
+
+  async getTemplate(): Promise<BaseEmailTemplateType> {
+    const {
+      locale,
+      productName,
+      userDid,
+      currentRate,
+      minAcceptableRate,
+      viewSubscriptionLink,
+      viewInvoiceLink,
+      customActions,
+    } = await this.getContext();
+
+    const template: BaseEmailTemplateType = {
+      title: translate('notification.subscriptionSlippageExceeded.title', locale, {
+        productName,
+      }),
+      body: translate('notification.subscriptionSlippageExceeded.body', locale, {
+        productName,
+        currentRate,
+        minAcceptableRate,
+      }),
+      // @ts-ignore
+      attachments: [
+        {
+          type: 'section',
+          fields: [
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.account', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: userDid,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.product', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: productName,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.subscriptionSlippageExceeded.currentRate', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#FF0000',
+                text: currentRate,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.subscriptionSlippageExceeded.minAcceptableRate', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: minAcceptableRate,
+              },
+            },
+          ],
+        },
+      ],
+      // @ts-ignore
+      actions: [
+        {
+          name: translate('notification.subscriptionSlippageExceeded.payNow', locale),
+          title: translate('notification.subscriptionSlippageExceeded.payNow', locale),
+          link: viewInvoiceLink,
+        },
+        {
+          name: translate('notification.common.viewSubscription', locale),
+          title: translate('notification.common.viewSubscription', locale),
+          link: viewSubscriptionLink,
+        },
+        {
+          name: translate('notification.subscriptionSlippageExceeded.adjustSlippage', locale),
+          title: translate('notification.subscriptionSlippageExceeded.adjustSlippage', locale),
+          link: viewSubscriptionLink,
+        },
+        ...customActions,
+      ].filter(Boolean),
+    };
+
+    return template;
+  }
+}

package/api/src/libs/notification/template/subscription-slippage-warning.ts

@@ -0,0 +1,212 @@
+/* eslint-disable @typescript-eslint/brace-style */
+import prettyMsI18n from 'pretty-ms-i18n';
+
+import { getUserLocale } from '../../../integrations/blocklet/notification';
+import { translate } from '../../../locales';
+import { Customer, Subscription } from '../../../store/models';
+import { getMainProductName } from '../../product';
+import { getCustomerSubscriptionPageUrl } from '../../subscription';
+import { formatTime, getPrettyMsI18nLocale } from '../../time';
+import { getSubscriptionNotificationCustomActions } from '../../util';
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+
+export interface SubscriptionSlippageWarningEmailTemplateOptions {
+  subscriptionId: string;
+  currentRate: string;
+  minAcceptableRate: string;
+  renewalTime: number; // Unix timestamp in seconds
+}
+
+interface SubscriptionSlippageWarningEmailTemplateContext {
+  locale: string;
+  productName: string;
+  userDid: string;
+  currentRate: string;
+  minAcceptableRate: string;
+  renewalTime: string;
+  timeUntilRenewal: string;
+  viewSubscriptionLink: string;
+  customActions: any[];
+}
+
+export class SubscriptionSlippageWarningEmailTemplate
+  implements BaseEmailTemplate<SubscriptionSlippageWarningEmailTemplateContext>
+{
+  options: SubscriptionSlippageWarningEmailTemplateOptions;
+
+  constructor(options: SubscriptionSlippageWarningEmailTemplateOptions) {
+    this.options = options;
+  }
+
+  async getContext(): Promise<SubscriptionSlippageWarningEmailTemplateContext> {
+    const subscription = await Subscription.findByPk(this.options.subscriptionId);
+    if (!subscription) {
+      throw new Error(`Subscription not found: ${this.options.subscriptionId}`);
+    }
+
+    const customer = await Customer.findByPk(subscription.customer_id);
+    if (!customer) {
+      throw new Error(`Customer not found: ${subscription.customer_id}`);
+    }
+
+    const userDid = customer.did;
+    const locale = await getUserLocale(userDid);
+    const productName = await getMainProductName(subscription.id);
+
+    const renewalTimeMs = this.options.renewalTime * 1000;
+    const renewalTime = formatTime(renewalTimeMs);
+    const timeUntilRenewal = prettyMsI18n(renewalTimeMs - Date.now(), {
+      locale: getPrettyMsI18nLocale(locale),
+    });
+
+    const viewSubscriptionLink = getCustomerSubscriptionPageUrl({
+      subscriptionId: subscription.id,
+      locale,
+      userDid,
+    });
+
+    const customActions = getSubscriptionNotificationCustomActions(
+      subscription,
+      'subscription.slippage_warning',
+      locale
+    );
+
+    return {
+      locale,
+      productName,
+      userDid,
+      currentRate: this.options.currentRate,
+      minAcceptableRate: this.options.minAcceptableRate,
+      renewalTime,
+      timeUntilRenewal,
+      viewSubscriptionLink,
+      customActions,
+    };
+  }
+
+  async getTemplate(): Promise<BaseEmailTemplateType> {
+    const {
+      locale,
+      productName,
+      userDid,
+      currentRate,
+      minAcceptableRate,
+      renewalTime,
+      timeUntilRenewal,
+      viewSubscriptionLink,
+      customActions,
+    } = await this.getContext();
+
+    const template: BaseEmailTemplateType = {
+      title: translate('notification.subscriptionSlippageWarning.title', locale, {
+        productName,
+      }),
+      body: translate('notification.subscriptionSlippageWarning.body', locale, {
+        productName,
+        currentRate,
+        minAcceptableRate,
+        timeUntilRenewal,
+      }),
+      // @ts-ignore
+      attachments: [
+        {
+          type: 'section',
+          fields: [
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.account', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: userDid,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.product', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: productName,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.subscriptionSlippageWarning.renewalTime', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: renewalTime,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.subscriptionSlippageWarning.currentRate', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#FF6600',
+                text: currentRate,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.subscriptionSlippageWarning.minAcceptableRate', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: minAcceptableRate,
+              },
+            },
+          ],
+        },
+      ],
+      // @ts-ignore
+      actions: [
+        {
+          name: translate('notification.common.viewSubscription', locale),
+          title: translate('notification.common.viewSubscription', locale),
+          link: viewSubscriptionLink,
+        },
+        {
+          name: translate('notification.subscriptionSlippageWarning.adjustSlippage', locale),
+          title: translate('notification.subscriptionSlippageWarning.adjustSlippage', locale),
+          link: viewSubscriptionLink,
+        },
+        ...customActions,
+      ].filter(Boolean),
+    };
+
+    return template;
+  }
+}

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

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/brace-style */
 /* eslint-disable @typescript-eslint/indent */
-import { fromUnitToToken } from '@ocap/util';
 import type { ManipulateType } from 'dayjs';
 
 import dayjs from '../../dayjs';
 import { translate } from '../../../locales';
 import { Invoice, PaymentCurrency, PaymentMethod } from '../../../store/models';
 import { formatTime, getSimplifyDuration } from '../../time';
+import { formatTokenAmount } from '../../util';
 import { BaseSubscriptionEmailTemplate, BaseEmailTemplateType } from './base';
 
 export interface SubscriptionWillCanceledEmailTemplateOptions {
@@ -90,7 +90,7 @@ export class SubscriptionWillCanceledEmailTemplate extends BaseSubscriptionEmail
     const willCancelDuration = getSimplifyDuration((cancelAt - now) * 1000, locale);
 
     // @ts-ignore
-    const paymentInfo = `${fromUnitToToken(+invoice.total, invoice?.paymentCurrency?.decimal)} ${invoice?.paymentCurrency?.symbol}${invoice?.paymentMethod ? `(${invoice?.paymentMethod.name})` : ''}`;
+    const paymentInfo = `${formatTokenAmount(invoice.total, invoice?.paymentCurrency?.decimal)} ${invoice?.paymentCurrency?.symbol}${invoice?.paymentMethod ? `(${invoice?.paymentMethod.name})` : ''}`;
 
     let body = translate('notification.subscriptWillCanceled.body', locale, {
       productName,

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

@@ -3,16 +3,15 @@
 import type { ManipulateType } from 'dayjs';
 import type { LiteralUnion } from 'type-fest';
 
-import { fromUnitToToken } from '@ocap/util';
 import dayjs from '../../dayjs';
 import { getTokenByAddress } from '../../../integrations/arcblock/stake';
 import { translate } from '../../../locales';
 import { Invoice, Price, SubscriptionItem } from '../../../store/models';
 import type { PaymentDetail } from '../../payment';
-import { getSubscriptionPaymentAddress, getPaymentAmountForCycleSubscription } from '../../subscription';
+import { getSubscriptionPaymentAddress, getEstimatedPaymentAmountForCycleSubscription } from '../../subscription';
 
 import { formatTime, getSimplifyDuration } from '../../time';
-import { formatCurrencyInfo, getCustomerRechargeLink } from '../../util';
+import { formatCurrencyInfo, formatTokenAmount, getCustomerRechargeLink } from '../../util';
 import { BaseSubscriptionEmailTemplate, BaseEmailTemplateType } from './base';
 
 export interface SubscriptionWillRenewEmailTemplateOptions {
@@ -91,7 +90,8 @@ export class SubscriptionWillRenewEmailTemplate extends BaseSubscriptionEmailTem
     const at = formatTime(periodEnd * 1000);
     const willRenewDuration = getSimplifyDuration((periodEnd - dayjs().unix()) * 1000, locale);
 
-    const paymentAmount = await getPaymentAmountForCycleSubscription(subscription, paymentCurrency);
+    const paymentAmountResult = await getEstimatedPaymentAmountForCycleSubscription(subscription, paymentCurrency);
+    const paymentAmount = paymentAmountResult.amount;
     const paymentDetail = { price: paymentAmount, balance: 0, symbol: paymentCurrency.symbol, balanceFormatted: '0' };
 
     // 获取余额信息（非 Stripe 支付方式）
@@ -100,7 +100,7 @@ export class SubscriptionWillRenewEmailTemplate extends BaseSubscriptionEmailTem
       const paymentAddress = getSubscriptionPaymentAddress(subscription, paymentInfoResult.paymentMethod!.type);
       const balance = await getTokenByAddress(paymentAddress, paymentInfoResult.paymentMethod!, paymentCurrency);
 
-      paymentDetail.balanceFormatted = fromUnitToToken(balance || '0', paymentCurrency.decimal);
+      paymentDetail.balanceFormatted = formatTokenAmount(balance || '0', paymentCurrency.decimal);
       paymentDetail.balance = +paymentDetail.balanceFormatted;
     }
 
@@ -120,9 +120,23 @@ export class SubscriptionWillRenewEmailTemplate extends BaseSubscriptionEmailTem
       true
     );
 
-    const paymentInfo = isMetered
-      ? translate('notification.subscriptionWillRenew.estimatedAmountNote', locale, { amount: basePaymentInfo })
-      : basePaymentInfo;
+    // Determine payment info message based on estimation type
+    let paymentInfo: string;
+    if (paymentAmountResult.estimatedByRate && isMetered) {
+      paymentInfo = translate('notification.subscriptionWillRenew.estimatedAmountNoteRateAndUsage', locale, {
+        amount: basePaymentInfo,
+      });
+    } else if (paymentAmountResult.estimatedByRate) {
+      paymentInfo = translate('notification.subscriptionWillRenew.estimatedAmountNoteRate', locale, {
+        amount: basePaymentInfo,
+      });
+    } else if (isMetered) {
+      paymentInfo = translate('notification.subscriptionWillRenew.estimatedAmountNote', locale, {
+        amount: basePaymentInfo,
+      });
+    } else {
+      paymentInfo = basePaymentInfo;
+    }
 
     // 计算周期时间 - 使用安全的回退机制
     const periodStart = invoice?.period_start || subscription.current_period_start;

package/api/src/libs/payment.ts

@@ -33,7 +33,7 @@ import {
 } from './util';
 import { CHARGE_SUPPORTED_CHAIN_TYPES, EVM_CHAIN_TYPES } from './constants';
 import { getTokenByAddress } from '../integrations/arcblock/stake';
-import { isCreditMetered } from './session';
+import { isCreditMetered } from './credit-utils';
 
 export interface SufficientForPaymentResult {
   sufficient: boolean;
@@ -255,10 +255,12 @@ export async function isDelegationSufficientForPayment(args: {
     const address = toDelegateAddress(delegator, wallet.address);
     const { state } = await client.getDelegateState({ address });
     if (!state) {
+      logger.error('isDelegationSufficientForPayment: no delegation state', { address, delegator });
       return { sufficient: false, reason: 'NO_DELEGATION' };
     }
 
     if (!state.ops || state.ops?.length === 0) {
+      logger.error('isDelegationSufficientForPayment: no delegation ops', { address, delegator });
       return { sufficient: false, reason: 'NO_DELEGATION' };
     }
 

package/api/src/libs/price.ts

@@ -4,7 +4,10 @@ import type { PriceCurrency } from '../store/models/types';
 /**
  * Get price currency options for a given price
  */
-export function getPriceCurrencyOptions(price: Price | TPriceExpanded): PriceCurrency[] {
+export function getPriceCurrencyOptions(price: Price | TPriceExpanded | null | undefined): PriceCurrency[] {
+  if (!price) {
+    return [];
+  }
   if (Array.isArray(price.currency_options)) {
     return price.currency_options;
   }

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

@@ -180,6 +180,14 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
           return;
         }
 
+        // Check if error is marked as non-retryable
+        if (err && err.nonRetryable === true) {
+          logger.info('fail job due to non-retryable error', { id: jobId, job, errorCode: err.code });
+          await clearJob(jobId);
+          emit('failed', { id: jobId, job, error: err });
+          return;
+        }
+
         // @ts-ignore
         if (doc.retry_count >= maxRetries) {
           logger.info('fail job on max retry exceed', { id: jobId, job });