payment-kit 1.18.47 → 1.18.48

package/api/src/index.ts

@@ -40,6 +40,7 @@ import subscribeHandlers from './routes/connect/subscribe';
 import delegationHandlers from './routes/connect/delegation';
 import overdraftProtectionHandlers from './routes/connect/overdraft-protection';
 import rechargeAccountHandlers from './routes/connect/recharge-account';
+import reStakeHandlers from './routes/connect/re-stake';
 import { initialize } from './store/models';
 import { sequelize } from './store/sequelize';
 import { initUserHandler } from './integrations/blocklet/user';
@@ -79,6 +80,7 @@ handlers.attach(Object.assign({ app: router }, rechargeHandlers));
 handlers.attach(Object.assign({ app: router }, rechargeAccountHandlers));
 handlers.attach(Object.assign({ app: router }, delegationHandlers));
 handlers.attach(Object.assign({ app: router }, overdraftProtectionHandlers));
+handlers.attach(Object.assign({ app: router }, reStakeHandlers));
 router.use('/api', routes);
 
 const isProduction = process.env.BLOCKLET_MODE === 'production';

package/api/src/libs/pagination.ts

@@ -145,10 +145,11 @@ function calculateFetchStrategy<T>(
       if (sources.length > 1) {
         // For multi-source scenarios, we need more data to ensure correct merging
         // Especially for later pages, estimation can be inaccurate
-        const bufferMultiplier = Math.max(2, Math.ceil(page / 2)); // More buffer for later pages
+        const bufferMultiplier = Math.max(3, Math.ceil(page * 1.5)); // More aggressive buffer for later pages
+        const minDataRatio = page <= 2 ? 0.6 : 0.8; // Get more data for later pages
         const fetchLimit = Math.min(
           sourceCount,
-          Math.max(pageSize * bufferMultiplier, Math.ceil(sourceCount * 0.5)) // At least 50% of source data
+          Math.max(pageSize * bufferMultiplier, Math.ceil(sourceCount * minDataRatio))
         );
         return { fetchLimit, fetchOffset: 0 };
       }
@@ -163,7 +164,8 @@ function calculateFetchStrategy<T>(
     if (sourceMeta?.type === 'cached' || sourceMeta?.type === 'computed') {
       // For multi-source, be more conservative
       if (sources.length > 1) {
-        const fetchLimit = Math.min(sourceCount, Math.max(pageSize * 3, Math.ceil(sourceCount * 0.8))); // Get 80% of data
+        const minDataRatio = page <= 2 ? 0.7 : 0.9; // Get more data for later pages
+        const fetchLimit = Math.min(sourceCount, Math.max(pageSize * 3, Math.ceil(sourceCount * minDataRatio)));
         return { fetchLimit, fetchOffset: 0 };
       }
       const bufferSize = Math.min(sourceMeta.estimatedSize ?? sourceCount, pageSize * 2);
@@ -172,7 +174,8 @@ function calculateFetchStrategy<T>(
 
     // Default strategy: more conservative for multi-source
     if (sources.length > 1) {
-      const fetchLimit = Math.min(sourceCount, Math.max(pageSize * 2, Math.ceil(sourceCount * 0.6))); // Get 60% of data
+      const minDataRatio = page <= 2 ? 0.6 : 0.8; // Get more data for later pages
+      const fetchLimit = Math.min(sourceCount, Math.max(pageSize * 2, Math.ceil(sourceCount * minDataRatio)));
       return { fetchLimit, fetchOffset: 0 };
     }
     const fetchLimit = Math.min(pageSize * 2, sourceCount);

package/api/src/libs/subscription.ts

@@ -904,7 +904,7 @@ export async function checkRemainingStake(
   }
 
   return {
-    enough: total.gte(new BN(amount)),
+    enough: total.gte(new BN(amount || '0')),
     staked,
     revoked,
   };

package/api/src/routes/connect/re-stake.ts

@@ -0,0 +1,116 @@
+import type { CallbackArgs } from '../../libs/auth';
+import { type TLineItemExpanded } from '../../store/models';
+import { ensureReStakeContext, executeOcapTransactions, getAuthPrincipalClaim, getStakeTxClaim } from './shared';
+import { ensureStakeInvoice } from '../../libs/invoice';
+import logger from '../../libs/logger';
+import { addSubscriptionJob, subscriptionQueue } from '../../queues/subscription';
+import { SubscriptionWillCanceledSchedule } from '../../crons/subscription-will-canceled';
+
+export default {
+  action: 're-stake',
+  authPrincipal: false,
+  persistentDynamicClaims: false,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensureReStakeContext(extraParams.subscriptionId);
+      return getAuthPrincipalClaim(paymentMethod, 'continue');
+    },
+  },
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    const { subscription, paymentMethod, paymentCurrency, payerAddress } = await ensureReStakeContext(subscriptionId);
+    if (userDid !== payerAddress) {
+      throw new Error(
+        `You are not the payer for this subscription. Expected payer: ${payerAddress}, but found: ${userDid}.`
+      );
+    }
+    // @ts-ignore
+    const items = subscription!.items as TLineItemExpanded[];
+
+    if (paymentMethod.type === 'arcblock') {
+      return [
+        {
+          prepareTx: await getStakeTxClaim({
+            userDid,
+            userPk,
+            paymentCurrency,
+            paymentMethod,
+            items,
+            subscription,
+          }),
+        },
+      ];
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+
+  onAuth: async ({ request, userDid, userPk, claims, extraParams }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    const { subscription, paymentMethod, paymentCurrency, customer } = await ensureReStakeContext(subscriptionId);
+
+    if (paymentMethod.type === 'arcblock') {
+      const { stakingAmount, ...paymentDetails } = await executeOcapTransactions(
+        userDid,
+        userPk,
+        claims,
+        paymentMethod,
+        request,
+        subscription?.id,
+        paymentCurrency.contract
+      );
+
+      // 创建质押账单
+      await ensureStakeInvoice(
+        {
+          total: stakingAmount,
+          description: 'Re-stake to resume subscription',
+          currency_id: paymentCurrency.id,
+          metadata: {
+            payment_details: {
+              arcblock: {
+                tx_hash: paymentDetails?.staking?.tx_hash,
+                payer: paymentDetails?.payer,
+                address: paymentDetails?.staking?.address,
+              },
+            },
+          },
+        },
+        subscription!,
+        paymentMethod,
+        customer!
+      );
+
+      await subscription.update({
+        cancel_at_period_end: false,
+        cancel_at: 0,
+        canceled_at: 0,
+        // @ts-ignore
+        cancelation_details: null,
+        payment_details: {
+          ...subscription.payment_details,
+          [paymentMethod.type]: paymentDetails,
+        },
+      });
+
+      await new SubscriptionWillCanceledSchedule().deleteScheduleSubscriptionJobs([subscription]);
+
+      subscriptionQueue
+        .delete(`cancel-${subscription.id}`)
+        .then(() => logger.info('subscription cancel job is canceled'))
+        .catch((err) => logger.error('subscription cancel job failed to cancel', { error: err }));
+      await addSubscriptionJob(subscription, 'cycle');
+
+      logger.info('Subscription resumed with re-stake', {
+        subscriptionId: subscription.id,
+        stakingTxHash: paymentDetails?.staking?.tx_hash,
+        stakingAddress: paymentDetails?.staking?.address,
+      });
+      return {
+        hash: paymentDetails.staking?.tx_hash,
+      };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+};

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

@@ -15,6 +15,7 @@ import {
   getAuthPrincipalClaim,
   getDelegationTxClaim,
   getStakeTxClaim,
+  returnStakeForCanceledSubscription,
 } from './shared';
 import { ensureStakeInvoice } from '../../libs/invoice';
 import { EVM_CHAIN_TYPES } from '../../libs/constants';
@@ -239,6 +240,10 @@ export default {
         );
         await afterTxExecution(paymentDetails);
 
+        if (subscription.recovered_from) {
+          returnStakeForCanceledSubscription(subscription.recovered_from);
+        }
+
         return { hash: paymentDetails.tx_hash };
       } catch (err) {
         logger.error('Failed to finalize setup', { setupIntent: setupIntent.id, error: err });

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

@@ -43,6 +43,7 @@ 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';
+import { returnStakeQueue } from '../../queues/subscription';
 
 type Result = {
   checkoutSession: CheckoutSession;
@@ -783,6 +784,15 @@ export async function getDelegationTxClaim({
   throw new Error(`getDelegationTxClaim: Payment method ${paymentMethod.type} not supported`);
 }
 
+export function getStakeAmount(subscription: Subscription, paymentCurrency: PaymentCurrency, items: TLineItemExpanded[]) {
+  const billingThreshold = Number(subscription.billing_thresholds?.amount_gte || 0);
+  const minStakeAmount = Number(subscription.billing_thresholds?.stake_gte || 0);
+  const threshold = fromTokenToUnit(Math.max(billingThreshold, minStakeAmount), paymentCurrency.decimal);
+  const staking = getSubscriptionStakeSetup(items, paymentCurrency.id, threshold.toString());
+  const amount = staking.licensed.add(staking.metered).toString();
+  return amount;
+}
+
 export async function getStakeTxClaim({
   userDid,
   userPk,
@@ -1135,6 +1145,50 @@ export async function ensureChangePaymentContext(subscriptionId: string) {
   };
 }
 
+export async function ensureReStakeContext(subscriptionId: string) {
+  const subscription = await Subscription.findByPk(subscriptionId);
+  if (!subscription) {
+    throw new Error(`Subscription not found: ${subscriptionId}`);
+  }
+  if (subscription.status === 'canceled') {
+    throw new Error(`Subscription ${subscriptionId} not recoverable from cancellation`);
+  }
+  if (!subscription.cancel_at_period_end) {
+    throw new Error(`Subscription ${subscriptionId} not recoverable from cancellation config`);
+  }
+  if (subscription.cancelation_details?.reason === 'payment_failed') {
+    throw new Error(`Subscription ${subscriptionId} not recoverable from payment failed`);
+  }
+
+  const paymentCurrency = await PaymentCurrency.findByPk(subscription.currency_id);
+  if (!paymentCurrency) {
+    throw new Error(`PaymentCurrency ${subscription.currency_id} not found for subscription ${subscriptionId}`);
+  }
+  const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+  if (!paymentMethod) {
+    throw new Error(`Payment method not found for subscription ${subscriptionId}`);
+  }
+
+  if (paymentMethod.type !== 'arcblock') {
+    throw new Error(`Payment method ${paymentMethod.type} not supported for subscription ${subscriptionId}`);
+  }
+
+  const customer = await Customer.findByPk(subscription.customer_id);
+  if (!customer) {
+    throw new Error(`Customer not found for subscription ${subscriptionId}`);
+  }
+
+  // @ts-ignore
+  subscription.items = await expandSubscriptionItems(subscription.id);
+
+  return {
+    subscription,
+    paymentCurrency,
+    paymentMethod,
+    customer,
+    payerAddress: getSubscriptionPaymentAddress(subscription, paymentMethod?.type),
+  };
+}
 export async function ensureSubscriptionForCollectBatch(
   subscriptionId?: string, 
   currencyId?: string,
@@ -1370,3 +1424,28 @@ export async function updateStripeSubscriptionAfterChangePayment(setupIntent: Se
   }
 }
 
+export async function returnStakeForCanceledSubscription(subscriptionId: string) {
+  if (!subscriptionId) {
+    return;
+  }
+  try {
+    const subscription = await Subscription.findByPk(subscriptionId);
+    if (!subscription) {
+      throw new Error(`Subscription ${subscriptionId} not found`);
+    }
+    if (subscription.status !== 'canceled') {
+      throw new Error(`Subscription ${subscriptionId} is not canceled`);
+    }
+  
+    if (!subscription.payment_details?.arcblock?.staking?.tx_hash) {
+      throw new Error(`No staking transaction found in subscription ${subscriptionId}`);
+    }
+    returnStakeQueue.push({ id: `return-stake-${subscription.id}`, job: { subscriptionId: subscription.id } });
+    logger.info('Subscription return stake job scheduled', {
+      jobId: `return-stake-${subscription.id}`,
+      subscription: subscription.id,
+    });
+  } catch (err) {
+    logger.error('returnStakeForCanceledSubscription failed', { error: err, subscriptionId });
+  }
+}

package/api/src/routes/subscriptions.ts

@@ -17,6 +17,7 @@ import { isDelegationSufficientForPayment } from '../libs/payment';
 import { authenticate } from '../libs/security';
 import { expandLineItems, getFastCheckoutAmount, getSubscriptionCreateSetup, isLineItemAligned } from '../libs/session';
 import {
+  checkRemainingStake,
   createProration,
   finalizeSubscriptionUpdate,
   getPastInvoicesAmount,
@@ -33,6 +34,7 @@ import { invoiceQueue } from '../queues/invoice';
 import {
   addSubscriptionJob,
   returnOverdraftProtectionQueue,
+  returnStakeQueue,
   slashOverdraftProtectionQueue,
   slashStakeQueue,
   subscriptionQueue,
@@ -426,6 +428,42 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
   return res.json(subscription);
 });
 
+router.get('/:id/recover-info', authPortal, async (req, res) => {
+  const doc = await Subscription.findByPk(req.params.id);
+
+  if (!doc) {
+    return res.status(404).json({ error: 'Subscription not found' });
+  }
+
+  const paymentMethod = await PaymentMethod.findByPk(doc.default_payment_method_id);
+  const paymentCurrency = await PaymentCurrency.findByPk(doc.currency_id);
+
+  let needStake = false;
+  let revokedStake = '0';
+
+  if (paymentMethod?.type === 'arcblock' && paymentCurrency) {
+    const address = doc.payment_details?.arcblock?.staking?.address;
+    if (address) {
+      try {
+        const { revoked } = await checkRemainingStake(paymentMethod, paymentCurrency, address, '0');
+        const cancelReason = doc.cancelation_details?.reason;
+        if (revoked && revoked !== '0' && cancelReason === 'stake_revoked') {
+          needStake = true;
+          revokedStake = revoked;
+        }
+      } catch (err) {
+        console.error(`Failed to check remaining stake for subscription ${doc.id}`, { error: err });
+      }
+    }
+  }
+
+  return res.json({
+    subscription: doc,
+    needStake,
+    revokedStake,
+  });
+});
+
 router.put('/:id/recover', authPortal, async (req, res) => {
   const doc = await Subscription.findByPk(req.params.id);
 
@@ -442,13 +480,43 @@ router.put('/:id/recover', authPortal, async (req, res) => {
     return res.status(400).json({ error: 'Subscription not recoverable from cancellation' });
   }
 
+  const paymentMethod = await PaymentMethod.findByPk(doc.default_payment_method_id);
+  if (!paymentMethod) {
+    return res.status(400).json({ error: 'Payment method not found' });
+  }
+  const paymentCurrency = await PaymentCurrency.findByPk(doc.currency_id);
+  if (!paymentCurrency) {
+    return res.status(400).json({ error: 'Payment currency not found' });
+  }
+
+  // check if need stake
+  if (paymentMethod.type === 'arcblock') {
+    const address = doc.payment_details?.arcblock?.staking?.address;
+    if (address) {
+      try {
+        const { revoked } = await checkRemainingStake(paymentMethod, paymentCurrency, address, '0');
+        const cancelReason = doc.cancelation_details?.reason;
+        if (revoked && revoked !== '0' && cancelReason === 'stake_revoked') {
+          return res.json({
+            needStake: true,
+            subscription: doc,
+            revoked,
+          });
+        }
+      } catch (err) {
+        logger.error('subscription recover failed to check remaining stake', { error: err });
+      }
+    }
+  }
+
   if (doc.cancel_at_period_end) {
     await updateStripeSubscription(doc, { cancel_at_period_end: false });
   } else {
     await updateStripeSubscription(doc, { cancel_at: null });
   }
 
-  await doc.update({ cancel_at_period_end: false, cancel_at: 0, canceled_at: 0 });
+  // @ts-ignore
+  await doc.update({ cancel_at_period_end: false, cancel_at: 0, canceled_at: 0, cancelation_details: null });
   await new SubscriptionWillCanceledSchedule().deleteScheduleSubscriptionJobs([doc]);
   // reschedule jobs
   subscriptionQueue
@@ -457,7 +525,7 @@ router.put('/:id/recover', authPortal, async (req, res) => {
     .catch((err) => logger.error('subscription cancel job failed to cancel', { error: err }));
   await addSubscriptionJob(doc, 'cycle');
 
-  return res.json(doc);
+  return res.json({ subscription: doc });
 });
 
 router.put('/:id/pause', auth, async (req, res) => {
@@ -520,6 +588,26 @@ router.put('/:id/resume', auth, async (req, res) => {
   return res.json(doc);
 });
 
+router.put('/:id/return-stake', authPortal, async (req, res) => {
+  const doc = await Subscription.findByPk(req.params.id);
+  if (!doc) {
+    return res.status(404).json({ error: 'Subscription not found' });
+  }
+  if (doc.status !== 'canceled') {
+    return res.status(400).json({ error: 'Subscription is not canceled' });
+  }
+
+  if (!doc.payment_details?.arcblock?.staking?.tx_hash) {
+    return res.status(400).json({ error: 'No staking transaction found in subscription' });
+  }
+  returnStakeQueue.push({ id: `return-stake-${doc.id}`, job: { subscriptionId: doc.id } });
+  logger.info('Subscription return stake job scheduled', {
+    jobId: `return-stake-${doc.id}`,
+    subscription: doc.id,
+  });
+  return res.json({ success: true, subscriptionId: doc.id });
+});
+
 const isValidSubscriptionItemChange = (item: SubscriptionUpdateItem) => {
   if (item.deleted) {
     if (!item.id) {

package/api/tests/libs/pagination.spec.ts

@@ -300,6 +300,33 @@ describe('mergePaginate', () => {
       expect(result.data.map((item) => item.id)).toEqual(['id_4', 'id_2', 'id_3', 'id_1']);
     });
 
+    it('should handle 29 records with last page showing correct 9 items', async () => {
+      const baseDate = new Date('2024-01-01T00:00:00Z');
+
+      // Create 3 data sources with uneven distribution: 10, 10, 9 records
+      const source1 = createTestDataSource(createTestItems(10, baseDate));
+      const source2 = createTestDataSource(createTestItems(10, new Date(baseDate.getTime() + 10000)));
+      const source3 = createTestDataSource(createTestItems(9, new Date(baseDate.getTime() + 20000)));
+
+      // Test the last page (page 3, should have 9 items: records 21-29)
+      const result = await mergePaginate(
+        [source1, source2, source3],
+        { page: 3, pageSize: 10 },
+        defaultTimeOrderBy('desc')
+      );
+
+      expect(result.total).toBe(29);
+      expect(result.data).toHaveLength(9); // Should show all 9 remaining items, not just 2
+      expect(result.paging).toEqual({
+        page: 3,
+        pageSize: 10,
+        totalPages: 3,
+      });
+
+      // Verify we got the correct range of items (the oldest ones)
+      expect(result.data.every((item) => item.value < 20)).toBe(true); // These should be the oldest items
+    });
+
     it('should handle multiple data sources with late pages correctly', async () => {
       const baseDate = new Date('2024-01-01T00:00:00Z');
 

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.18.47
+version: 1.18.48
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.18.47",
+  "version": "1.18.48",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -47,17 +47,17 @@
     "@abtnode/cron": "^1.16.43",
     "@arcblock/did": "^1.20.11",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
-    "@arcblock/did-connect": "^2.13.47",
+    "@arcblock/did-connect": "^2.13.54",
     "@arcblock/did-util": "^1.20.11",
     "@arcblock/jwt": "^1.20.11",
-    "@arcblock/ux": "^2.13.47",
+    "@arcblock/ux": "^2.13.54",
     "@arcblock/validator": "^1.20.11",
     "@blocklet/did-space-js": "^1.0.56",
     "@blocklet/js-sdk": "^1.16.43",
     "@blocklet/logger": "^1.16.43",
-    "@blocklet/payment-react": "1.18.47",
+    "@blocklet/payment-react": "1.18.48",
     "@blocklet/sdk": "^1.16.43",
-    "@blocklet/ui-react": "^2.13.47",
+    "@blocklet/ui-react": "^2.13.54",
     "@blocklet/uploader": "^0.1.93",
     "@blocklet/xss": "^0.1.36",
     "@mui/icons-material": "^5.16.6",
@@ -123,7 +123,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.43",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.18.47",
+    "@blocklet/payment-types": "1.18.48",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -169,5 +169,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "e781286c5a20e54ef0eb7e029505f32c00cb33e2"
+  "gitHead": "4042dc2996b11ab6ccf6a973af53042cff913474"
 }

package/scripts/sdk.js

@@ -539,6 +539,13 @@ const subscriptionModule = {
     console.log('createBatchUsageRecords', results);
     return results;
   },
+
+  // 返回质押
+  async returnStake() {
+    const result = await payment.subscriptions.returnStake('sub_pWYXj2fale49qeFfEpunTmZq');
+    console.log('returnStake', result);
+    return result;
+  },
 };
 
 const testModules = {

package/src/components/subscription/portal/actions.tsx

@@ -5,12 +5,12 @@ import {
   ConfirmDialog,
   api,
   formatError,
-  formatToDate,
   getPrefix,
   getSubscriptionAction,
   usePaymentContext,
   OverdueInvoicePayment,
   formatBNStr,
+  ResumeSubscription,
 } from '@blocklet/payment-react';
 import type { TSubscriptionExpanded } from '@blocklet/payment-types';
 import { Button, Link, Stack, Tooltip, Typography, Box, Alert } from '@mui/material';
@@ -27,7 +27,7 @@ import CustomerCancelForm from './cancel';
 import OverdraftProtectionDialog from '../../customer/overdraft-protection';
 import Actions from '../../actions';
 import { useUnpaidInvoicesCheckForSubscription } from '../../../hooks/subscription';
-import { isWillCanceled } from '../../../libs/util';
+import { isActive, isWillCanceled } from '../../../libs/util';
 
 interface ActionConfig {
   key: string;
@@ -105,34 +105,26 @@ SubscriptionActions.defaultProps = {
   forceShowDetailAction: false,
   buttonSize: 'small',
 };
-const fetchExtraActions = async ({
-  id,
-  showExtra,
-}: {
-  id: string;
-  showExtra: boolean;
-}): Promise<{ changePlan: boolean; batchPay: string }> => {
-  if (!showExtra) {
-    return Promise.resolve({ changePlan: false, batchPay: '' });
-  }
 
-  const [changePlan, batchPay] = await Promise.all([
-    api
-      .get(`/api/subscriptions/${id}/change-plan`)
-      .then((res) => !!res.data)
-      .catch(() => false),
-    api
-      .get(`/api/subscriptions/${id}/summary`)
-      .then((res) => {
-        if (!isEmpty(res.data) && Object.keys(res.data).length === 1) {
-          return Object.keys(res.data)[0] as string;
-        }
-        return '';
-      })
-      .catch(() => ''),
-  ]);
+const fetchChangePlan = async (id: string): Promise<boolean> => {
+  try {
+    const res = await api.get(`/api/subscriptions/${id}/change-plan`);
+    return !!res.data;
+  } catch {
+    return false;
+  }
+};
 
-  return { changePlan, batchPay };
+const fetchBatchPay = async (id: string): Promise<string> => {
+  try {
+    const res = await api.get(`/api/subscriptions/${id}/summary`);
+    if (!isEmpty(res.data) && Object.keys(res.data).length === 1) {
+      return Object.keys(res.data)[0] as string;
+    }
+    return '';
+  } catch {
+    return '';
+  }
 };
 
 const supportRecharge = (subscription: TSubscriptionExpanded) => {
@@ -177,7 +169,13 @@ export function SubscriptionActionsInner({
     return true;
   };
 
-  const { data: extraActions } = useRequest(() => fetchExtraActions({ id: subscription.id, showExtra: !!showExtra }));
+  const { data: changePlanAvailable = false } = useRequest(() => fetchChangePlan(subscription.id), {
+    ready: !!showExtra && isActive(subscription),
+  });
+
+  const { data: batchPayAvailable = '' } = useRequest(() => fetchBatchPay(subscription.id), {
+    ready: !!showExtra,
+  });
 
   const { data: upcoming = {} } = useRequest(
     () => api.get(`/api/subscriptions/${subscription.id}/upcoming`).then((res) => res.data),
@@ -269,21 +267,6 @@ export function SubscriptionActionsInner({
     }
   };
 
-  const handleRecover = async () => {
-    try {
-      setState({ loading: true });
-      const sub = await api.put(`/api/subscriptions/${state.subscription}/recover`).then((res) => res.data);
-      setSubscription(sub);
-      Toast.success(t('common.saved'));
-      if (onChange) onChange(state.action);
-    } catch (err) {
-      console.error(err);
-      Toast.error(formatError(err));
-    } finally {
-      setState({ loading: false, action: '', subscription: '' });
-    }
-  };
-
   const handleDelegate = () => {
     connect.open({
       containerEl: undefined as unknown as Element,
@@ -503,7 +486,7 @@ export function SubscriptionActionsInner({
       },
       {
         key: 'changePlan',
-        show: !!extraActions?.changePlan,
+        show: changePlanAvailable,
         label: action?.text || t('payment.customer.changePlan.button'),
         onClick: (e) => {
           e?.stopPropagation();
@@ -515,7 +498,7 @@ export function SubscriptionActionsInner({
       },
       {
         key: 'batchPay',
-        show: !!extraActions?.batchPay,
+        show: !!batchPayAvailable,
         label: action?.text || t('admin.subscription.batchPay.button'),
         onClick: (e) => {
           e?.stopPropagation();
@@ -530,7 +513,7 @@ export function SubscriptionActionsInner({
       },
       {
         key: 'mainAction',
-        show: !!(!extraActions?.batchPay && supportAction),
+        show: !!(!batchPayAvailable && supportAction),
         label: action?.text || t(`payment.customer.${action?.action}.button`),
         onClick: (e) => {
           e?.stopPropagation();
@@ -660,18 +643,17 @@ export function SubscriptionActionsInner({
         />
       )}
       {state.action === 'recover' && state.subscription && (
-        <ConfirmDialog
-          onConfirm={handleRecover}
-          onCancel={(e) => {
-            e.stopPropagation();
+        <ResumeSubscription
+          subscriptionId={state.subscription}
+          onResumed={(updatedSubscription) => {
             setState({ action: '', subscription: '' });
+            onChange?.(state.action);
+            setSubscription(updatedSubscription as TSubscriptionExpanded);
+          }}
+          dialogProps={{
+            open: true,
+            onClose: () => setState({ action: '', subscription: '' }),
           }}
-          title={t('payment.customer.recover.title')}
-          message={t('payment.customer.recover.description', {
-            date: formatToDate(subscription.current_period_end * 1000),
-          })}
-          loading={state.loading}
-          color="primary"
         />
       )}
 

package/src/libs/util.ts

@@ -348,6 +348,9 @@ export function getAppInfo(address: string): { name: string; avatar: string; typ
   return null;
 }
 
+export function isActive(subscription: TSubscriptionExpanded) {
+  return ['active', 'trialing'].includes(subscription.status);
+}
 export function isWillCanceled(subscription: TSubscriptionExpanded) {
   const now = Date.now() / 1000;
   if (