payment-kit 1.27.2 → 1.28.0

package/api/src/libs/audit.ts

@@ -8,14 +8,40 @@ import { context } from './context';
 
 const API_VERSION = '2023-09-05';
 
-export async function createEvent(scope: string, type: LiteralUnion<EventType, string>, model: any, options: any = {}) {
+export function createEvent(
+  scope: string,
+  type: LiteralUnion<EventType, string>,
+  model: any,
+  options: any = {}
+): Promise<void> {
+  // Context-aware tracking for CF Workers:
+  // - HTTP requests: use ctx.waitUntil (non-blocking, like Blocklet's fire-and-forget)
+  // - Queue consumer/Cron: use __cfPendingJobs__ (blocking, listeners must complete)
+  // - Blocklet Server: no tracking needed (long-lived process)
+  const promise = doCreateEvent(scope, type, model, options);
+  const isHttp = (globalThis as any).__cfHttpContext__;
+  if (isHttp) {
+    const waitUntil = (globalThis as any).__cfWaitUntil__;
+    if (typeof waitUntil === 'function') {
+      waitUntil(promise.catch((err: any) => console.error('[createEvent]', type, err?.message || err)));
+    }
+  } else {
+    const pending = (globalThis as any).__cfPendingJobs__;
+    if (Array.isArray(pending)) {
+      pending.push(promise.catch((err: any) => console.error('[createEvent]', type, err?.message || err)));
+    }
+  }
+  return promise;
+}
+
+async function doCreateEvent(scope: string, type: LiteralUnion<EventType, string>, model: any, options: any = {}) {
   const data: any = {
     object: model.dataValues,
   };
   if (type.endsWith('updated')) {
     data.previous_attributes = pick(model._previousDataValues, options.fields);
   }
-  // console.log('createEvent', scope, type, data, options);
+
   const event = await Event.create({
     type,
     api_version: API_VERSION,
@@ -24,13 +50,12 @@ export async function createEvent(scope: string, type: LiteralUnion<EventType, s
     object_type: scope,
     data,
     request: {
-      // FIXME:
       id: '',
       idempotency_key: '',
       requested_by: options.requestedBy || context.getRequestedBy() || 'system',
     },
     metadata: {},
-    pending_webhooks: 99, // force all events goto the event queue
+    pending_webhooks: 99,
   });
 
   events.emit('event.created', { id: event.id });
@@ -57,7 +82,6 @@ export async function createStatusEvent(
     return;
   }
 
-  // console.log('createStatusEvent', scope, prefix, config, data, options);
   const suffix = config[data.object.status];
   const event = await Event.create({
     type: [prefix, suffix].join('.'),
@@ -67,13 +91,12 @@ export async function createStatusEvent(
     object_type: scope,
     data,
     request: {
-      // FIXME:
       id: '',
       idempotency_key: '',
       requested_by: options.requestedBy || context.getRequestedBy() || 'system',
     },
     metadata: {},
-    pending_webhooks: 99, // force all events goto the event queue
+    pending_webhooks: 99,
   });
 
   events.emit('event.created', { id: event.id });
@@ -97,7 +120,6 @@ export async function createCustomEvent(
     return;
   }
 
-  // console.log('createCustomEvent', scope, prefix, type, data, options);
   const event = await Event.create({
     type: [prefix, suffix].join('.'),
     api_version: API_VERSION,
@@ -106,13 +128,12 @@ export async function createCustomEvent(
     object_type: scope,
     data,
     request: {
-      // FIXME:
       id: '',
       idempotency_key: '',
       requested_by: options.requestedBy || context.getRequestedBy() || 'system',
     },
     metadata: {},
-    pending_webhooks: 99, // force all events goto the event queue
+    pending_webhooks: 99,
   });
 
   events.emit('event.created', { id: event.id });
@@ -121,11 +142,6 @@ export async function createCustomEvent(
 
 /**
  * 创建自定义事件，无需依赖模型对象
- * @param type 完整的事件类型，格式为 prefix.suffix
- * @param objectType 对象类型
- * @param objectId 对象ID
- * @param data 事件数据
- * @param options 额外选项
  */
 export async function createFlexibleEvent(
   type: string,
@@ -153,7 +169,7 @@ export async function createFlexibleEvent(
       requested_by: requestedBy || context.getRequestedBy() || 'system',
     },
     metadata,
-    pending_webhooks: 99, // force all events goto the event queue
+    pending_webhooks: 99,
   });
 
   events.emit('event.created', { id: event.id });

package/api/src/libs/auth.ts

@@ -3,7 +3,7 @@ import path from 'path';
 import AuthStorage from '@arcblock/did-connect-storage-nedb';
 // @ts-ignore
 import { BlockletService } from '@blocklet/sdk/service/auth';
-import { getWallet } from '@blocklet/sdk/lib/wallet';
+import { getWallet, getAccessWallet } from '@blocklet/sdk/lib/wallet';
 import { WalletAuthenticator } from '@blocklet/sdk/lib/wallet-authenticator';
 import { WalletHandlers } from '@blocklet/sdk/lib/wallet-handler';
 import type { Request } from 'express';
@@ -13,9 +13,56 @@ import type { WalletObject } from '@ocap/wallet';
 import env from './env';
 import logger from './logger';
 
+// Workaround #2: @blocklet/sdk's notification.getSender() uses
+// `getWallet().address` (BLOCKLET_APP_SK derived) as the sender appDid for
+// relay/EventBus broadcasts. On migrated blocklets that address (e.g. zNKti3…)
+// is a rotating session id that the relay does not recognise, surfacing as:
+//   "Sender blocklet does not exist: <addr>"
+//   "Failed to broadcast event via relay: payment_intent.succeeded"
+// The relay/EventBus calls in notification.js invoke `(0, exports.getSender)()`
+// at send time, so mutating the module's own `exports.getSender` intercepts
+// every call site. We must use `require()` (not `import default`) — the module
+// sets `exports.default` to a subset object that does NOT include getSender,
+// so the default-import alias cannot reach the live `exports.getSender`.
+//
+// Path must be `@blocklet/sdk/service/notification` (no `lib/`) — in Node it
+// is a thin re-export that resolves via the module cache to the same object
+// as `@blocklet/sdk/lib/service/notification`; in CF Workers the esbuild
+// config aliases it to a no-op shim (patching a no-op is harmless). Using
+// the `lib/` path breaks the CF build because it does not have an alias
+// and falls through to `@blocklet/sdk` → `shims/blocklet-sdk/index.ts/lib/...`.
+// Same root cause as the WalletAuthenticator override below — remove once the
+// upstream sdk is patched.
+// eslint-disable-next-line @typescript-eslint/no-var-requires, global-require, import/no-extraneous-dependencies
+const notificationExports = require('@blocklet/sdk/service/notification');
+
+notificationExports.getSender = () => ({
+  appDid: process.env.BLOCKLET_APP_ID || getWallet(undefined, '', 'sk').address,
+  wallet: getAccessWallet(),
+});
+logger.info('[sdk-patch] notification.getSender overridden', {
+  appDid: notificationExports.getSender().appDid,
+  expectedAppId: process.env.BLOCKLET_APP_ID,
+});
+
 export const wallet: WalletObject = getWallet();
 export const ethWallet: WalletObject = getWallet('ethereum');
-export const authenticator = new WalletAuthenticator();
+
+// Workaround for migrated blocklets where `BLOCKLET_APP_SK` is a rotating session
+// key whose derived address ≠ appId. Upstream @blocklet/sdk's WalletAuthenticator
+// passes `wallet: getWallet()` to did-connect-js, so outer.agentDid becomes that
+// rotating address. Meanwhile the federated cert (signed by master) sets
+// agentDid = `did:abt:${verifySite.appId}` (permanent), so the wallet-side strict
+// check `cert.agentDid === outer.agentDid` fails with "Agent did does not match
+// with certificate issuer."
+//
+// Force the authenticator to derive its signing wallet from BLOCKLET_APP_PK
+// (permanent app pk → address = appId), aligning with the fix in
+// @blocklet/sdk PR #12810 that already corrected getDelegatee. Remove once the
+// upstream wallet-authenticator.ts is patched accordingly.
+export const authenticator = new WalletAuthenticator({
+  wallet: getWallet(undefined, '', 'sk'),
+});
 export const handlers = new WalletHandlers({
   authenticator,
   tokenStorage: new AuthStorage({

package/api/src/libs/chain-error.ts

@@ -0,0 +1,31 @@
+import CustomError from './error';
+
+export function parseChainError(err: unknown): CustomError {
+  const msg = (err as Error)?.message ?? String(err);
+
+  const gasMatch = msg.match(
+    /Insufficient fund to pay for tx cost from (\w+)[\s\S]*?expected\s+([\d.]+)\s+(\w+)[\s\S]*?got\s+([\d.]+)/
+  );
+  if (gasMatch) {
+    return new CustomError('INSUFFICIENT_GAS', 'Main account lacks gas token for tx cost').withDetails({
+      account: gasMatch[1],
+      required: gasMatch[2],
+      available: gasMatch[4],
+      token: gasMatch[3],
+    });
+  }
+
+  // Chain rejects gas-payer JWT when the signing account has no on-chain state
+  // (fresh DID that never broadcast a DeclareTx). The wallet shouldn't attach
+  // x-gas-payer-* headers in that case, but surface a clean code/message so the
+  // UI doesn't render the raw GraphQL string. See #1356.
+  const gasPayerNotOnChain = msg.match(/Gas payer (\w+)[\s\S]*?does not exist on chain/i);
+  if (gasPayerNotOnChain) {
+    return new CustomError(
+      'GAS_PAYER_NOT_ON_CHAIN',
+      'Wallet account has no on-chain history yet; please fund or transact once before paying'
+    ).withDetails({ account: gasPayerNotOnChain[1] });
+  }
+
+  return new CustomError('TX_REJECTED', msg).withDetails({ raw: msg });
+}

package/api/src/libs/error.ts

@@ -2,6 +2,8 @@
 export default class CustomError extends Error {
   code: string;
 
+  details?: Record<string, unknown>;
+
   constructor(code = 'GENERIC', ...params: any[]) {
     super(...params);
 
@@ -11,6 +13,19 @@ export default class CustomError extends Error {
 
     this.code = code;
   }
+
+  withDetails(details: Record<string, unknown>) {
+    this.details = details;
+    return this;
+  }
+
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      details: this.details,
+    };
+  }
 }
 
 /**

package/api/src/libs/event.ts

@@ -9,7 +9,48 @@ interface MyEventType extends EventEmitter {
   emit(eventName: LiteralUnion<EventType, string | symbol>, ...args: any[]): boolean;
 }
 
-export const events = new EventEmitter() as MyEventType;
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const _events = new EventEmitter();
+
+// Wrap on/once so async listeners auto-register their Promises in CF Workers.
+// EventEmitter.emit() is synchronous and discards async listener return values.
+// In CF Workers, untracked Promises are abandoned when the request/consumer ends.
+// This wrapper ensures async listener work completes via flushPendingJobs().
+// In Blocklet Server (__cfPendingJobs__ doesn't exist), this is a transparent pass-through.
+function wrapAsyncListener(listener: (...args: any[]) => any): (...args: any[]) => any {
+  return function (...args: any[]) {
+    const result = listener(...args);
+    if (result && typeof result.then === 'function') {
+      // Context-aware: HTTP uses waitUntil (non-blocking), queue/cron uses pendingJobs (blocking)
+      const isHttp = (globalThis as any).__cfHttpContext__;
+      if (isHttp) {
+        const waitUntil = (globalThis as any).__cfWaitUntil__;
+        if (typeof waitUntil === 'function') {
+          waitUntil(result.catch((err: any) => console.error('[event] async listener error:', err?.message || err)));
+        }
+      } else {
+        const pending = (globalThis as any).__cfPendingJobs__;
+        if (Array.isArray(pending)) {
+          pending.push(result.catch((err: any) => console.error('[event] async listener error:', err?.message || err)));
+        }
+      }
+    }
+    return result;
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const _origOn = _events.on.bind(_events);
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const _origOnce = _events.once.bind(_events);
+_events.on = function (eventName: string | symbol, listener: (...args: any[]) => void) {
+  return _origOn(eventName, wrapAsyncListener(listener));
+};
+_events.once = function (eventName: string | symbol, listener: (...args: any[]) => void) {
+  return _origOnce(eventName, wrapAsyncListener(listener));
+};
+
+export const events = _events as MyEventType;
 
 export const emitAsync = (event: string, ...args: any[]) => {
   return new Promise((resolve, reject) => {

package/api/src/libs/invoice.ts

@@ -4,7 +4,8 @@ import { withQuery } from 'ufo';
 
 import { BN, fromUnitToToken } from '@ocap/util';
 import { Op, type WhereOptions } from 'sequelize';
-import { cloneDeep, pick } from 'lodash';
+import cloneDeep from 'lodash/cloneDeep';
+import pick from 'lodash/pick';
 import {
   Customer,
   Invoice,
@@ -78,8 +79,10 @@ export async function getOneTimeProductInfo(invoiceId: string, paymentCurrency:
       throw new Error(`Invoice not found: ${invoiceId}`);
     }
     const json = doc.toJSON();
-    const products = (await Product.findAll()).map((x) => x.toJSON());
-    const prices = (await Price.findAll()).map((x) => x.toJSON());
+    const [products, prices] = await Promise.all([
+      Product.findAll().then((xs) => xs.map((x) => x.toJSON())),
+      Price.findAll().then((xs) => xs.map((x) => x.toJSON())),
+    ]);
     // @ts-ignore
     expandLineItems(json.lines, products, prices);
     const oneTimePaymentInfo: Array<{
@@ -108,12 +111,18 @@ export async function getOneTimeProductInfo(invoiceId: string, paymentCurrency:
 
 export async function getInvoiceShouldPayTotal(invoice: Invoice) {
   try {
-    const subscription = await Subscription.findByPk(invoice.subscription_id);
+    // Parallel fetch: subscription + paymentCurrency are independent;
+    // subscriptionItems + invoiceItems are also independent of each other.
+    const [subscription, paymentCurrency, subscriptionItems, invoiceItems] = await Promise.all([
+      Subscription.findByPk(invoice.subscription_id),
+      PaymentCurrency.findByPk(invoice.currency_id),
+      SubscriptionItem.findAll({ where: { subscription_id: invoice.subscription_id } }),
+      InvoiceItem.findAll({ where: { invoice_id: invoice.id } }),
+    ]);
+
     if (!subscription) {
       throw new Error(`Subscription not found: ${invoice.subscription_id}`);
     }
-
-    const paymentCurrency = await PaymentCurrency.findByPk(invoice.currency_id);
     if (!paymentCurrency) {
       throw new Error(`Payment currency not found: ${invoice.currency_id}`);
     }
@@ -123,12 +132,6 @@ export async function getInvoiceShouldPayTotal(invoice: Invoice) {
       throw new Error(`Payment method not found: ${paymentCurrency.payment_method_id}`);
     }
 
-    const subscriptionItems = await SubscriptionItem.findAll({
-      where: { subscription_id: subscription.id },
-    });
-    const invoiceItems = await InvoiceItem.findAll({
-      where: { invoice_id: invoice.id },
-    });
     const invoiceQuoteIds = invoiceItems
       .map((item) => item.metadata?.quote_id)
       .filter((id): id is string => typeof id === 'string' && id.length > 0);
@@ -577,25 +580,50 @@ async function createInvoiceWithItems(props: BaseInvoiceProps): Promise<{
       })
     : itemsData;
 
+  // Pre-fetch all prices and products in bulk to avoid N+1 queries per item
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  const _itemPriceIds = enrichedItemsData.map((item) => item.price_id).filter(Boolean);
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  const [_allPrices, _taxRateForCustomer] = await Promise.all([
+    Price.findAll({ where: { id: _itemPriceIds }, include: [{ model: Product, as: 'product' }] }),
+    // Tax rate matching only depends on customer address — same for all items
+    customer.address?.country
+      ? TaxRate.findMatchingRate({
+          country: customer.address.country,
+          state: customer.address.state,
+          postalCode: customer.address.postal_code,
+          livemode,
+        }).catch(() => null)
+      : Promise.resolve(null),
+  ]);
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  const _priceMap = new Map(_allPrices.map((p: any) => [p.id, p]));
+
   // create invoice items
   const items = await Promise.all(
     enrichedItemsData.map(async (item) => {
-      // Match tax rate for this specific item
+      // Use pre-fetched price/product for tax rate matching
       let taxRateId: string | undefined;
       if (customer.address?.country && item.price_id) {
         try {
-          const price = await Price.findByPk(item.price_id);
+          const price = _priceMap.get(item.price_id);
           if (price?.product_id) {
-            const product = await Product.findByPk(price.product_id);
+            const { product } = price as any;
             if (product) {
-              const taxRate = await TaxRate.findMatchingRate({
-                country: customer.address.country,
-                state: customer.address.state,
-                postalCode: customer.address.postal_code,
-                taxCode: product.tax_code,
-                livemode,
-              });
-              taxRateId = taxRate?.id;
+              // Use pre-fetched tax rate if no product-specific tax_code,
+              // otherwise do a specific lookup
+              if (!product.tax_code) {
+                taxRateId = (_taxRateForCustomer as any)?.id;
+              } else {
+                const taxRate = await TaxRate.findMatchingRate({
+                  country: customer.address.country,
+                  state: customer.address.state,
+                  postalCode: customer.address.postal_code,
+                  taxCode: product.tax_code,
+                  livemode,
+                });
+                taxRateId = taxRate?.id;
+              }
             }
           }
         } catch (error) {
@@ -785,8 +813,10 @@ export async function cleanupInvoiceAndItems(invoiceId: string) {
     return;
   }
 
-  const removedItem = await InvoiceItem.destroy({ where: { invoice_id: invoiceId } });
-  const removedInvoice = await Invoice.destroy({ where: { id: invoiceId } });
+  const [removedItem, removedInvoice] = await Promise.all([
+    InvoiceItem.destroy({ where: { invoice_id: invoiceId } }),
+    Invoice.destroy({ where: { id: invoiceId } }),
+  ]);
   logger.info('cleanup invoice and items', { invoiceId, removedItem, removedInvoice });
 }
 
@@ -1345,21 +1375,26 @@ export const migrateSubscriptionPaymentMethodInvoice = async (
     }
   }
 
-  // 3. Get old and new payment method/currency
-  const oldPaymentCurrency = await PaymentCurrency.findByPk(oldCurrencyId);
+  // 3. Get old and new payment currency in parallel
+  const [oldPaymentCurrency, newPaymentCurrency] = await Promise.all([
+    PaymentCurrency.findByPk(oldCurrencyId),
+    PaymentCurrency.findByPk(newCurrencyId),
+  ]);
   if (!oldPaymentCurrency) {
     throw new Error(`Payment currency ${oldCurrencyId} not found`);
   }
-  const oldPaymentMethod = await PaymentMethod.findByPk(oldPaymentCurrency.payment_method_id);
-  if (!oldPaymentMethod) {
-    throw new Error(`Payment method for currency ${oldCurrencyId} not found`);
-  }
-
-  const newPaymentCurrency = await PaymentCurrency.findByPk(newCurrencyId);
   if (!newPaymentCurrency) {
     throw new Error(`Payment currency ${newCurrencyId} not found`);
   }
-  const newPaymentMethod = await PaymentMethod.findByPk(newPaymentCurrency.payment_method_id);
+
+  // Get old and new payment method in parallel
+  const [oldPaymentMethod, newPaymentMethod] = await Promise.all([
+    PaymentMethod.findByPk(oldPaymentCurrency.payment_method_id),
+    PaymentMethod.findByPk(newPaymentCurrency.payment_method_id),
+  ]);
+  if (!oldPaymentMethod) {
+    throw new Error(`Payment method for currency ${oldCurrencyId} not found`);
+  }
   if (!newPaymentMethod) {
     throw new Error(`Payment method for currency ${newCurrencyId} not found`);
   }

package/api/src/libs/notification/template/customer-auto-recharge-daily-limit-exceeded.ts

@@ -29,9 +29,7 @@ interface CustomerAutoRechargeDailyLimitExceededEmailTemplateContext {
   customerIndexUrl: string;
 }
 
-export class CustomerAutoRechargeDailyLimitExceededEmailTemplate
-  implements BaseEmailTemplate<CustomerAutoRechargeDailyLimitExceededEmailTemplateContext>
-{
+export class CustomerAutoRechargeDailyLimitExceededEmailTemplate implements BaseEmailTemplate<CustomerAutoRechargeDailyLimitExceededEmailTemplateContext> {
   options: CustomerAutoRechargeDailyLimitExceededEmailTemplateOptions;
 
   constructor(options: CustomerAutoRechargeDailyLimitExceededEmailTemplateOptions) {

package/api/src/libs/notification/template/customer-auto-recharge-failed.ts

@@ -46,9 +46,7 @@ interface CustomerAutoRechargeFailedEmailTemplateContext {
   isSkipped: boolean;
 }
 
-export class CustomerAutoRechargeFailedEmailTemplate
-  implements BaseEmailTemplate<CustomerAutoRechargeFailedEmailTemplateContext>
-{
+export class CustomerAutoRechargeFailedEmailTemplate implements BaseEmailTemplate<CustomerAutoRechargeFailedEmailTemplateContext> {
   options: CustomerAutoRechargeFailedEmailTemplateOptions;
 
   constructor(options: CustomerAutoRechargeFailedEmailTemplateOptions) {

package/api/src/libs/notification/template/customer-credit-grant-granted.ts

@@ -21,9 +21,7 @@ interface CustomerCreditGrantGrantedEmailTemplateContext {
   at: string;
 }
 
-export class CustomerCreditGrantGrantedEmailTemplate
-  implements BaseEmailTemplate<CustomerCreditGrantGrantedEmailTemplateContext>
-{
+export class CustomerCreditGrantGrantedEmailTemplate implements BaseEmailTemplate<CustomerCreditGrantGrantedEmailTemplateContext> {
   options: CustomerCreditGrantGrantedEmailTemplateOptions;
 
   constructor(options: CustomerCreditGrantGrantedEmailTemplateOptions) {

package/api/src/libs/notification/template/customer-credit-insufficient.ts

@@ -37,9 +37,7 @@ interface CustomerCreditInsufficientEmailTemplateContext {
   at: string;
 }
 
-export class CustomerCreditInsufficientEmailTemplate
-  implements BaseEmailTemplate<CustomerCreditInsufficientEmailTemplateContext>
-{
+export class CustomerCreditInsufficientEmailTemplate implements BaseEmailTemplate<CustomerCreditInsufficientEmailTemplateContext> {
   options: CustomerCreditInsufficientEmailTemplateOptions;
 
   constructor(options: CustomerCreditInsufficientEmailTemplateOptions) {

package/api/src/libs/notification/template/customer-credit-low-balance.ts

@@ -26,9 +26,7 @@ interface CustomerCreditLowBalanceEmailTemplateContext {
   isCritical: boolean; // true if percentage < 1%
   rechargeUrl: string | null;
 }
-export class CustomerCreditLowBalanceEmailTemplate
-  implements BaseEmailTemplate<CustomerCreditLowBalanceEmailTemplateContext>
-{
+export class CustomerCreditLowBalanceEmailTemplate implements BaseEmailTemplate<CustomerCreditLowBalanceEmailTemplateContext> {
   // Notification configuration: 10 minute grace period before sending
   static readonly delay = 10 * 60; // seconds
 

package/api/src/libs/notification/template/customer-revenue-succeeded.ts

@@ -43,9 +43,7 @@ interface CustomerRevenueSucceededEmailTemplateContext {
  * @class CustomerRevenueSucceededEmailTemplate
  * @implements {BaseEmailTemplate<CustomerRevenueSucceededEmailTemplateContext>}
  */
-export class CustomerRevenueSucceededEmailTemplate
-  implements BaseEmailTemplate<CustomerRevenueSucceededEmailTemplateContext>
-{
+export class CustomerRevenueSucceededEmailTemplate implements BaseEmailTemplate<CustomerRevenueSucceededEmailTemplateContext> {
   options: CustomerRevenueSucceededEmailTemplateOptions;
 
   constructor(options: CustomerRevenueSucceededEmailTemplateOptions) {

package/api/src/libs/notification/template/customer-reward-succeeded.ts

@@ -64,9 +64,7 @@ interface CustomerRewardSucceededEmailTemplateContext {
  * @class CustomerRewardSucceededEmailTemplate
  * @implements {BaseEmailTemplate<CustomerRewardSucceededEmailTemplateContext>}
  */
-export class CustomerRewardSucceededEmailTemplate
-  implements BaseEmailTemplate<CustomerRewardSucceededEmailTemplateContext>
-{
+export class CustomerRewardSucceededEmailTemplate implements BaseEmailTemplate<CustomerRewardSucceededEmailTemplateContext> {
   options: CustomerRewardSucceededEmailTemplateOptions;
 
   constructor(options: CustomerRewardSucceededEmailTemplateOptions) {

package/api/src/libs/notification/template/one-time-payment-refund-succeeded.ts

@@ -29,9 +29,7 @@ interface OneTimePaymentRefundSucceededEmailTemplateContext {
   invoiceNumber?: string;
 }
 
-export class OneTimePaymentRefundSucceededEmailTemplate
-  implements BaseEmailTemplate<OneTimePaymentRefundSucceededEmailTemplateContext>
-{
+export class OneTimePaymentRefundSucceededEmailTemplate implements BaseEmailTemplate<OneTimePaymentRefundSucceededEmailTemplateContext> {
   options: OneTimePaymentRefundSucceededEmailTemplateOptions;
 
   constructor(options: OneTimePaymentRefundSucceededEmailTemplateOptions) {

package/api/src/libs/notification/template/one-time-payment-succeeded.ts

@@ -37,9 +37,7 @@ interface OneTimePaymentSucceededEmailTemplateContext {
  * @class OneTimePaymentSucceededEmailTemplate
  * @implements {BaseEmailTemplate<OneTimePaymentSucceededEmailTemplateContext>}
  */
-export class OneTimePaymentSucceededEmailTemplate
-  implements BaseEmailTemplate<OneTimePaymentSucceededEmailTemplateContext>
-{
+export class OneTimePaymentSucceededEmailTemplate implements BaseEmailTemplate<OneTimePaymentSucceededEmailTemplateContext> {
   options: OneTimePaymentSucceededEmailTemplateOptions;
 
   constructor(options: OneTimePaymentSucceededEmailTemplateOptions) {

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

@@ -50,9 +50,7 @@ interface SubscriptionRenewFailedEmailTemplateContext {
   payer: string;
 }
 
-export class SubscriptionRenewFailedEmailTemplate
-  implements BaseEmailTemplate<SubscriptionRenewFailedEmailTemplateContext>
-{
+export class SubscriptionRenewFailedEmailTemplate implements BaseEmailTemplate<SubscriptionRenewFailedEmailTemplateContext> {
   options: SubscriptionRenewFailedEmailTemplateOptions;
 
   constructor(options: SubscriptionRenewFailedEmailTemplateOptions) {

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

@@ -27,9 +27,7 @@ interface SubscriptionSlippageExceededEmailTemplateContext {
   customActions: any[];
 }
 
-export class SubscriptionSlippageExceededEmailTemplate
-  implements BaseEmailTemplate<SubscriptionSlippageExceededEmailTemplateContext>
-{
+export class SubscriptionSlippageExceededEmailTemplate implements BaseEmailTemplate<SubscriptionSlippageExceededEmailTemplateContext> {
   options: SubscriptionSlippageExceededEmailTemplateOptions;
 
   constructor(options: SubscriptionSlippageExceededEmailTemplateOptions) {

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

@@ -29,9 +29,7 @@ interface SubscriptionSlippageWarningEmailTemplateContext {
   customActions: any[];
 }
 
-export class SubscriptionSlippageWarningEmailTemplate
-  implements BaseEmailTemplate<SubscriptionSlippageWarningEmailTemplateContext>
-{
+export class SubscriptionSlippageWarningEmailTemplate implements BaseEmailTemplate<SubscriptionSlippageWarningEmailTemplateContext> {
   options: SubscriptionSlippageWarningEmailTemplateOptions;
 
   constructor(options: SubscriptionSlippageWarningEmailTemplateOptions) {

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

@@ -68,7 +68,7 @@ export class SubscriptionSucceededEmailTemplate extends BaseSubscriptionEmailTem
 
         return Boolean(
           ['disabled', 'minted', 'sent', 'error'].includes(checkoutSession?.nft_mint_status as string) &&
-            (invoice?.payment_intent_id || (invoice && +invoice.amount_remaining === 0))
+          (invoice?.payment_intent_id || (invoice && +invoice.amount_remaining === 0))
         );
       },
       { timeout: 1000 * 10, interval: 1000 }