payment-kit 1.17.4 → 1.17.5

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

@@ -9,6 +9,8 @@ import { getTxMetadata } from '../../libs/util';
 import { ensureSubscriptionRecharge, getAuthPrincipalClaim } from './shared';
 import logger from '../../libs/logger';
 import { ensureRechargeInvoice } from '../../libs/invoice';
+import { EVMChainType } from '../../store/models';
+import { EVM_CHAIN_TYPES } from '../../libs/constants';
 
 export default {
   action: 'recharge',
@@ -54,14 +56,14 @@ export default {
       return claims;
     }
 
-    if (paymentMethod.type === 'ethereum') {
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
       return {
         signature: {
           type: 'eth:transaction',
           data: toBase58(
             Buffer.from(
               JSON.stringify({
-                network: paymentMethod.settings?.ethereum?.chain_id,
+                network: paymentMethod.settings[paymentMethod.type as EVMChainType]?.chain_id,
                 tx: encodeTransferItx(receiverAddress, amount, paymentCurrency.contract as string),
               }),
               'utf-8'
@@ -137,7 +139,7 @@ export default {
       }
     }
 
-    if (paymentMethod.type === 'ethereum') {
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
       try {
         const paymentDetails = await executeEvmTransaction('transfer', userDid, claims, paymentMethod);
         waitForEvmTxConfirm(
@@ -159,7 +161,10 @@ export default {
         return { hash: paymentDetails.tx_hash };
       } catch (err) {
         console.error(err);
-        logger.error('Failed to finalize recharge on ethereum', { receiverAddress, error: err });
+        logger.error(`Failed to finalize recharge on ${paymentMethod.type}`, {
+          receiverAddress,
+          error: err,
+        });
         throw err;
       }
     }

package/api/src/routes/connect/setup.ts

@@ -17,6 +17,7 @@ import {
   getStakeTxClaim,
 } from './shared';
 import { ensureStakeInvoice } from '../../libs/invoice';
+import { EVM_CHAIN_TYPES } from '../../libs/constants';
 
 export default {
   action: 'setup',
@@ -94,7 +95,7 @@ export default {
       return claims;
     }
 
-    if (paymentMethod.type === 'ethereum') {
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
       if (!paymentCurrency.contract) {
         throw new Error(`Payment currency ${paymentMethod.type}:${paymentCurrency.id} does not support setup`);
       }
@@ -213,7 +214,7 @@ export default {
       }
     }
 
-    if (paymentMethod.type === 'ethereum') {
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
       await prepareTxExecution();
       broadcastEvmTransaction(checkoutSessionId, 'pending', claims);
       const paymentDetails = await executeEvmTransaction('approve', userDid, claims, paymentMethod);

package/api/src/routes/connect/shared.ts

@@ -35,6 +35,7 @@ import { Price } from '../../store/models/price';
 import { SetupIntent } from '../../store/models/setup-intent';
 import { Subscription } from '../../store/models/subscription';
 import { ensureInvoiceAndItems } from '../../libs/invoice';
+import { CHARGE_SUPPORTED_CHAIN_TYPES, EVM_CHAIN_TYPES } from '../../libs/constants';
 
 type Result = {
   checkoutSession: CheckoutSession;
@@ -124,7 +125,7 @@ export async function ensurePaymentIntent(checkoutSessionId: string, userDid?: s
     throw new Error('Payment currency not found');
   }
 
-  if (['arcblock', 'ethereum'].includes(paymentMethod.type) === false) {
+  if (CHARGE_SUPPORTED_CHAIN_TYPES.includes(paymentMethod.type) === false) {
     throw new Error(`Payment method ${paymentMethod.type} should not be here`);
   }
 
@@ -195,7 +196,7 @@ export async function ensureSetupIntent(checkoutSessionId: string, userDid?: str
     throw new Error('Payment currency not found for checkoutSession');
   }
 
-  if (['arcblock', 'ethereum'].includes(paymentMethod.type) === false) {
+  if (CHARGE_SUPPORTED_CHAIN_TYPES.includes(paymentMethod.type) === false) {
     throw new Error(`Payment method ${paymentMethod.type} should not be here`);
   }
 
@@ -266,7 +267,7 @@ export async function ensureSubscriptionDelegation(subscriptionId: string) {
   if (!subscription) {
     throw new Error('Subscription not found');
   }
-  if (!['arcblock', 'ethereum'].includes(subscription.paymentMethod?.type)) {
+  if (!CHARGE_SUPPORTED_CHAIN_TYPES.includes(subscription.paymentMethod?.type)) {
     throw new Error(`Payment method ${subscription.paymentMethod?.type} not supported for delegation`);
   }
   subscription.items = await expandSubscriptionItems(subscription.id);
@@ -497,6 +498,14 @@ export function getAuthPrincipalClaim(method: PaymentMethod, action: string) {
       host: method.settings?.ethereum?.api_host as string,
     };
   }
+  if (method.type === 'base') {
+    chainInfo = {
+      type: 'ethereum',
+      // @ts-ignore
+      id: method.settings?.base?.chain_id as number,
+      host: method.settings?.base?.api_host as string,
+    };
+  }
 
   return {
     description: `Select account to ${action}`,
@@ -570,16 +579,25 @@ export async function getDelegationTxClaim({
     };
   }
 
-  if (paymentMethod.type === 'ethereum' && paymentCurrency.contract) {
+  if (EVM_CHAIN_TYPES.includes(paymentMethod.type) && paymentCurrency.contract) {
     const requirement = tokenRequirements.find((x) => x.address === paymentCurrency.contract);
     const limit = tokenLimits.find((x) => x.address === paymentCurrency.contract);
+    // logger.info('getDelegationTxClaim base', {
+    //   address: ethWallet.address,
+    //   amount: mode === 'setup' ? requirement!.value : limit!.totalAllowance,
+    //   contract: paymentCurrency.contract,
+    //   mode,
+    //   requirement,
+    //   limit,
+    // });
     return {
       type: 'eth:transaction',
       description: 'Sign the approval to continue',
       data: toBase58(
         Buffer.from(
           JSON.stringify({
-            network: paymentMethod.settings?.ethereum?.chain_id,
+            // @ts-ignore
+            network: paymentMethod.settings?.[paymentMethod.type]?.chain_id,
             tx: await encodeApproveItx(
               paymentMethod.getEvmClient(),
               ethWallet.address,
@@ -847,7 +865,7 @@ export async function ensureSubscription(subscriptionId: string): Promise<Result
     throw new Error(`Payment currency not found for subscription ${subscriptionId}`);
   }
 
-  if (['arcblock', 'ethereum'].includes(paymentMethod.type) === false) {
+  if (CHARGE_SUPPORTED_CHAIN_TYPES.includes(paymentMethod.type) === false) {
     throw new Error(`Payment method ${paymentMethod.type} should not be here`);
   }
 
@@ -900,7 +918,7 @@ export async function ensureChangePaymentContext(subscriptionId: string) {
     throw new Error(`Payment currency not found for SetupIntent ${setupIntent.id}`);
   }
 
-  if (['arcblock', 'ethereum'].includes(paymentMethod.type) === false) {
+  if (CHARGE_SUPPORTED_CHAIN_TYPES.includes(paymentMethod.type) === false) {
     throw new Error(`Payment method ${paymentMethod.type} should not be here`);
   }
 

package/api/src/routes/connect/subscribe.ts

@@ -18,6 +18,7 @@ import {
   getStakeTxClaim,
 } from './shared';
 import { ensureStakeInvoice } from '../../libs/invoice';
+import { EVM_CHAIN_TYPES } from '../../libs/constants';
 
 export default {
   action: 'subscription',
@@ -94,7 +95,7 @@ export default {
       return claims;
     }
 
-    if (paymentMethod.type === 'ethereum') {
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
       if (!paymentCurrency.contract) {
         throw new Error(`Payment currency ${paymentMethod.type}:${paymentCurrency.id} does not support subscription`);
       }
@@ -194,7 +195,7 @@ export default {
       return { hash: paymentDetails.tx_hash };
     }
 
-    if (paymentMethod.type === 'ethereum') {
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
       await prepareTxExecution();
       const { invoice } = await ensureInvoiceForCheckout({ checkoutSession, customer, subscription });
       broadcastEvmTransaction(checkoutSessionId, 'pending', claims);

package/api/src/routes/payment-currencies.ts

@@ -7,6 +7,7 @@ import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
 import { PaymentCurrency, TPaymentCurrency } from '../store/models/payment-currency';
 import { PaymentMethod } from '../store/models/payment-method';
+import { EVM_CHAIN_TYPES } from '../libs/constants';
 
 const router = Router();
 
@@ -24,6 +25,11 @@ router.post('/', auth, async (req, res) => {
   if (!raw.description) {
     return res.status(400).json({ error: 'payment currency description is required' });
   }
+  const method = await PaymentMethod.findByPk(raw.payment_method_id);
+  if (!method) {
+    return res.status(400).json({ error: 'payment method not found' });
+  }
+  raw.logo = raw.logo || method.logo;
   if (!raw.logo) {
     return res.status(400).json({ error: 'payment currency logo is required' });
   }
@@ -35,22 +41,17 @@ router.post('/', auth, async (req, res) => {
     return res.status(400).json({ error: 'payment currency with same contract already exist' });
   }
 
-  const method = await PaymentMethod.findByPk(raw.payment_method_id);
-  if (!method) {
-    return res.status(400).json({ error: 'payment method not found' });
-  }
-
   if (method.type === 'stripe') {
     return res.status(400).json({ error: 'Adding method for stripe not supported' });
   }
 
-  if (method.type === 'ethereum') {
+  if (EVM_CHAIN_TYPES.includes(method.type)) {
     try {
       const client = method.getEvmClient();
       const info = await fetchErc20Meta(client, raw.contract);
-      logger.info('ethereum erc20 info fetched', { raw, info });
+      logger.info(`${method.type} erc20 info fetched`, { raw, info });
       if (!info.symbol || !info.decimal) {
-        return res.status(400).json({ error: 'ethereum token not found' });
+        return res.status(400).json({ error: `${method.type} token not found` });
       }
 
       const currency = await PaymentCurrency.create({
@@ -76,7 +77,7 @@ router.post('/', auth, async (req, res) => {
       return res.json(currency);
     } catch (err) {
       console.error(err);
-      return res.status(400).json({ error: 'ethereum currency contract verify failed' });
+      return res.status(400).json({ error: `${method.type} currency contract verify failed` });
     }
   }
 
@@ -112,7 +113,7 @@ router.post('/', auth, async (req, res) => {
       return res.json(currency);
     } catch (err) {
       console.error(err);
-      return res.status(400).json({ error: 'ethereum currency contract verify failed' });
+      return res.status(400).json({ error: `${method.type} currency contract verify failed` });
     }
   }
 

package/api/src/routes/payment-methods.ts

@@ -11,7 +11,9 @@ import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { PaymentMethod, TPaymentMethod } from '../store/models/payment-method';
-import type { PaymentMethodSettings } from '../store/models/types';
+import type { EVMChainType, PaymentMethodSettings } from '../store/models/types';
+import { ethWallet, wallet } from '../libs/auth';
+import { EVM_CHAIN_TYPES } from '../libs/constants';
 
 const router = Router();
 
@@ -90,36 +92,41 @@ router.post('/', auth, async (req, res) => {
     return res.json({ ...method.toJSON(), payment_currencies: [currency.toJSON()] });
   }
 
-  if (raw.type === 'ethereum') {
-    if (!raw.settings.ethereum?.api_host) {
-      return res.status(400).json({ error: 'ethereum api_host is required' });
+  if (EVM_CHAIN_TYPES.includes(raw.type as string)) {
+    const paymentType = raw.type as EVMChainType;
+    if (!raw.settings[paymentType]?.api_host) {
+      return res.status(400).json({ error: `${paymentType} api_host is required` });
     }
-    if (!raw.settings.ethereum?.explorer_host) {
-      return res.status(400).json({ error: 'ethereum explorer_host is required' });
+    if (!raw.settings[paymentType]?.explorer_host) {
+      return res.status(400).json({ error: `${paymentType} explorer_host is required` });
     }
-    if (!raw.settings.ethereum?.native_symbol) {
-      return res.status(400).json({ error: 'ethereum native_symbol is required' });
+    if (!raw.settings[paymentType]?.native_symbol) {
+      return res.status(400).json({ error: `${paymentType} native_symbol is required` });
     }
 
     try {
-      const provider = new ethers.JsonRpcProvider(raw.settings.ethereum.api_host);
+      const provider = new ethers.JsonRpcProvider(raw.settings[paymentType]?.api_host);
       const [network, blockNumber] = await Promise.all([provider.getNetwork(), provider.getBlockNumber()]);
-      raw.settings.ethereum.chain_id = network.chainId.toString();
-      logger.info('ethereum api endpoint verified', { settings: raw.settings.ethereum, network, blockNumber });
+      raw.settings[paymentType]!.chain_id = network.chainId.toString();
+      logger.info(`${paymentType} api endpoint verified`, {
+        settings: raw.settings[paymentType],
+        network,
+        blockNumber,
+      });
     } catch (err) {
       logger.error('verify ethereum api endpoint failed', err);
       return res.status(400).json({ error: err.message });
     }
 
     const exist = await PaymentMethod.findOne({
-      where: { type: 'ethereum', 'settings.ethereum.chain_id': raw.settings.ethereum?.chain_id },
+      where: { type: paymentType, [`settings.${paymentType}.chain_id`]: raw.settings[paymentType]?.chain_id },
     });
     if (exist) {
-      return res.status(400).json({ error: 'ethereum payment method already exist' });
+      return res.status(400).json({ error: `${paymentType} payment method already exist` });
     }
 
-    raw.settings = pick(PaymentMethod.encryptSettings(raw.settings), ['ethereum']) as PaymentMethodSettings;
-    raw.logo = raw.logo || getUrl('/methods/ethereum.png');
+    raw.settings = pick(PaymentMethod.encryptSettings(raw.settings), [paymentType]) as PaymentMethodSettings;
+    raw.logo = raw.logo || getUrl(`/methods/${paymentType}.png`);
     raw.features = {
       recurring: true,
       refund: true,
@@ -127,13 +134,13 @@ router.post('/', auth, async (req, res) => {
     };
     raw.confirmation = {
       type: 'block',
-      block: raw.settings.ethereum?.confirmation || 1,
+      block: raw.settings[paymentType]?.confirmation || 1,
     };
 
     const method = await PaymentMethod.create(raw as TPaymentMethod);
 
     // create currency for native currency
-    const symbol = raw.settings.ethereum?.native_symbol as string;
+    const symbol = raw.settings[paymentType]?.native_symbol as string;
     const currency = await PaymentCurrency.create({
       livemode: method.livemode,
       active: method.active,
@@ -177,8 +184,11 @@ router.get('/', auth, async (req, res) => {
     order: [['created_at', 'ASC']],
     include: [{ model: PaymentCurrency, as: 'payment_currencies', order: [['created_at', 'ASC']] }],
   });
-
-  res.json(list);
+  if (query.addresses === 'true') {
+    res.json({ list, addresses: { arcblock: wallet.address, ethereum: ethWallet.address } });
+  } else {
+    res.json(list);
+  }
 });
 
 router.get('/types', auth, (_, res) => {
@@ -201,6 +211,12 @@ router.get('/types', auth, (_, res) => {
       description: 'Pay with ethereum compatible chains',
       logo: getUrl('/methods/ethereum.png'),
     },
+    {
+      type: 'base',
+      name: 'Base',
+      description: 'Pay with base compatible chains',
+      logo: getUrl('/methods/base.png'),
+    },
   ]);
 });
 

package/api/src/routes/payment-stats.ts

@@ -10,6 +10,7 @@ import { ethWallet, wallet } from '../libs/auth';
 import dayjs from '../libs/dayjs';
 import { authenticate } from '../libs/security';
 import {
+  EVMChainType,
   Invoice,
   PaymentCurrency,
   PaymentIntent,
@@ -19,6 +20,7 @@ import {
   Refund,
   Subscription,
 } from '../store/models';
+import { EVM_CHAIN_TYPES } from '../libs/constants';
 
 const router = Router();
 const auth = authenticate<PaymentStat>({ component: true, roles: ['owner', 'admin'] });
@@ -98,8 +100,12 @@ async function getCurrencyLinks(livemode: boolean) {
         'tokens'
       );
     }
-    if (item.payment_method?.type === 'ethereum') {
-      acc[item.id] = joinURL(item.payment_method.settings.ethereum?.explorer_host, 'address', ethWallet.address);
+    if (EVM_CHAIN_TYPES.includes(item.payment_method?.type as string)) {
+      acc[item.id] = joinURL(
+        item.payment_method.settings[item.payment_method.type as EVMChainType]?.explorer_host,
+        'address',
+        ethWallet.address
+      );
     }
     return acc;
   }, {} as any);
@@ -110,7 +116,7 @@ router.get('/summary', auth, async (req, res) => {
   try {
     const [arcblock, ethereum, links] = await Promise.all([
       getTokenSummaryByDid(wallet.address, !!req.livemode, 'arcblock'),
-      getTokenSummaryByDid(ethWallet.address, !!req.livemode, 'ethereum'),
+      getTokenSummaryByDid(ethWallet.address, !!req.livemode, EVM_CHAIN_TYPES),
       getCurrencyLinks(!!req.livemode),
     ]);
     res.json({

package/api/src/routes/prices.ts

@@ -11,6 +11,7 @@ import { canUpsell } from '../libs/session';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
+import { checkCurrencySupportRecurring } from '../libs/product';
 
 const router = Router();
 
@@ -162,7 +163,14 @@ export async function createPrice(payload: any) {
 
   raw.currency_options = Price.formatCurrencies(raw.currency_options, currencies);
   raw.unit_amount = fromTokenToUnit(raw.unit_amount, currency.decimal).toString();
-
+  const isRecurring = payload.type === 'recurring';
+  const { notSupportCurrencies, validate } = await checkCurrencySupportRecurring(
+    (raw.currency_options || [])?.map((x) => x.currency_id).filter(Boolean),
+    isRecurring
+  );
+  if (!validate) {
+    throw new Error(`currency ${notSupportCurrencies.map((x) => x.name).join(', ')} does not support recurring`);
+  }
   const price = await Price.insert(raw);
   return getExpandedPrice(price.id as string);
 }
@@ -349,6 +357,16 @@ router.put('/:id', auth, async (req, res) => {
       });
     }
   }
+  const isRecurring = updates.type === 'recurring';
+  const { notSupportCurrencies, validate } = await checkCurrencySupportRecurring(
+    (updates.currency_options || [])?.map((x) => x.currency_id).filter(Boolean),
+    isRecurring
+  );
+  if (!validate) {
+    return res
+      .status(400)
+      .json({ error: `currency ${notSupportCurrencies.map((x) => x.name).join(', ')} does not support recurring` });
+  }
 
   try {
     await doc.update(Price.formatBeforeSave(updates));

package/api/src/routes/products.ts

@@ -13,6 +13,7 @@ import { PaymentCurrency } from '../store/models/payment-currency';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
 import type { CustomUnitAmount } from '../store/models/types';
+import { checkCurrencySupportRecurring } from '../libs/product';
 
 const router = Router();
 
@@ -57,6 +58,7 @@ const ProductAndPriceSchema = Joi.object({
 }).unknown(true);
 
 export async function createProductAndPrices(payload: any) {
+  // 1. 准备 product 数据
   const raw: Partial<Product> = pick(payload, [
     'name',
     'type',
@@ -75,66 +77,96 @@ export async function createProductAndPrices(payload: any) {
   raw.created_via = payload.via || 'api';
   raw.metadata = formatMetadata(raw.metadata);
 
-  const product = await Product.create(raw as Product);
+  // 2. 验证并准备 prices 数据
+  let pricesRaw: (Price & { model: 'string' })[] = [];
   if (Array.isArray(payload.prices) && payload.prices.length) {
     if (payload.prices.some((x: any) => !x.unit_amount && !x.custom_unit_amount)) {
       throw new Error('unit_amount or custom_unit_amount is required for price');
     }
 
     const currencies = await PaymentCurrency.findAll({ where: { active: true } });
-    const pricesRaw = payload.prices.map((price: Price & { model: 'string' }) => {
-      price.product_id = product.id;
-      price.active = product.active;
-      price.livemode = product.livemode;
-      price.currency_id = price.currency_id || payload.currency_id;
+    pricesRaw = payload.prices.map((price: Price & { model: 'string' }) => {
+      const newPrice = { ...price };
+      newPrice.active = !!raw.active;
+      newPrice.livemode = !!raw.livemode;
+      newPrice.currency_id = price.currency_id || payload.currency_id;
 
-      const currency = currencies.find((x) => x.id === price.currency_id);
+      const currency = currencies.find((x) => x.id === newPrice.currency_id);
       if (!currency) {
-        throw new Error(`currency ${price.currency_id} used in price not found or inactive`);
+        throw new Error(`currency ${newPrice.currency_id} used in price not found or inactive`);
       }
-      if (price.custom_unit_amount) {
+
+      if (newPrice.custom_unit_amount) {
         // @ts-ignore
         ['preset', 'maximum', 'minimum'].forEach((key: keyof CustomUnitAmount) => {
-          if (price.custom_unit_amount?.[key]) {
-            price.custom_unit_amount[key] = fromTokenToUnit(
-              price.custom_unit_amount[key] as string,
+          if (newPrice.custom_unit_amount?.[key]) {
+            newPrice.custom_unit_amount[key] = fromTokenToUnit(
+              newPrice.custom_unit_amount[key] as string,
               currency.decimal
             ).toString();
           }
         });
-        if (Array.isArray(price.custom_unit_amount.presets)) {
-          price.custom_unit_amount.presets = price.custom_unit_amount.presets.map((x) =>
+        if (Array.isArray(newPrice.custom_unit_amount.presets)) {
+          newPrice.custom_unit_amount.presets = newPrice.custom_unit_amount.presets.map((x) =>
             fromTokenToUnit(x, currency.decimal).toString()
           );
         }
       } else {
-        if (!price.unit_amount) {
+        if (!newPrice.unit_amount) {
           throw new Error('price.unit_amount is required');
         }
-        price.unit_amount = fromTokenToUnit(price.unit_amount, currency.decimal).toString();
+        newPrice.unit_amount = fromTokenToUnit(newPrice.unit_amount, currency.decimal).toString();
       }
 
-      if (Array.isArray(price.currency_options)) {
-        price.currency_options = Price.formatCurrencies(price.currency_options, currencies);
+      if (Array.isArray(newPrice.currency_options)) {
+        newPrice.currency_options = Price.formatCurrencies(newPrice.currency_options, currencies);
       } else {
-        price.currency_options = [];
+        newPrice.currency_options = [];
       }
-      if (price.currency_options.some((x) => x.currency_id === price.currency_id) === false) {
-        price.currency_options.unshift({
-          currency_id: price.currency_id,
-          unit_amount: price.unit_amount,
+
+      if (newPrice.currency_options.some((x) => x.currency_id === newPrice.currency_id) === false) {
+        newPrice.currency_options.unshift({
+          currency_id: newPrice.currency_id,
+          unit_amount: newPrice.unit_amount,
           tiers: null,
-          custom_unit_amount: price.custom_unit_amount,
+          custom_unit_amount: newPrice.custom_unit_amount,
         });
       }
 
-      return price;
+      return newPrice;
     });
 
-    const prices = await Promise.all(pricesRaw.map((x: Price & { model: 'string' }) => Price.insert(x)));
+    // 3. 验证货币是否支持 recurring
+    const validationResults = await Promise.all(
+      pricesRaw.map((x) => {
+        const isRecurring = x.type === 'recurring';
+        const currencyIds = (x.currency_options || []).map((c) => c.currency_id).filter(Boolean);
+        return checkCurrencySupportRecurring(currencyIds, isRecurring);
+      })
+    );
+
+    const invalidCurrencies = validationResults.filter((result) => !result.validate);
+    if (invalidCurrencies.length > 0) {
+      throw new Error(
+        `Currency ${invalidCurrencies.flatMap((result) => result.notSupportCurrencies.map((c) => c?.name)).join(', ')} does not support recurring`
+      );
+    }
+  }
+
+  // 4. 所有验证通过后，创建 product
+  const product = await Product.create(raw as Product);
+
+  // 5. 创建 prices
+  if (pricesRaw.length > 0) {
+    const prices = await Promise.all(
+      pricesRaw.map((price) => {
+        price.product_id = product.id;
+        return Price.insert(price);
+      })
+    );
 
-    // update default price id
-    product.default_price_id = prices[0].id;
+    // 6. 更新 default price
+    product.default_price_id = prices?.[0]?.id;
     await product.save();
 
     return { ...product.toJSON(), prices: prices.map((x) => x.toJSON()) };

package/api/src/routes/subscriptions.ts

@@ -64,6 +64,7 @@ import { createUsageRecordQueryFn } from './usage-records';
 import { SubscriptionWillCanceledSchedule } from '../crons/subscription-will-canceled';
 import { getTokenByAddress } from '../integrations/arcblock/stake';
 import { ensureOverdraftProtectionPrice } from '../libs/overdraft-protection';
+import { CHARGE_SUPPORTED_CHAIN_TYPES } from '../libs/constants';
 
 const router = Router();
 const auth = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
@@ -1766,7 +1767,7 @@ router.get('/:id/cycle-amount', authPortal, async (req, res) => {
 
   if (req.query?.overdraftProtection) {
     const { price } = await ensureOverdraftProtectionPrice(subscription.livemode);
-    const invoicePrice = price.currency_options.find((x: any) => x.currency_id === subscription?.currency_id);
+    const invoicePrice = (price?.currency_options || []).find((x: any) => x.currency_id === subscription?.currency_id);
     const gas = invoicePrice?.unit_amount;
     return res.json({
       amount: new BN(maxAmount).add(new BN(gas)).toString(),
@@ -1856,7 +1857,7 @@ router.get('/:id/payer-token', authMine, async (req, res) => {
 
   // @ts-ignore
   const paymentAddress = getSubscriptionPaymentAddress(subscription, paymentMethod.type);
-  if (!paymentAddress && ['ethereum', 'arcblock'].includes(paymentMethod.type)) {
+  if (!paymentAddress && CHARGE_SUPPORTED_CHAIN_TYPES.includes(paymentMethod.type)) {
     return res.status(400).json({ error: `Payer not found on subscription payment detail: ${subscription.id}` });
   }
 
@@ -2015,7 +2016,7 @@ router.get('/:id/overdraft-protection', authPortal, async (req, res) => {
       await isSubscriptionOverdraftProtectionEnabled(subscription);
     const upcoming = await getUpcomingInvoiceAmount(req.params.id as string);
     const { price } = await ensureOverdraftProtectionPrice(subscription.livemode);
-    const invoicePrice = price.currency_options.find((x: any) => x.currency_id === subscription?.currency_id);
+    const invoicePrice = (price?.currency_options || []).find((x: any) => x.currency_id === subscription?.currency_id);
     const gas = invoicePrice?.unit_amount;
     return res.json({
       enabled,