payment-kit 1.15.1 → 1.15.3

package/api/src/libs/notification/template/subscription-stake-slash-succeeded.ts

@@ -0,0 +1,228 @@
+/* eslint-disable prettier/prettier */
+import { fromUnitToToken } from '@ocap/util';
+import { getUserLocale } from '../../../integrations/blocklet/notification';
+import { translate } from '../../../locales';
+import { Customer, PaymentIntent, PaymentMethod, Subscription } from '../../../store/models';
+import { Invoice } from '../../../store/models/invoice';
+import { PaymentCurrency } from '../../../store/models/payment-currency';
+import { getMainProductName } from '../../product';
+import { getCustomerSubscriptionPageUrl } from '../../subscription';
+import { formatTime } from '../../time';
+import { getExplorerLink } from '../../util';
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+import logger from '../../logger';
+
+export interface SubscriptionStakeSlashSucceededEmailTemplateOptions {
+  paymentIntentId: string;
+  subscriptionId: string;
+  invoiceId: string;
+}
+
+interface SubscriptionStakeSlashSucceededEmailTemplateContext {
+  locale: string;
+  productName: string;
+  at: string;
+
+  userDid: string;
+  slashInfo: string;
+  slashReason: string;
+
+  viewSubscriptionLink: string;
+  viewTxHashLink: string | undefined;
+}
+
+export class SubscriptionStakeSlashSucceededEmailTemplate
+  implements BaseEmailTemplate<SubscriptionStakeSlashSucceededEmailTemplateContext> {
+  options: SubscriptionStakeSlashSucceededEmailTemplateOptions;
+
+  constructor(options: SubscriptionStakeSlashSucceededEmailTemplateOptions) {
+    this.options = options;
+  }
+
+  async getContext(): Promise<SubscriptionStakeSlashSucceededEmailTemplateContext> {
+    const invoice = await Invoice.findByPk(this.options.invoiceId);
+    if (!invoice) {
+      throw new Error(`Invoice not found: ${this.options.invoiceId}`);
+    }
+    if (invoice?.billing_reason !== 'slash_stake') {
+      throw new Error(`Invoice billing_reason not slash_stake: ${this.options.invoiceId}`);
+    }
+    const paymentIntent = await PaymentIntent.findByPk(this.options.paymentIntentId);
+
+    if (!paymentIntent) {
+      throw new Error(`PaymentIntent not found: ${this.options.paymentIntentId}`);
+    }
+    if (paymentIntent.status !== 'succeeded') {
+      throw new Error(`SlashStake not succeeded: ${this.options.paymentIntentId}`);
+    }
+
+    const subscription = await Subscription.findByPk(this.options.subscriptionId);
+
+    if (!subscription) {
+      throw new Error(`Subscription not found: ${this.options.subscriptionId}`);
+    }
+
+    if (subscription.status !== 'canceled') {
+      throw new Error(`Subscription status not cancelled: ${this.options.subscriptionId}`);
+    }
+
+    const customer = await Customer.findByPk(subscription.customer_id);
+    if (!customer) {
+      throw new Error(`Customer not found: ${subscription.customer_id}`);
+    }
+
+    const paymentCurrency = (await PaymentCurrency.findOne({
+      where: {
+        id: subscription.currency_id,
+      },
+    })) as PaymentCurrency;
+
+    const userDid: string = customer.did;
+    const locale = await getUserLocale(userDid);
+    const productName = await getMainProductName(this.options.subscriptionId);
+    const at: string = formatTime(paymentIntent.created_at);
+
+    const slashInfo: string = `${fromUnitToToken(paymentIntent?.amount_received || '0', paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
+
+    const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(paymentIntent.payment_method_id);
+    // @ts-expect-error
+    const chainHost: string | undefined = paymentMethod?.settings?.[paymentMethod.type]?.api_host;
+    const viewSubscriptionLink = getCustomerSubscriptionPageUrl({
+      subscriptionId: this.options.subscriptionId,
+      locale,
+      userDid,
+    });
+
+    // @ts-expect-error
+    const txHash: string | undefined = paymentIntent?.payment_details?.[paymentMethod.type]?.tx_hash;
+    const viewTxHashLink: string | undefined =
+      txHash &&
+      getExplorerLink({
+        type: 'tx',
+        did: txHash,
+        chainHost,
+      });
+
+    const slashReason = subscription?.cancelation_details?.slash_reason || 'admin slash';
+
+    return {
+      locale,
+      productName,
+      at,
+
+      userDid,
+      slashInfo,
+      slashReason,
+      viewSubscriptionLink,
+      viewTxHashLink,
+    };
+  }
+
+  async getTemplate(): Promise<BaseEmailTemplateType> {
+    const {
+      locale,
+      productName,
+      at,
+
+      userDid,
+      slashInfo,
+      slashReason,
+      viewSubscriptionLink,
+      viewTxHashLink,
+    } = await this.getContext();
+
+    logger.info('SubscriptionStakeSlashSucceededEmailTemplate getTemplate', { productName, at, userDid, slashInfo, viewSubscriptionLink, viewTxHashLink });
+    const template: BaseEmailTemplateType = {
+      title: `${translate('notification.subscriptionStakeSlashSucceeded.title', locale, {
+        productName,
+      })}`,
+      body: `${translate('notification.subscriptionStakeSlashSucceeded.body', locale, {
+        at,
+        productName,
+        slashInfo,
+      })}`,
+      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.common.slashAmount', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: slashInfo,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.slashReason', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: slashReason,
+              },
+            },
+          ],
+        },
+      ],
+      // @ts-ignore
+      actions: [
+        {
+          name: translate('notification.common.viewSubscription', locale),
+          title: translate('notification.common.viewSubscription', locale),
+          link: viewSubscriptionLink,
+        },
+        viewTxHashLink && {
+          name: translate('notification.common.viewTxHash', locale),
+          title: translate('notification.common.viewTxHash', locale),
+          link: viewTxHashLink as string,
+        },
+      ].filter(Boolean),
+    };
+
+    return template;
+  }
+}

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

@@ -118,8 +118,8 @@ export class SubscriptionSucceededEmailTemplate
     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((subscription.current_period_start || invoice.period_start) * 1000);
+    const currentPeriodEnd: string = formatTime((subscription.current_period_end || invoice.period_end) * 1000);
     const duration: string = prettyMsI18n(
       new Date(currentPeriodEnd).getTime() - new Date(currentPeriodStart).getTime(),
       {

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

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/brace-style */
 /* eslint-disable @typescript-eslint/indent */
-import { toDid } from '@ocap/util';
+import { fromUnitToToken, toDid } from '@ocap/util';
 import pWaitFor from 'p-wait-for';
 import prettyMsI18n from 'pretty-ms-i18n';
 
@@ -65,18 +65,15 @@ export class SubscriptionTrialStartEmailTemplate
             subscription_id: subscription.id,
           },
         });
-
-        return ['minted', 'sent', 'error'].includes(checkoutSession?.nft_mint_status as string);
+        return ['minted', 'sent', 'error', 'disabled'].includes(checkoutSession?.nft_mint_status as string);
       },
       { timeout: 1000 * 10, interval: 1000 }
     );
 
-    const invoice: Invoice = (await Invoice.findOne({
-      where: {
-        subscription_id: subscription.id,
-        total: 0,
-      },
-    })) as Invoice;
+    const invoice: Invoice = (await Invoice.findByPk(subscription.latest_invoice_id)) as Invoice;
+    if (!invoice) {
+      throw new Error(`Invoice not found in subscription: ${subscription.id}`);
+    }
 
     const paymentCurrency = (await PaymentCurrency.findOne({
       where: {
@@ -102,7 +99,7 @@ export class SubscriptionTrialStartEmailTemplate
     const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(invoice.default_payment_method_id);
     const chainHost: string | undefined =
       paymentMethod?.settings?.[checkoutSession?.nft_mint_details?.type as 'arcblock' | 'ethereum']?.api_host;
-    const paymentInfo: string = `0 ${paymentCurrency.symbol}`;
+    const paymentInfo: string = `${fromUnitToToken(invoice?.total || '0', paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
     const currentPeriodStart: string = formatTime((subscription.trial_start as number) * 1000);
     const currentPeriodEnd: string = formatTime((subscription.trial_end as number) * 1000);
     const duration: string = prettyMsI18n(

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

@@ -4,11 +4,12 @@ import { fromUnitToToken } from '@ocap/util';
 import type { ManipulateType } from 'dayjs';
 import prettyMsI18n from 'pretty-ms-i18n';
 
+import { getTokenSummaryByDid } from '@api/integrations/arcblock/stake';
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
-import { Customer, Invoice, Subscription } from '../../../store/models';
+import { Customer, Subscription } from '../../../store/models';
 import { PaymentCurrency } from '../../../store/models/payment-currency';
-import { PaymentDetail, getPaymentDetail } from '../../payment';
+import { PaymentDetail, getPaymentAmountForCycleSubscription } from '../../payment';
 import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
@@ -63,7 +64,7 @@ export class SubscriptionTrialWilEndEmailTemplate
       throw new Error(`Customer not found: ${subscription.customer_id}`);
     }
 
-    const invoice = (await Invoice.findByPk(subscription.latest_invoice_id)) as Invoice;
+    // const invoice = (await Invoice.findByPk(subscription.latest_invoice_id)) as Invoice;
     const paymentCurrency = (await PaymentCurrency.findOne({
       where: {
         id: subscription.currency_id,
@@ -77,8 +78,15 @@ export class SubscriptionTrialWilEndEmailTemplate
     const willRenewDuration: string =
       locale === 'en' ? this.getWillRenewDuration(locale) : this.getWillRenewDuration(locale).split(' ').join('');
 
-    const paymentDetail: PaymentDetail = await getPaymentDetail(userDid, invoice);
-    const paymentInfo: string = `${fromUnitToToken(+invoice.total, paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
+    // const paymentDetail: PaymentDetail = await getPaymentDetail(userDid, invoice);
+
+    const paymentAmount = await getPaymentAmountForCycleSubscription(subscription, paymentCurrency);
+    const paymentDetail = { price: paymentAmount, balance: 0, symbol: paymentCurrency.symbol };
+
+    const token = await getTokenSummaryByDid(userDid, customer.livemode);
+
+    paymentDetail.balance = +fromUnitToToken(token?.[paymentCurrency.id] || '0', paymentCurrency.decimal);
+    const paymentInfo: string = `${paymentAmount} ${paymentCurrency.symbol}`;
     const currentPeriodStart: string = formatTime((subscription.trial_start as number) * 1000);
     const currentPeriodEnd: string = formatTime((subscription.trial_end as number) * 1000);
     const duration: string = prettyMsI18n(

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

@@ -1,18 +1,19 @@
 /* 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 prettyMsI18n from 'pretty-ms-i18n';
 import type { LiteralUnion } from 'type-fest';
 
+import { getTokenSummaryByDid } from '@api/integrations/arcblock/stake';
+import { fromUnitToToken } from '@ocap/util';
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
 import { Customer, Invoice, PaymentMethod, Price, Subscription, SubscriptionItem } from '../../../store/models';
 import { PaymentCurrency } from '../../../store/models/payment-currency';
-import { PaymentDetail, getPaymentDetail } from '../../payment';
+import { getPaymentAmountForCycleSubscription, type PaymentDetail } from '../../payment';
 import { getMainProductName } from '../../product';
-import { getCustomerSubscriptionPageUrl, getUpcomingInvoiceAmount } from '../../subscription';
+import { getCustomerSubscriptionPageUrl } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
 import { getExplorerLink } from '../../util';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
@@ -40,6 +41,7 @@ interface SubscriptionWillRenewEmailTemplateContext {
 
   viewSubscriptionLink: string;
   addFundsLink: string;
+  paymentMethod: PaymentMethod | null;
 }
 
 export class SubscriptionWillRenewEmailTemplate
@@ -85,18 +87,24 @@ export class SubscriptionWillRenewEmailTemplate
     const willRenewDuration: string =
       locale === 'en' ? this.getWillRenewDuration(locale) : this.getWillRenewDuration(locale).split(' ').join('');
 
-    const upcomingInvoiceAmount = await getUpcomingInvoiceAmount(subscription.id);
-    const amount: string = fromUnitToToken(+upcomingInvoiceAmount.amount, upcomingInvoiceAmount.currency?.decimal);
-    const paymentDetail: PaymentDetail = await getPaymentDetail(userDid, invoice, amount);
-    paymentDetail.price = +amount;
+    // const upcomingInvoiceAmount = await getUpcomingInvoiceAmount(subscription.id);
+    // const amount: string = fromUnitToToken(+upcomingInvoiceAmount.amount, upcomingInvoiceAmount.currency?.decimal);
+    // const paymentDetail: PaymentDetail = await getPaymentDetail(userDid, invoice, amount);
+    // paymentDetail.price = +amount;
+
+    const paymentAmount = await getPaymentAmountForCycleSubscription(subscription, paymentCurrency);
+    const paymentDetail = { price: paymentAmount, balance: 0, symbol: paymentCurrency.symbol };
+
+    const token = await getTokenSummaryByDid(userDid, customer.livemode);
 
+    paymentDetail.balance = +fromUnitToToken(token?.[paymentCurrency.id] || '0', paymentCurrency.decimal);
     const { isPrePaid, interval } = await this.getPaymentCategory({
       subscriptionId: subscription.id,
     });
     const paidType: string = isPrePaid
       ? translate('notification.common.prepaid', locale)
       : translate('notification.common.postpaid', locale);
-    const paymentInfo: string = `${paymentDetail.price} ${paymentCurrency.symbol}`;
+    const paymentInfo: string = `${paymentDetail?.price || '0'} ${paymentCurrency.symbol}`;
     const currentPeriodStart: string = isPrePaid
       ? formatTime(invoice.period_end * 1000)
       : formatTime(invoice.period_start * 1000);
@@ -143,6 +151,7 @@ export class SubscriptionWillRenewEmailTemplate
 
       viewSubscriptionLink,
       addFundsLink,
+      paymentMethod,
     };
   }
   async getPaymentCategory({ subscriptionId }: { subscriptionId: string }): Promise<{
@@ -228,10 +237,11 @@ export class SubscriptionWillRenewEmailTemplate
 
       viewSubscriptionLink,
       addFundsLink,
+      paymentMethod,
     } = await this.getContext();
 
     const canPay: boolean = paymentDetail.balance >= paymentDetail.price;
-    if (canPay && !this.options.required) {
+    if (canPay) {
       // 当余额足够支付并且本封邮件不是必须发送时,可以不发送邮件
       return null;
     }
@@ -240,31 +250,33 @@ export class SubscriptionWillRenewEmailTemplate
       return null;
     }
 
+    const isStripe = paymentMethod?.type === 'stripe';
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionWillRenew.title', locale, {
         productName,
         willRenewDuration,
       })}`,
-      body: canPay
-        ? `${translate('notification.subscriptionWillRenew.body', locale, {
-            at,
-            productName,
-            willRenewDuration,
-            balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
-          })}`
-        : `${translate('notification.subscriptionWillRenew.unableToPayBody', locale, {
-            at,
-            productName,
-            willRenewDuration,
-            reason: `<span style="color: red;">${translate(
-              'notification.subscriptionWillRenew.unableToPayReason',
-              locale,
-              {
-                balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
-                price: `${paymentDetail.price} ${paymentDetail.symbol}`,
-              }
-            )}</span>`,
-          })}`,
+      body:
+        canPay || isStripe
+          ? `${translate('notification.subscriptionWillRenew.body', locale, {
+              at,
+              productName,
+              willRenewDuration,
+              balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
+            })}`
+          : `${translate('notification.subscriptionWillRenew.unableToPayBody', locale, {
+              at,
+              productName,
+              willRenewDuration,
+              reason: `<span style="color: red;">${translate(
+                'notification.subscriptionWillRenew.unableToPayReason',
+                locale,
+                {
+                  balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
+                  price: `${paymentDetail.price} ${paymentDetail.symbol}`,
+                }
+              )}</span>`,
+            })}`,
       // @ts-expect-error
       attachments: [
         {

package/api/src/libs/payment.ts

@@ -10,11 +10,23 @@ import cloneDeep from 'lodash/cloneDeep';
 import type { LiteralUnion } from 'type-fest';
 
 import { fetchErc20Allowance, fetchErc20Balance, fetchEtherBalance } from '../integrations/ethereum/token';
-import { Invoice, PaymentCurrency, PaymentIntent, PaymentMethod, TCustomer, TLineItemExpanded } from '../store/models';
+import {
+  Invoice,
+  PaymentCurrency,
+  PaymentIntent,
+  PaymentMethod,
+  SubscriptionItem,
+  TCustomer,
+  TLineItemExpanded,
+  Subscription,
+  Price,
+  UsageRecord,
+} from '../store/models';
 import type { TPaymentCurrency } from '../store/models/payment-currency';
 import { blocklet, ethWallet, wallet } from './auth';
 import logger from './logger';
 import { OCAP_PAYMENT_TX_TYPE } from './util';
+import { getSubscriptionCycleAmount, getSubscriptionCycleSetup } from './subscription';
 
 export interface SufficientForPaymentResult {
   sufficient: boolean;
@@ -339,3 +351,43 @@ export async function isBalanceSufficientForRefund(args: {
 
   throw new Error(`isBalanceSufficientForRefund: Payment method ${paymentMethod.type} not supported`);
 }
+
+export async function getPaymentAmountForCycleSubscription(
+  subscription: Subscription,
+  paymentCurrency: PaymentCurrency
+) {
+  const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
+  let expandedItems = await Price.expand(
+    subscriptionItems.map((x) => ({ id: x.id, price_id: x.price_id, quantity: x.quantity })),
+    { product: true }
+  );
+  const previousPeriodEnd =
+    subscription.status === 'trialing' ? subscription.trial_end : subscription.current_period_end;
+  const setup = getSubscriptionCycleSetup(subscription.pending_invoice_item_interval, previousPeriodEnd as number);
+  // get usage summaries for this billing cycle
+  expandedItems = await Promise.all(
+    expandedItems.map(async (x: any) => {
+      // For metered billing, we need to get usage summary for this billing cycle
+      // @link https://stripe.com/docs/products-prices/pricing-models#usage-types
+      if (x.price.recurring?.usage_type === 'metered') {
+        const rawQuantity = await UsageRecord.getSummary({
+          id: x.id,
+          start: setup.period.start - setup.cycle / 1000,
+          end: setup.period.end - setup.cycle / 1000,
+          method: x.price.recurring?.aggregate_usage,
+          dryRun: false,
+        });
+        x.quantity = x.price.transformQuantity(rawQuantity);
+        // record raw quantity in metadata
+        x.metadata = x.metadata || {};
+        x.metadata.quantity = rawQuantity;
+      }
+      return x;
+    })
+  );
+  if (expandedItems.length > 0) {
+    const amount = getSubscriptionCycleAmount(expandedItems, paymentCurrency.id);
+    return +fromUnitToToken(amount?.total || '0', paymentCurrency.decimal);
+  }
+  return 0;
+}

package/api/src/libs/subscription.ts

@@ -268,6 +268,19 @@ export async function createProration(
     logger.warn('try to create proration with invalid arguments', { anchor, prorationStart, prorationEnd });
     throw new Error('Subscription proration anchor should not be larger than prorationEnd');
   }
+  const trialing = subscription.status === 'trialing';
+  if (trialing) {
+    return {
+      lastInvoice,
+      total: '0',
+      due: '0',
+      used: '0',
+      unused: '0',
+      prorations: [],
+      newCredit: '0',
+      appliedCredit: '0',
+    };
+  }
 
   const prorationRate = Math.ceil(((prorationEnd - anchor) / (prorationEnd - prorationStart)) * precision);
   let unused = new BN(0);
@@ -823,3 +836,33 @@ export async function getSubscriptionStakeAddress(subscription: Subscription, cu
     (await getCustomerStakeAddress(customerDid, subscription.id))
   );
 }
+
+export async function getSubscriptionStakeCancellation(
+  subscription: Subscription,
+  paymentMethod: PaymentMethod,
+  paymentCurrency: PaymentCurrency
+): Promise<{
+  stakeReturn: boolean;
+  stakeSlash: boolean;
+  stakeEnough: boolean;
+  hasStake: boolean;
+}> {
+  const cancellation = {
+    stakeReturn: subscription.cancelation_details?.return_stake === true,
+    stakeSlash: subscription.cancelation_details?.slash_stake === true,
+    stakeEnough: false,
+    hasStake: !!subscription?.payment_details?.arcblock?.staking?.tx_hash,
+  };
+  const customerCancelRequest = subscription.cancelation_details?.reason === 'cancellation_requested';
+  if (customerCancelRequest) {
+    // cancel request from customer
+    const address = subscription?.payment_details?.arcblock?.staking?.address;
+    let stakeEnough;
+    if (address && paymentMethod) {
+      const stakeReturnResult = await getSubscriptionStakeReturnSetup(subscription, address, paymentMethod);
+      stakeEnough = await checkRemainingStake(paymentMethod, paymentCurrency, address, stakeReturnResult.return_amount);
+      cancellation.stakeEnough = stakeEnough?.enough;
+    }
+  }
+  return cancellation;
+}

package/api/src/locales/en.ts

@@ -7,6 +7,10 @@ export default flat({
       product: 'Product',
       paymentAmount: 'Payment amount',
       refundAmount: 'Refund amount',
+      stakeAmount: 'Stake amount',
+      returnAmount: 'Return amount',
+      slashAmount: 'Slash amount',
+      slashReason: 'Slash reason',
       refundPeriod: 'Refund period',
       validityPeriod: 'Service period',
       paymentPeriod: 'Payment period',
@@ -110,6 +114,16 @@ export default flat({
       body: 'Your subscription to {productName} has been successfully refunded on {at}, with a refund amount of {refundInfo}. If you have any questions, please feel free to contact us.',
     },
 
+    subscriptionStakeReturnSucceeded: {
+      title: '{productName} stake return successful',
+      body: 'The stake for your subscription to {productName} has been returned on {at}, with a return amount of {refundInfo}. If you have any questions, please feel free to contact us.',
+    },
+
+    subscriptionStakeSlashSucceeded: {
+      title: '{productName} stake slashed',
+      body: 'The stake for your subscription to {productName} has been slashed on {at}, with a slash amount of {slashInfo}. If you have any questions, please feel free to contact us.',
+    },
+
     customerRewardSucceeded: {
       title: 'Thanks for your reward of {amount}',
       body: 'Thanks for your reward on {at} for {subject}, the amount of reward is {amount}. Your support is our driving force, thanks for your generous support!',
@@ -127,6 +141,16 @@ export default flat({
       body: 'Your subscription to {productName} has been canceled on {at}. If you have any questions, please feel free to contact us.',
       adminCanceled: 'Admin canceled',
       adminCanceledAndRefunded: 'Admin canceled and refunded, please check for the refund email',
+      adminCanceledAndStakeReturned: 'Admin canceled and returned the stake, please check for the stake return email',
+      adminCanceledAndSlashed: 'Admin canceled and slashed stake, please check for the stake slash email',
+      adminCanceledAndRefundedAndStakeReturned:
+        'The administrator has canceled the subscription and refunded, and the stake has been returned, please check for the refund and stake return email.',
+      adminCanceledAndRefundedAndStakeSlashed:
+        'The administrator has canceled the subscription and refunded, and the stake has been slashed, please check for the refund and stake slash email.',
+      customerCanceled: 'User-initiated cancellation',
+      customerCanceledAndStakeReturned:
+        'User-initiated cancellation, the stake will be returned later, please check for the stake return email',
+      paymentFailed: 'Payment failed',
     },
   },
 });

package/api/src/locales/zh.ts

@@ -7,6 +7,10 @@ export default flat({
       product: '商品',
       paymentAmount: '扣费金额',
       refundAmount: '退款金额',
+      stakeAmount: '质押金额',
+      returnAmount: '退还金额',
+      slashAmount: '罚没金额',
+      slashReason: '罚没原因',
       refundPeriod: '退款周期',
       validityPeriod: '服务周期',
       paymentPeriod: '扣款周期',
@@ -107,6 +111,16 @@ export default flat({
       body: '您订阅的 {productName} 在 {at} 已退款成功，退款金额为 {refundInfo}。如有任何疑问，请随时与我们联系。',
     },
 
+    subscriptionStakeReturnSucceeded: {
+      title: '{productName} 质押退还成功',
+      body: '您订阅的 {productName} 在 {at} 已退还押金，退还金额为 {refundInfo}。如有任何疑问，请随时与我们联系。',
+    },
+
+    subscriptionStakeSlashSucceeded: {
+      title: '{productName} 质押已被罚没',
+      body: '您订阅的 {productName} 在 {at} 已罚没押金，罚没金额为 {slashInfo}。如有任何疑问，请随时与我们联系。',
+    },
+
     customerRewardSucceeded: {
       title: '感谢您打赏的 {amount}',
       body: '感谢您于 {at} 在 {subject} 下的打赏，打赏金额为 {amount}。您的支持是我们前行的动力，谢谢您的大力支持！',
@@ -124,6 +138,14 @@ export default flat({
       body: '您订阅的 {productName} 在 {at} 已取消。如有任何疑问，请随时与我们联系。',
       adminCanceled: '管理员取消',
       adminCanceledAndRefunded: '管理员取消并已退款,请留意后续的退款邮件',
+      adminCanceledAndStakeReturned: '管理员取消并已退还押金,请留意后续的质押退还邮件',
+      adminCanceledAndSlashed: '管理员取消并已罚没,请留意后续的罚没邮件',
+      adminCanceledAndRefundedAndStakeReturned:
+        '管理员已取消订阅并退款，押金也已退还，请留意后续的退款和质押退还邮件。',
+      adminCanceledAndRefundedAndStakeSlashed: '管理员已取消订阅并退款，押金已被罚没，请留意后续的退款和质押罚没邮件。',
+      customerCanceled: '用户主动取消',
+      customerCanceledAndStakeReturned: '用户主动取消, 押金会在稍后退还, 请留意后续的质押退还邮件',
+      paymentFailed: '扣费失败',
     },
   },
 });