payment-kit 1.29.1 → 1.29.3

package/api/src/routes/{payment-currencies.ts → hono/payment-currencies.ts}

@@ -1,70 +1,79 @@
+// Phase 3 (express→hono) — hono fork of routes/payment-currencies.ts. Sub-app with
+// routes relative to /api/payment-currencies (mounted via mountResourceGroup). The
+// business logic is unchanged; only the express plumbing becomes hono:
+//   req.body → c.get('sanitizedBody'); res.status(n).json(x) → c.json(x, n).
 import { fromTokenToUnit } from '@ocap/util';
-import { Router } from 'express';
+import { Hono } from 'hono';
 import { InferAttributes, Op, WhereOptions } from 'sequelize';
 
 import Joi from 'joi';
 import pick from 'lodash/pick';
-import { sessionMiddleware } from '@blocklet/sdk/lib/middlewares/session';
-import { fetchErc20Meta } from '../integrations/ethereum/token';
-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 { Price, Product } from '../store/models';
-import { EVM_CHAIN_TYPES } from '../libs/constants';
-import { ethWallet, getVaultAddress, wallet } from '../libs/auth';
-import { resolveAddressChainTypes } from '../libs/util';
-import { depositVaultQueue } from '../queues/payment';
-import { checkDepositVaultAmount } from '../libs/payment';
-import { getTokenSummaryByDid } from '../integrations/arcblock/stake';
-import { MetadataSchema } from '../libs/api';
-import { getRechargePaymentUrl } from '../libs/currency';
-import { checkCurrencySupportRecurring } from '../libs/product';
-
-const router = Router();
+import { fetchErc20Meta } from '../../integrations/ethereum/token';
+import logger from '../../libs/logger';
+import { authenticate } from '../../middlewares/hono/security';
+import { sessionMiddleware } from '../../middlewares/hono/session';
+import { PaymentCurrency, TPaymentCurrency } from '../../store/models/payment-currency';
+import { PaymentMethod } from '../../store/models/payment-method';
+import { Price, Product } from '../../store/models';
+import { EVM_CHAIN_TYPES } from '../../libs/constants';
+import { ethWallet, getVaultAddress, wallet } from '../../libs/auth';
+import { resolveAddressChainTypes } from '../../libs/util';
+import { depositVaultQueue } from '../../queues/payment';
+import { checkDepositVaultAmount } from '../../libs/payment';
+import { getTokenSummaryByDid } from '../../integrations/arcblock/stake';
+import { MetadataSchema } from '../../libs/api';
+import { getRechargePaymentUrl } from '../../libs/currency';
+import { checkCurrencySupportRecurring } from '../../libs/product';
+
+const app = new Hono();
 
-const user = sessionMiddleware({ accessKey: true });
 const auth = authenticate<PaymentCurrency>({ component: true, roles: ['owner', 'admin'] });
 const authOwner = authenticate<PaymentCurrency>({ component: true, roles: ['owner'] });
+// faithful fork of the express `sessionMiddleware({ accessKey: true })` — populates
+// c.get('user') from a login token OR access key, and does NOT gate (next() either way).
+const user = sessionMiddleware({ accessKey: true });
+
 const paymentCurrencyCreateSchema = Joi.object({
   name: Joi.string().max(32).required(),
   description: Joi.string().max(255).required(),
 }).unknown(true);
-router.post('/', auth, async (req, res) => {
-  const raw: Partial<TPaymentCurrency> = req.body;
 
-  const { error } = paymentCurrencyCreateSchema.validate(pick(req.body, ['name', 'description']));
+app.post('/', auth, async (c) => {
+  const body = c.get('sanitizedBody') ?? {};
+  const raw: Partial<TPaymentCurrency> = body;
+
+  const { error } = paymentCurrencyCreateSchema.validate(pick(body, ['name', 'description']));
   if (error) {
-    return res.status(400).json({ error: error.message });
+    return c.json({ error: error.message }, 400);
   }
 
   if (!raw.payment_method_id) {
-    return res.status(400).json({ error: 'payment_method_id is required' });
+    return c.json({ error: 'payment_method_id is required' }, 400);
   }
   if (!raw.name) {
-    return res.status(400).json({ error: 'payment currency name is required' });
+    return c.json({ error: 'payment currency name is required' }, 400);
   }
   if (!raw.description) {
-    return res.status(400).json({ error: 'payment currency description is required' });
+    return c.json({ error: 'payment currency description is required' }, 400);
   }
   const method = await PaymentMethod.findByPk(raw.payment_method_id);
   if (!method) {
-    return res.status(400).json({ error: 'payment method not found' });
+    return c.json({ error: 'payment method not found' }, 400);
   }
   raw.logo = raw.logo || method.logo;
   if (!raw.logo) {
-    return res.status(400).json({ error: 'payment currency logo is required' });
+    return c.json({ error: 'payment currency logo is required' }, 400);
   }
   if (!raw.contract) {
-    return res.status(400).json({ error: 'payment currency contract is required' });
+    return c.json({ error: 'payment currency contract is required' }, 400);
   }
   const exist = await PaymentCurrency.findOne({ where: { contract: raw.contract } });
   if (exist) {
-    return res.status(400).json({ error: 'payment currency with same contract already exist' });
+    return c.json({ error: 'payment currency with same contract already exist' }, 400);
   }
 
   if (method.type === 'stripe') {
-    return res.status(400).json({ error: 'Adding method for stripe not supported' });
+    return c.json({ error: 'Adding method for stripe not supported' }, 400);
   }
 
   if (EVM_CHAIN_TYPES.includes(method.type)) {
@@ -73,7 +82,7 @@ router.post('/', auth, async (req, res) => {
       const info = await fetchErc20Meta(client, raw.contract);
       logger.info(`${method.type} erc20 info fetched`, { raw, info });
       if (!info.symbol || !info.decimal) {
-        return res.status(400).json({ error: `${method.type} token not found` });
+        return c.json({ error: `${method.type} token not found` }, 400);
       }
 
       const currency = await PaymentCurrency.create({
@@ -98,10 +107,10 @@ router.post('/', auth, async (req, res) => {
 
         metadata: {},
       });
-      return res.json(currency);
+      return c.json(currency);
     } catch (err) {
       logger.error(err);
-      return res.status(400).json({ error: `${method.type} currency contract verify failed` });
+      return c.json({ error: `${method.type} currency contract verify failed` }, 400);
     }
   }
 
@@ -111,7 +120,7 @@ router.post('/', auth, async (req, res) => {
       const { state } = await client.getTokenState({ address: raw.contract });
       logger.info('ocap token info fetched', { raw, state });
       if (!state) {
-        return res.status(400).json({ error: 'ocap token not found' });
+        return c.json({ error: 'ocap token not found' }, 400);
       }
 
       const currency = await PaymentCurrency.create({
@@ -136,18 +145,45 @@ router.post('/', auth, async (req, res) => {
 
         metadata: {},
       });
-      return res.json(currency);
+      return c.json(currency);
     } catch (err) {
       logger.error(err);
-      return res.status(400).json({ error: `${method.type} currency contract verify failed` });
+      return c.json({ error: `${method.type} currency contract verify failed` }, 400);
     }
   }
 
-  return res.status(400).json({ error: `add currency for payment method ${method.type} is not supported` });
+  return c.json({ error: `add currency for payment method ${method.type} is not supported` }, 400);
+});
+
+// check if currencies support recurring subscriptions
+// registered before /:id routes so the static segment wins
+app.post('/check-recurring-support', async (c) => {
+  try {
+    const body = c.get('sanitizedBody') ?? {};
+    const { currency_ids: currencyIds } = body as any;
+    if (!Array.isArray(currencyIds)) {
+      return c.json({ error: 'currency_ids must be an array' }, 400);
+    }
+    if (currencyIds.length === 0) {
+      return c.json({ error: 'currency_ids cannot be empty' }, 400);
+    }
+    const { notSupportCurrencies, validate } = await checkCurrencySupportRecurring(currencyIds, true);
+    return c.json({
+      supported: validate,
+      unsupported_currencies: notSupportCurrencies.map((cur) => ({
+        id: cur.id,
+        name: cur.name,
+        symbol: cur.symbol,
+      })),
+    });
+  } catch (err) {
+    logger.error('check recurring support error', err);
+    return c.json({ error: (err as any).message }, 400);
+  }
 });
 
-router.get('/', auth, async (req, res) => {
-  const { query } = req;
+app.get('/', auth, async (c) => {
+  const query = c.req.query();
   const where: WhereOptions<InferAttributes<PaymentCurrency>> = {};
 
   if (typeof query.active === 'string') {
@@ -168,13 +204,13 @@ router.get('/', auth, async (req, res) => {
     include: [],
   });
 
-  res.json(list);
+  return c.json(list);
 });
 
-router.get('/vault-config', auth, async (req, res) => {
+app.get('/vault-config', auth, async (c) => {
   const vaultAddress = await getVaultAddress();
   if (!vaultAddress) {
-    return res.json({
+    return c.json({
       list: [],
       balances: {},
     });
@@ -196,16 +232,16 @@ router.get('/vault-config', auth, async (req, res) => {
         payment_method_id: {
           [Op.in]: paymentMethodIds,
         },
-        livemode: !!req.livemode,
+        livemode: !!c.get('livemode'),
       },
       include: [{ model: PaymentMethod, as: 'payment_method' }],
     });
     try {
       const [arcblock, ethereum] = await Promise.all([
-        getTokenSummaryByDid(wallet.address, !!req.livemode, 'arcblock'),
-        getTokenSummaryByDid(ethWallet.address, !!req.livemode, EVM_CHAIN_TYPES),
+        getTokenSummaryByDid(wallet.address, !!c.get('livemode'), 'arcblock'),
+        getTokenSummaryByDid(ethWallet.address, !!c.get('livemode'), EVM_CHAIN_TYPES),
       ]);
-      return res.json({
+      return c.json({
         list,
         balances: {
           ...arcblock,
@@ -214,54 +250,87 @@ router.get('/vault-config', auth, async (req, res) => {
       });
     } catch (err) {
       logger.error('get token summary failed', err);
-      return res.status(400).json({ error: err.message, list, balances: {} });
+      return c.json({ error: (err as any).message, list, balances: {} }, 400);
     }
   } catch (err) {
     logger.error('get payment currency vault config failed', err);
-    return res.status(400).json({ error: err.message, list: [], balances: {} });
+    return c.json({ error: (err as any).message, list: [], balances: {} }, 400);
   }
 });
 
-router.get('/:id/deposit-vault', auth, async (req, res) => {
-  const { id } = req.params;
+app.get('/:id/deposit-vault', auth, async (c) => {
+  const id = c.req.param('id');
   if (!id) {
-    return res.status(400).json({ error: 'Missing payment currency id' });
+    return c.json({ error: 'Missing payment currency id' }, 400);
   }
   try {
     const result = await checkDepositVaultAmount(id);
-    return res.json(result);
+    return c.json(result);
   } catch (error) {
     logger.error('Error checking deposit vault amount', { error, id });
-    return res.status(400).json({ error: 'Failed to check deposit vault amount', message: error.message });
+    return c.json({ error: 'Failed to check deposit vault amount', message: (error as any).message }, 400);
   }
 });
 
-router.put('/:id/deposit-vault', auth, async (req, res) => {
-  const paymentCurrency = await PaymentCurrency.findByPk(req.params.id);
+app.put('/:id/deposit-vault', auth, async (c) => {
+  const paymentCurrency = await PaymentCurrency.findByPk(c.req.param('id'));
   if (!paymentCurrency) {
-    return res.status(404).json({ error: 'Payment currency not found' });
+    return c.json({ error: 'Payment currency not found' }, 404);
   }
   const vaultAddress = await getVaultAddress();
   if (!vaultAddress) {
-    return res.status(400).json({ error: 'Vault address not found' });
+    return c.json({ error: 'Vault address not found' }, 400);
   }
   depositVaultQueue.push({
     id: `deposit-vault-${paymentCurrency.id}`,
     job: { currencyId: paymentCurrency.id },
   });
   logger.info('Deposit vault job pushed', { currencyId: paymentCurrency.id });
-  return res.json({ message: 'Deposit vault job pushed' });
+  return c.json({ message: 'Deposit vault job pushed' });
 });
 
-router.get('/:id', auth, async (req, res) => {
-  const doc = await PaymentCurrency.findOne({
-    where: { [Op.or]: [{ id: req.params.id }, { symbol: req.params.id }] },
-  });
+app.get('/:id/recharge-config', user, async (c) => {
+  try {
+    const id = c.req.param('id');
 
-  if (doc) {
-    res.json(doc);
-  } else {
-    res.status(404).json(null);
+    const currency = await PaymentCurrency.scope('withRechargeConfig').findByPk(id);
+
+    if (!currency) {
+      return c.json({ error: 'Credit currency not found' }, 404);
+    }
+
+    if (!currency.recharge_config) {
+      return c.json({
+        currency_id: id,
+        recharge_config: null,
+        message: 'No recharge config available for this currency',
+      });
+    }
+
+    const paymentUrl = await getRechargePaymentUrl(currency);
+
+    let basePrice: (Price & { product: Product }) | null = null;
+    if (currency.recharge_config.base_price_id) {
+      basePrice = (await Price.findByPk(currency.recharge_config.base_price_id, {
+        include: [{ model: Product, as: 'product' }],
+      })) as Price & { product: Product };
+    }
+
+    return c.json({
+      currency_id: id,
+      currency_info: pick(currency, ['id', 'name', 'symbol', 'decimal', 'type']),
+      recharge_config: {
+        ...currency.recharge_config,
+        basePrice,
+        payment_url: paymentUrl,
+      },
+    });
+  } catch (error: any) {
+    logger.error('Failed to get currency recharge config', {
+      currencyId: c.req.param('id'),
+      error: error.message,
+    });
+    return c.json({ error: 'Internal server error' }, 500);
   }
 });
 
@@ -271,23 +340,25 @@ const UpdateVaultConfigSchema = Joi.object({
   withdraw_threshold: Joi.number().min(0).required(),
   buffer_threshold: Joi.number().min(0).required(),
 });
-router.put('/:id/vault-config', authOwner, async (req, res) => {
+
+app.put('/:id/vault-config', authOwner, async (c) => {
   try {
-    const { id } = req.params;
+    const id = c.req.param('id');
+    const body = c.get('sanitizedBody') ?? {};
 
-    const { error, value: vaultConfig } = UpdateVaultConfigSchema.validate(req.body);
+    const { error, value: vaultConfig } = UpdateVaultConfigSchema.validate(body);
     if (error) {
-      return res.status(400).json({ error: error.message });
+      return c.json({ error: error.message }, 400);
     }
 
     const paymentCurrency = await PaymentCurrency.findByPk(id);
     if (!paymentCurrency) {
-      return res.status(404).json({ error: 'payment currency not found' });
+      return c.json({ error: 'payment currency not found' }, 404);
     }
 
     const vaultAddress = await getVaultAddress();
     if (!vaultAddress) {
-      return res.status(400).json({ error: 'Vault address not found' });
+      return c.json({ error: 'Vault address not found' }, 400);
     }
 
     const updateData: Partial<TPaymentCurrency> = {
@@ -301,10 +372,10 @@ router.put('/:id/vault-config', authOwner, async (req, res) => {
 
     await paymentCurrency.update(updateData);
 
-    return res.json(paymentCurrency.toJSON());
+    return c.json(paymentCurrency.toJSON());
   } catch (err) {
     logger.error('update payment currency vault config failed', err);
-    return res.status(400).json({ error: err.message });
+    return c.json({ error: (err as any).message }, 400);
   }
 });
 
@@ -315,26 +386,28 @@ const updateCurrencySchema = Joi.object({
   metadata: MetadataSchema,
   symbol: Joi.string().empty('').optional(),
 }).unknown(true);
-router.put('/:id', auth, async (req, res) => {
-  const { id } = req.params;
-  const raw: Partial<TPaymentCurrency> = req.body;
+
+app.put('/:id', auth, async (c) => {
+  const id = c.req.param('id');
+  const body = c.get('sanitizedBody') ?? {};
+  const raw: Partial<TPaymentCurrency> = body;
 
   const { error } = updateCurrencySchema.validate(raw);
   if (error) {
-    return res.status(400).json({ error: error.message });
+    return c.json({ error: error.message }, 400);
   }
 
   const currency = await PaymentCurrency.findByPk(id);
   if (!currency) {
-    return res.status(404).json({ error: 'Payment currency not found' });
+    return c.json({ error: 'Payment currency not found' }, 404);
   }
   if (raw.contract && raw.contract !== currency.contract) {
-    return res.status(400).json({ error: 'contract cannot be updated' });
+    return c.json({ error: 'contract cannot be updated' }, 400);
   }
 
   const method = await PaymentMethod.findByPk(currency.payment_method_id);
   if (!method) {
-    return res.status(400).json({ error: 'Payment method not found' });
+    return c.json({ error: 'Payment method not found' }, 400);
   }
 
   const updates: Partial<TPaymentCurrency> = {
@@ -349,33 +422,34 @@ router.put('/:id', auth, async (req, res) => {
   }
 
   const updatedCurrency = await currency.update(updates);
-  return res.json(updatedCurrency);
+  return c.json(updatedCurrency);
 });
 
 const tokenConfigSchema = Joi.object({
   token_factory_address: Joi.string().required(),
 });
 
-router.put('/:id/token-config', auth, async (req, res) => {
+app.put('/:id/token-config', auth, async (c) => {
   try {
-    const { id } = req.params;
+    const id = c.req.param('id');
+    const body = c.get('sanitizedBody') ?? {};
 
-    const { error, value } = tokenConfigSchema.validate(req.body);
+    const { error, value } = tokenConfigSchema.validate(body);
     if (error) {
-      return res.status(400).json({ error: error.message });
+      return c.json({ error: error.message }, 400);
     }
 
     const currency = await PaymentCurrency.findByPk(id);
     if (!currency) {
-      return res.status(404).json({ error: 'Payment currency not found' });
+      return c.json({ error: 'Payment currency not found' }, 404);
     }
 
     if (currency.type !== 'credit') {
-      return res.status(400).json({ error: 'Only credit currencies can have token_config' });
+      return c.json({ error: 'Only credit currencies can have token_config' }, 400);
     }
 
     if (currency.token_config) {
-      return res.status(400).json({ error: 'Token config already exists. Cannot be updated once set.' });
+      return c.json({ error: 'Token config already exists. Cannot be updated once set.' }, 400);
     }
 
     const paymentMethod = await PaymentMethod.findOne({
@@ -386,7 +460,7 @@ router.put('/:id/token-config', auth, async (req, res) => {
     });
 
     if (!paymentMethod) {
-      return res.status(400).json({ error: 'ArcBlock payment method not found' });
+      return c.json({ error: 'ArcBlock payment method not found' }, 400);
     }
 
     const client = paymentMethod.getOcapClient();
@@ -395,7 +469,7 @@ router.put('/:id/token-config', auth, async (req, res) => {
     });
 
     if (!tokenFactoryState) {
-      return res.status(400).json({ error: 'Token factory not found on chain' });
+      return c.json({ error: 'Token factory not found on chain' }, 400);
     }
 
     const tokenConfig = {
@@ -416,28 +490,31 @@ router.put('/:id/token-config', auth, async (req, res) => {
       tokenConfig,
     });
 
-    return res.json(currency.toJSON());
+    return c.json(currency.toJSON());
   } catch (err) {
-    logger.error('update payment currency token_config failed', { error: err?.message, id: req.params.id });
-    return res.status(400).json({ error: err?.message });
+    logger.error('update payment currency token_config failed', {
+      error: (err as any)?.message,
+      id: c.req.param('id'),
+    });
+    return c.json({ error: (err as any)?.message }, 400);
   }
 });
 
-router.delete('/:id/token-config', auth, async (req, res) => {
+app.delete('/:id/token-config', auth, async (c) => {
   try {
-    const { id } = req.params;
+    const id = c.req.param('id');
 
     const currency = await PaymentCurrency.findByPk(id);
     if (!currency) {
-      return res.status(404).json({ error: 'Payment currency not found' });
+      return c.json({ error: 'Payment currency not found' }, 404);
     }
 
     if (currency.type !== 'credit') {
-      return res.status(400).json({ error: 'Only credit currencies can have token_config' });
+      return c.json({ error: 'Only credit currencies can have token_config' }, 400);
     }
 
     if (!currency.token_config) {
-      return res.status(400).json({ error: 'Token config does not exist' });
+      return c.json({ error: 'Token config does not exist' }, 400);
     }
 
     await currency.update({
@@ -448,80 +525,25 @@ router.delete('/:id/token-config', auth, async (req, res) => {
       currencyId: id,
     });
 
-    return res.json(currency.toJSON());
-  } catch (err) {
-    logger.error('delete payment currency token_config failed', { error: err?.message, id: req.params.id });
-    return res.status(400).json({ error: err?.message });
-  }
-});
-
-router.delete('/:id', auth, async (req, res) => {
-  const { id } = req.params;
-
-  const currency = await PaymentCurrency.findByPk(id);
-  if (!currency) {
-    return res.status(404).json({ error: 'Payment currency not found' });
-  }
-  const isLocked = await currency.isLocked();
-  if (isLocked) {
-    return res.status(400).json({ error: 'Can not delete locked payment currency' });
-  }
-  const isUsed = await currency.isUsed();
-  if (isUsed) {
-    return res.status(400).json({ error: 'Can not delete payment currency used by other resources' });
-  }
-  try {
-    await currency.destroy();
-    return res.status(200).end();
+    return c.json(currency.toJSON());
   } catch (err) {
-    logger.error('delete payment currency error', err);
-    return res.status(400).json({ error: 'Delete payment currency failed' });
+    logger.error('delete payment currency token_config failed', {
+      error: (err as any)?.message,
+      id: c.req.param('id'),
+    });
+    return c.json({ error: (err as any)?.message }, 400);
   }
 });
 
-router.get('/:id/recharge-config', user, async (req, res) => {
-  try {
-    const { id } = req.params;
-
-    const currency = await PaymentCurrency.scope('withRechargeConfig').findByPk(id);
-
-    if (!currency) {
-      return res.status(404).json({ error: 'Credit currency not found' });
-    }
-
-    if (!currency.recharge_config) {
-      return res.json({
-        currency_id: id,
-        recharge_config: null,
-        message: 'No recharge config available for this currency',
-      });
-    }
-
-    const paymentUrl = await getRechargePaymentUrl(currency);
-
-    let basePrice: (Price & { product: Product }) | null = null;
-    if (currency.recharge_config.base_price_id) {
-      basePrice = (await Price.findByPk(currency.recharge_config.base_price_id, {
-        include: [{ model: Product, as: 'product' }],
-      })) as Price & { product: Product };
-    }
+app.get('/:id', auth, async (c) => {
+  const doc = await PaymentCurrency.findOne({
+    where: { [Op.or]: [{ id: c.req.param('id') }, { symbol: c.req.param('id') }] },
+  });
 
-    return res.json({
-      currency_id: id,
-      currency_info: pick(currency, ['id', 'name', 'symbol', 'decimal', 'type']),
-      recharge_config: {
-        ...currency.recharge_config,
-        basePrice,
-        payment_url: paymentUrl,
-      },
-    });
-  } catch (error: any) {
-    logger.error('Failed to get currency recharge config', {
-      currencyId: req.params.id,
-      error: error.message,
-    });
-    return res.status(500).json({ error: 'Internal server error' });
+  if (doc) {
+    return c.json(doc);
   }
+  return c.json(null, 404);
 });
 
 const rechargeConfigSchema = Joi.object({
@@ -534,19 +556,20 @@ const rechargeConfigSchema = Joi.object({
   }).optional(),
 }).unknown(true);
 
-router.put('/:id/recharge-config', auth, async (req, res) => {
-  const { id } = req.params;
+app.put('/:id/recharge-config', auth, async (c) => {
+  const id = c.req.param('id');
+  const body = c.get('sanitizedBody') ?? {};
   const { error, value: rechargeConfig } = rechargeConfigSchema.validate(
-    pick(req.body, ['base_price_id', 'payment_link_id', 'checkout_url', 'settings'])
+    pick(body, ['base_price_id', 'payment_link_id', 'checkout_url', 'settings'])
   );
   if (error) {
-    return res.status(400).json({ error: error.message });
+    return c.json({ error: error.message }, 400);
   }
 
   const currency = await PaymentCurrency.findByPk(id);
 
   if (!currency) {
-    return res.status(404).json({ error: 'Credit currency not found' });
+    return c.json({ error: 'Credit currency not found' }, 404);
   }
 
   if (rechargeConfig.base_price_id) {
@@ -559,7 +582,7 @@ router.put('/:id/recharge-config', auth, async (req, res) => {
     })) as Price & { product: Product };
 
     if (!basePrice) {
-      return res.status(404).json({ error: 'Base price not found or inactive' });
+      return c.json({ error: 'Base price not found or inactive' }, 404);
     }
   }
 
@@ -571,36 +594,35 @@ router.put('/:id/recharge-config', auth, async (req, res) => {
     tiersCount: rechargeConfig.price_tiers?.length || 0,
   });
 
-  return res.json({
+  return c.json({
     currency_id: id,
     recharge_config: rechargeConfig,
     message: 'Recharge config updated successfully',
   });
 });
 
-// check if currencies support recurring subscriptions
-router.post('/check-recurring-support', async (req, res) => {
+app.delete('/:id', auth, async (c) => {
+  const id = c.req.param('id');
+
+  const currency = await PaymentCurrency.findByPk(id);
+  if (!currency) {
+    return c.json({ error: 'Payment currency not found' }, 404);
+  }
+  const isLocked = await currency.isLocked();
+  if (isLocked) {
+    return c.json({ error: 'Can not delete locked payment currency' }, 400);
+  }
+  const isUsed = await currency.isUsed();
+  if (isUsed) {
+    return c.json({ error: 'Can not delete payment currency used by other resources' }, 400);
+  }
   try {
-    const { currency_ids: currencyIds } = req.body;
-    if (!Array.isArray(currencyIds)) {
-      return res.status(400).json({ error: 'currency_ids must be an array' });
-    }
-    if (currencyIds.length === 0) {
-      return res.status(400).json({ error: 'currency_ids cannot be empty' });
-    }
-    const { notSupportCurrencies, validate } = await checkCurrencySupportRecurring(currencyIds, true);
-    return res.json({
-      supported: validate,
-      unsupported_currencies: notSupportCurrencies.map((c) => ({
-        id: c.id,
-        name: c.name,
-        symbol: c.symbol,
-      })),
-    });
+    await currency.destroy();
+    return c.body(null, 200);
   } catch (err) {
-    logger.error('check recurring support error', err);
-    return res.status(400).json({ error: err.message });
+    logger.error('delete payment currency error', err);
+    return c.json({ error: 'Delete payment currency failed' }, 400);
   }
 });
 
-export default router;
+export default app;