payment-kit 1.13.284 → 1.13.286

package/.eslintrc.js

@@ -13,5 +13,6 @@ module.exports = {
     'import/prefer-default-export': 'off',
     'react-hooks/exhaustive-deps': 'off',
     'jsx-a11y/no-noninteractive-element-interactions': 'off',
+    '@typescript-eslint/indent': 'off',
   },
 };

package/api/src/integrations/arcblock/stake.ts

@@ -143,10 +143,7 @@ export async function checkStakeRevokeTx() {
           return;
         }
 
-        const address = toStakeAddress(customer.did, wallet.address);
-        if (t.tx.itxJson.address !== address) {
-          return;
-        }
+        const { address } = t.tx.itxJson;
 
         // Check related subscriptions in the stake
         const subscriptions = await Subscription.findAll({
@@ -163,13 +160,21 @@ export async function checkStakeRevokeTx() {
         });
 
         const { state: stake } = await client.getStakeState({ address });
-        const data = JSON.parse(stake.data?.value || '{}');
-        subscriptions
-          .filter((s) => s.isActive())
-          .filter((s) => data[s.id])
-          .forEach((s) => {
-            events.emit('customer.stake.revoked', { subscriptionId: s.id, tx: t });
-          });
+        if (stake.nonce) {
+          subscriptions
+            .filter((s) => s.isActive())
+            .forEach((s) => {
+              events.emit('customer.stake.revoked', { subscriptionId: s.id, tx: t });
+            });
+        } else {
+          const data = JSON.parse(stake.data?.value || '{}');
+          subscriptions
+            .filter((s) => s.isActive())
+            .filter((s) => data[s.id])
+            .forEach((s) => {
+              events.emit('customer.stake.revoked', { subscriptionId: s.id, tx: t });
+            });
+        }
       })
     );
   }

package/api/src/libs/subscription.ts

@@ -15,6 +15,7 @@ import {
   PaymentMethod,
   Price,
   PriceRecurring,
+  Refund,
   Subscription,
   SubscriptionItem,
   SubscriptionUpdateItem,
@@ -632,3 +633,75 @@ export async function onSubscriptionUpdateConnected(subscriptionId: string) {
     });
   }
 }
+
+export async function getRemainingStakes(subscriptionIds: string[], subscriptionInitStakes: { [key: string]: string }) {
+  if (!subscriptionIds || subscriptionIds.length === 0) {
+    return '0';
+  }
+  let total = new BN('0');
+  await Promise.all(
+    subscriptionIds.map(async (subscriptionId) => {
+      const refund = await Refund.findOne({
+        where: { subscription_id: subscriptionId, status: 'succeeded', type: 'stake_return' },
+      });
+      if (!refund) {
+        // this subscription not return stake
+        total = total.add(new BN(subscriptionInitStakes[subscriptionId] || '0'));
+      }
+    })
+  );
+  return total.toString();
+}
+
+export async function getSubscriptionStakeReturnSetup(
+  subscription: Subscription,
+  address: string,
+  paymentMethod: PaymentMethod
+) {
+  const client = paymentMethod.getOcapClient();
+  const { state } = await client.getStakeState({ address });
+  const currency = await PaymentCurrency.findByPk(subscription.currency_id);
+  if (!state.tokens || !currency) {
+    return {
+      total: '0',
+      return_amount: '0',
+      sender: '',
+    };
+  }
+  const total = new BN(state.tokens.find((x: any) => x.address === currency.contract)?.value || '0');
+  const [summary] = await Invoice.getUncollectibleAmount({
+    subscriptionId: subscription.id,
+    currencyId: subscription.currency_id,
+    customerId: subscription.customer_id,
+  });
+  const subscriptionInitStakes = JSON.parse(state.data?.value || '{}');
+  const initStake = subscriptionInitStakes[subscription.id];
+  const uncollectibleAmountBN = new BN(summary?.[subscription.currency_id] || '0');
+  const lastInvoice = await Invoice.findByPk(subscription.latest_invoice_id);
+  if (state.nonce) {
+    const returnStake = total.sub(uncollectibleAmountBN);
+    return {
+      total: total.toString(),
+      return_amount: returnStake.lt(new BN(0)) ? '0' : returnStake.toString(),
+      sender: state.sender,
+      lastInvoice,
+    };
+  }
+  const getReturnState = async () => {
+    const initStakeBN = new BN(initStake);
+    const otherSubscriptionIds = Object.keys(subscriptionInitStakes).filter(
+      (k) => k !== 'appId' && k !== subscription.id
+    );
+    const remainingStakes = await getRemainingStakes(otherSubscriptionIds, subscriptionInitStakes);
+    const actualStakeBN = new BN(total).sub(new BN(remainingStakes));
+    const minStakeBN = initStakeBN.lt(actualStakeBN) ? initStakeBN : actualStakeBN;
+    return minStakeBN.sub(uncollectibleAmountBN);
+  };
+  const returnStake = await getReturnState();
+  return {
+    total: initStake,
+    return_amount: returnStake.lt(new BN(0)) ? '0' : returnStake.toString(),
+    sender: state.sender,
+    lastInvoice,
+  };
+}

package/api/src/queues/refund.ts

@@ -1,3 +1,5 @@
+import { toStakeAddress } from '@arcblock/did-util';
+
 import { sendErc20ToUser } from '../integrations/ethereum/token';
 import { wallet } from '../libs/auth';
 import CustomError from '../libs/error';
@@ -93,11 +95,6 @@ export const handleRefund = async (job: RefundJob) => {
     logger.warn(`PaymentMethod not found: ${paymentCurrency.payment_method_id}`);
     return;
   }
-  const supportAutoCharge = await PaymentMethod.supportAutoCharge(paymentCurrency.payment_method_id);
-  if (supportAutoCharge === false) {
-    logger.warn(`PaymentMethod does not support auto charge: ${paymentCurrency.payment_method_id}`);
-    return;
-  }
 
   const customer = await Customer.findByPk(refund.customer_id);
   if (!customer) {
@@ -105,6 +102,26 @@ export const handleRefund = async (job: RefundJob) => {
     return;
   }
 
+  if (refund?.type === 'stake_return') {
+    handleStakeReturnJob(job, refund, paymentCurrency, paymentMethod, customer);
+  } else if (paymentMethod) {
+    handleRefundJob(job, refund, paymentCurrency, paymentMethod, customer);
+  }
+};
+
+const handleRefundJob = async (
+  job: RefundJob,
+  refund: Refund,
+  paymentCurrency: PaymentCurrency,
+  paymentMethod: PaymentMethod,
+  customer: Customer
+) => {
+  const supportAutoCharge = await PaymentMethod.supportAutoCharge(paymentCurrency.payment_method_id);
+  if (supportAutoCharge === false) {
+    logger.warn(`PaymentMethod does not support auto charge: ${paymentCurrency.payment_method_id}`);
+    return;
+  }
+
   // try refund transfer and reschedule on error
   logger.info('Refund transfer attempt', { id: refund.id, attempt: refund.attempt_count });
   let result;
@@ -223,6 +240,94 @@ export const handleRefund = async (job: RefundJob) => {
   }
 };
 
+const handleStakeReturnJob = async (
+  job: RefundJob,
+  refund: Refund,
+  paymentCurrency: PaymentCurrency,
+  paymentMethod: PaymentMethod,
+  customer: Customer
+) => {
+  // try stake return and reschedule on error
+  logger.info('Stake return attempt', { id: refund.id, attempt: refund.attempt_count });
+  try {
+    if (paymentMethod.type === 'arcblock') {
+      const arcblockDetail = refund.payment_details?.arcblock;
+      if (!arcblockDetail) {
+        throw new Error('arcblockDetail info not found');
+      }
+      const client = paymentMethod.getOcapClient();
+      const signed = await client.signSlashStakeTx({
+        tx: {
+          itx: {
+            address: toStakeAddress(customer.did, wallet.address),
+            outputs: [
+              {
+                owner: arcblockDetail?.receiver,
+                tokens: [{ address: paymentCurrency.contract, value: refund.amount }],
+              },
+            ],
+            message: 'stake_return_on_subscription_cancel',
+            data: {
+              typeUrl: 'json',
+              // @ts-ignore
+              value: {
+                appId: wallet.address,
+                reason: 'subscription_cancel',
+                subscriptionId: refund.subscription_id,
+              },
+            },
+          },
+        },
+        wallet,
+      });
+      // @ts-ignore
+      const { buffer } = await client.encodeSlashStakeTx({ tx: signed });
+      // @ts-ignore
+      const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, getGasPayerExtra(buffer));
+      logger.info('stake return done', { id: refund.id, txHash });
+      await refund.update({
+        status: 'succeeded',
+        last_attempt_error: null,
+        payment_details: {
+          arcblock: {
+            tx_hash: txHash,
+            payer: wallet.address,
+            type: 'stake_return',
+            receiver: arcblockDetail?.receiver,
+          },
+        },
+      });
+    }
+  } catch (err: any) {
+    logger.error('stake return failed', { error: err, id: refund.id });
+
+    const error: PaymentError = {
+      type: 'card_error',
+      code: err.code,
+      message: err.message,
+      payment_method_id: paymentMethod.id,
+      payment_method_type: paymentMethod.type,
+    };
+
+    const updates = await handleRefundFailed(refund, error);
+    await refund.update(updates.refund);
+
+    // reschedule next attempt
+    const retryAt = updates.refund.next_attempt;
+    if (retryAt) {
+      refundQueue.push({
+        id: refund.id,
+        job: { refundId: refund.id, retryOnError: job.retryOnError },
+        runAt: retryAt,
+      });
+      logger.error('stake return retry scheduled', { id: refund.id, retryAt });
+    } else {
+      logger.info('stake job deleted since no retry', { id: refund.id });
+      refundQueue.delete(refund.id);
+    }
+  }
+};
+
 export const refundQueue = createQueue<RefundJob>({
   name: 'refund',
   onJob: handleRefund,

package/api/src/routes/connect/change-payment.ts

@@ -105,9 +105,8 @@ export default {
 
   onAuth: async ({ request, userDid, userPk, claims, extraParams }: CallbackArgs) => {
     const { subscriptionId } = extraParams;
-    const { subscription, setupIntent, paymentCurrency, paymentMethod } = await ensureChangePaymentContext(
-      subscriptionId
-    );
+    const { subscription, setupIntent, paymentCurrency, paymentMethod } =
+      await ensureChangePaymentContext(subscriptionId);
 
     const prepareTxExecution = async () => {
       await subscription?.update({
@@ -141,7 +140,14 @@ export default {
 
     if (paymentMethod.type === 'arcblock') {
       await prepareTxExecution();
-      const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod, request);
+      const paymentDetails = await executeOcapTransactions(
+        userDid,
+        userPk,
+        claims,
+        paymentMethod,
+        request,
+        subscription?.id
+      );
       await afterTxExecution(paymentDetails);
       return { hash: paymentDetails.tx_hash };
     }

package/api/src/routes/connect/change-plan.ts

@@ -141,7 +141,14 @@ export default {
     if (paymentMethod.type === 'arcblock') {
       await prepareTxExecution();
 
-      const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod, request);
+      const paymentDetails = await executeOcapTransactions(
+        userDid,
+        userPk,
+        claims,
+        paymentMethod,
+        request,
+        subscription?.id
+      );
       await afterTxExecution(paymentDetails);
 
       return { hash: paymentDetails.tx_hash };

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

@@ -168,7 +168,14 @@ export default {
       try {
         await prepareTxExecution();
 
-        const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod, request);
+        const paymentDetails = await executeOcapTransactions(
+          userDid,
+          userPk,
+          claims,
+          paymentMethod,
+          request,
+          subscription?.id
+        );
         await afterTxExecution(paymentDetails);
 
         return { hash: paymentDetails.tx_hash };

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

@@ -387,7 +387,7 @@ export async function ensureInvoiceAndItems({
   subscription?: Subscription;
   props: TInvoice;
   lineItems: TLineItemExpanded[];
-    trialing: boolean; // do we have trialing
+  trialing: boolean; // do we have trialing
   metered: boolean; // is the quantity metered
   applyCredit?: boolean; // should we apply customer credit?
 }): Promise<{ invoice: Invoice; items: InvoiceItem[] }> {
@@ -637,13 +637,13 @@ export async function getDelegationTxClaim({
   userDid: string;
   userPk: string;
   nonce: string;
-    mode: string;
+  mode: string;
   data: any;
   items: TLineItemExpanded[];
   paymentCurrency: PaymentCurrency;
   paymentMethod: PaymentMethod;
-    trialing: boolean;
-    billingThreshold?: number;
+  trialing: boolean;
+  billingThreshold?: number;
 }) {
   const amount = getFastCheckoutAmount(items, mode, paymentCurrency.id);
   const address = toDelegateAddress(userDid, wallet.address);
@@ -739,16 +739,16 @@ export async function getStakeTxClaim({
   if (paymentMethod.type === 'arcblock') {
     // create staking data
     const client = paymentMethod.getOcapClient();
-    const address = toStakeAddress(userDid, wallet.address);
+    const address = toStakeAddress(userDid, wallet.address, subscription.id);
     const { state } = await client.getStakeState({ address });
     const data = {
       type: 'json',
       value: Object.assign(
         {
           appId: wallet.address,
+          subscriptionId: subscription.id,
         },
-        JSON.parse(state?.data?.value || '{}'),
-        { [subscription.id]: amount }
+        JSON.parse(state?.data?.value || '{}')
       ),
     };
 
@@ -766,6 +766,7 @@ export async function getStakeTxClaim({
           slashers: [wallet.address],
           revokeWaitingPeriod: setup.cycle.duration / 1000, // wait for at least 1 billing cycle
           message: `Stake for subscription ${subscription.id}`,
+          nonce: subscription.id,
           inputs: [],
           data,
         },
@@ -976,7 +977,8 @@ export async function executeOcapTransactions(
   userPk: string,
   claims: any[],
   paymentMethod: PaymentMethod,
-  request: Request
+  request: Request,
+  subscriptionId?: string,
 ) {
   const client = paymentMethod.getOcapClient();
   const delegation = claims.find((x) => x.type === 'signature' && x.meta?.purpose === 'delegation');
@@ -1010,13 +1012,15 @@ export async function executeOcapTransactions(
     })
   );
 
+  const nonce = subscriptionId || '';
+
   return {
     tx_hash: delegationTxHash,
     payer: userDid,
     type: 'delegate',
     staking: {
       tx_hash: stakingTxHash,
-      address: toStakeAddress(userDid, wallet.address),
+      address: toStakeAddress(userDid, wallet.address, nonce),
     },
   };
 }

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

@@ -155,7 +155,14 @@ export default {
       await prepareTxExecution();
       const { invoice } = await ensureInvoiceForCheckout({ checkoutSession, customer, subscription });
 
-      const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod, request);
+      const paymentDetails = await executeOcapTransactions(
+        userDid,
+        userPk,
+        claims,
+        paymentMethod,
+        request,
+        subscription?.id
+      );
       await afterTxExecution(invoice!, paymentDetails);
 
       return { hash: paymentDetails.tx_hash };

package/api/src/routes/invoices.ts

@@ -10,6 +10,7 @@ import { createListParamSchema, getWhereFromKvQuery } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { expandLineItems } from '../libs/session';
 import { formatMetadata } from '../libs/util';
+import { Refund } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
 import { InvoiceItem } from '../store/models/invoice-item';
@@ -166,6 +167,46 @@ router.get('/', authMine, async (req, res) => {
                   },
                 },
               });
+              const stakeRecord = await Refund.findOne({
+                where: { subscription_id: subscription.id, status: 'succeeded', type: 'stake_return' },
+              });
+              if (stakeRecord) {
+                list.unshift({
+                  id: address as string,
+                  status: 'paid',
+                  description: 'Return Subscription staking',
+                  billing_reason: 'subscription_create',
+                  total: stakeRecord.amount,
+                  amount_due: '0',
+                  amount_paid: stakeRecord.amount,
+                  amount_remaining: '0',
+                  ...pick(last, [
+                    'number',
+                    'paid',
+                    'auto_advance',
+                    'currency_id',
+                    'customer_id',
+                    'subscription_id',
+                    'period_start',
+                    'period_end',
+                    'created_at',
+                    'updated_at',
+                  ]),
+                  // @ts-ignore
+                  paymentCurrency: await PaymentCurrency.findByPk(last.currency_id),
+                  paymentMethod: method,
+                  // @ts-ignore
+                  customer: await Customer.findByPk(last.customer_id),
+                  metadata: {
+                    payment_details: {
+                      arcblock: {
+                        tx_hash: stakeRecord?.payment_details?.arcblock?.tx_hash,
+                        payer: stakeRecord?.payment_details?.arcblock?.payer,
+                      },
+                    },
+                  },
+                });
+              }
             }
           }
         }

package/api/src/routes/subscriptions.ts

@@ -18,6 +18,7 @@ import {
   finalizeSubscriptionUpdate,
   getSubscriptionCreateSetup,
   getSubscriptionRefundSetup,
+  getSubscriptionStakeReturnSetup,
   getUpcomingInvoiceAmount,
 } from '../libs/subscription';
 import { MAX_SUBSCRIPTION_ITEM_COUNT, formatMetadata } from '../libs/util';
@@ -226,6 +227,7 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
     feedback = 'other',
     comment = '',
     reason = 'payment_disputed',
+    staking = 'none',
   } = req.body;
   if (at === 'custom' && dayjs(time).unix() < dayjs().unix()) {
     return res.status(400).json({ error: 'cancel at must be a future timestamp' });
@@ -306,9 +308,10 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
     const result = await getSubscriptionRefundSetup(subscription, updates.cancel_at);
     if (result.unused !== '0') {
       const item = await Refund.create({
+        type: 'refund',
         livemode: subscription.livemode,
         amount: refund === 'last' ? result.total : result.unused,
-        description: 'subscription_cancel',
+        description: 'refund_transfer_on_subscription_cancel',
         status: 'pending',
         reason: 'requested_by_admin',
         currency_id: subscription.currency_id,
@@ -346,6 +349,66 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
     }
   }
 
+  // trigger stake return
+  if (staking === 'proration') {
+    if (['owner', 'admin'].includes(req.user?.role as string) === false) {
+      return res.status(403).json({ error: 'Not authorized to perform this action' });
+    }
+    const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+    if (paymentMethod?.type !== 'arcblock') {
+      return res
+        .status(400)
+        .json({ error: `Stake return not supported for subscription with payment method ${paymentMethod?.type}` });
+    }
+    const address = subscription?.payment_details?.arcblock?.staking?.address ?? undefined;
+    if (!address) {
+      return res.status(400).json({ error: 'Staking not found on subscription payment detail' });
+    }
+    const result = await getSubscriptionStakeReturnSetup(subscription, address, paymentMethod);
+    if (result.return_amount !== '0') {
+      // do the stake return
+      const item = await Refund.create({
+        type: 'stake_return',
+        livemode: subscription.livemode,
+        amount: result.return_amount,
+        description: 'stake_return_on_subscription_cancel',
+        status: 'pending',
+        reason: 'requested_by_admin',
+        currency_id: subscription.currency_id,
+        customer_id: subscription.customer_id,
+        payment_method_id: subscription.default_payment_method_id,
+        payment_intent_id: result?.lastInvoice?.payment_intent_id as string,
+        subscription_id: subscription.id,
+        attempt_count: 0,
+        attempted: false,
+        next_attempt: 0,
+        last_attempt_error: null,
+        starting_balance: '0',
+        ending_balance: '0',
+        starting_token_balance: {},
+        ending_token_balance: {},
+        payment_details: {
+          // @ts-ignore
+          arcblock: {
+            receiver: result.sender,
+          },
+        },
+      });
+      logger.info('subscription cancel stake return created', {
+        ...req.params,
+        ...req.body,
+        ...pick(result, ['return_amount']),
+        item: item.toJSON(),
+      });
+    } else {
+      logger.info('subscription cancel stake return skipped', {
+        ...req.params,
+        ...req.body,
+        ...pick(result, ['return_amount']),
+      });
+    }
+  }
+
   return res.json(subscription);
 });
 
@@ -1181,6 +1244,38 @@ router.get('/:id/proration', authPortal, async (req, res) => {
   }
 });
 
+// Simulate stake return when subscription is canceled
+router.get('/:id/staking', authPortal, async (req, res) => {
+  try {
+    const subscription = await Subscription.findByPk(req.params.id);
+    if (!subscription) {
+      return res.status(404).json({ error: 'Subscription not found' });
+    }
+    if (subscription.isActive() === false) {
+      return res.status(400).json({ error: 'Subscription is not active' });
+    }
+
+    const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+    if (paymentMethod?.type !== 'arcblock') {
+      return res
+        .status(400)
+        .json({ error: `Stake return not supported for subscription with payment method ${paymentMethod?.type}` });
+    }
+    const address = subscription?.payment_details?.arcblock?.staking?.address ?? undefined;
+    if (!address) {
+      return res.status(400).json({ error: 'Staking not found on subscription payment detail' });
+    }
+    const result = await getSubscriptionStakeReturnSetup(subscription, address, paymentMethod);
+    return res.json({
+      return_amount: result.return_amount,
+      total: result.total,
+    });
+  } catch (err) {
+    console.error(err);
+    return res.status(400).json({ error: err.message });
+  }
+});
+
 // Check payment change status
 router.get('/:id/change-payment', authPortal, async (req, res) => {
   const subscription = await Subscription.findByPk(req.params.id);

package/api/src/store/migrations/20240628-stake-return.ts

@@ -0,0 +1,23 @@
+/* eslint-disable no-await-in-loop */
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    refunds: [
+      {
+        name: 'type',
+        field: {
+          type: DataTypes.ENUM('refund', 'stake_return'),
+          allowNull: true,
+          defaultValue: 'refund',
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('refunds', 'type');
+};

package/api/src/store/models/refund.ts

@@ -62,6 +62,7 @@ export class Refund extends Model<InferAttributes<Refund>, InferCreationAttribut
 
   declare created_at: CreationOptional<Date>;
   declare updated_at: CreationOptional<Date>;
+  declare type: LiteralUnion<'refund' | 'stake_return', string>;
 
   public static readonly GENESIS_ATTRIBUTES = {
     id: {
@@ -182,6 +183,11 @@ export class Refund extends Model<InferAttributes<Refund>, InferCreationAttribut
           type: DataTypes.STRING(30),
           allowNull: true,
         },
+        type: {
+          type: DataTypes.ENUM('refund', 'stake_return'),
+          allowNull: true,
+          defaultValue: 'refund',
+        },
       },
       {
         sequelize,

package/api/src/store/models/types.ts

@@ -266,7 +266,8 @@ export type PaymentDetails = {
   arcblock?: {
     tx_hash: string;
     payer: string;
-    type?: LiteralUnion<'slash' | 'transfer' | 'delegate', string>;
+    type?: LiteralUnion<'slash' | 'transfer' | 'delegate' | 'stake_return', string>;
+    receiver?: string;
     staking?: {
       tx_hash: string;
       address: string;

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.13.284
+version: 1.13.286
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.13.284",
+  "version": "1.13.286",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -52,7 +52,7 @@
     "@arcblock/validator": "^1.18.123",
     "@blocklet/js-sdk": "1.16.28",
     "@blocklet/logger": "1.16.28",
-    "@blocklet/payment-react": "1.13.284",
+    "@blocklet/payment-react": "1.13.286",
     "@blocklet/sdk": "1.16.28",
     "@blocklet/ui-react": "^2.10.1",
     "@blocklet/uploader": "^0.1.11",
@@ -117,8 +117,8 @@
   },
   "devDependencies": {
     "@abtnode/types": "1.16.28",
-    "@arcblock/eslint-config-ts": "^0.3.0",
-    "@blocklet/payment-types": "1.13.284",
+    "@arcblock/eslint-config-ts": "^0.3.2",
+    "@blocklet/payment-types": "1.13.286",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -136,7 +136,7 @@
     "lint-staged": "^12.5.0",
     "nodemon": "^2.0.22",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.8.8",
+    "prettier": "^3.3.2",
     "prettier-plugin-import-sort": "^0.0.7",
     "ts-jest": "^29.1.4",
     "ts-node": "^10.9.2",
@@ -158,5 +158,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "c844c5590104d35d4bffedddec6f909684bacc4b"
+  "gitHead": "fa41b3d6a308d9405f56717beee2f030a91ddec3"
 }

package/src/components/filter-toolbar.tsx

@@ -398,7 +398,9 @@ const Root = styled(Box)`
 
   .status-options {
     position: absolute;
-    box-shadow: 0px 5px 5px -3px rgba(0, 0, 0, 0.2), 0px 8px 10px 1px rgba(0, 0, 0, 0.14),
+    box-shadow:
+      0px 5px 5px -3px rgba(0, 0, 0, 0.2),
+      0px 8px 10px 1px rgba(0, 0, 0, 0.14),
       0px 3px 14px 2px rgba(0, 0, 0, 0.12);
     padding: 0;
     background: #fff;

package/src/components/metadata/editor.tsx

@@ -1,8 +1,10 @@
 import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
 import { Button, CircularProgress, Stack } from '@mui/material';
+import { isObject } from 'lodash';
 import type { EventHandler } from 'react';
 import { FormProvider, useForm } from 'react-hook-form';
 
+import { isObjectContent } from '../../libs/util';
 import MetadataForm from './form';
 
 export default function MetadataEditor({
@@ -20,7 +22,10 @@ export default function MetadataEditor({
   const metadata = data.metadata || {};
   const methods = useForm<any>({
     defaultValues: {
-      metadata: Object.keys(metadata).map((key: string) => ({ key, value: metadata[key] })),
+      metadata: Object.keys(metadata).map((key: string) => ({
+        key,
+        value: isObject(metadata[key]) ? JSON.stringify(metadata[key]) : metadata[key],
+      })),
     },
   });
 
@@ -31,7 +36,16 @@ export default function MetadataEditor({
   };
   const onSubmit = () => {
     handleSubmit(async (formData: any) => {
-      await onSave(formData);
+      const payload = {
+        ...(formData || {}),
+        metadata: Array.isArray(formData.metadata)
+          ? formData.metadata.reduce((acc: any, x: any) => {
+              acc[x.key] = isObjectContent(x.value) ? JSON.parse(x.value) : x.value;
+              return acc;
+            }, {})
+          : [],
+      };
+      await onSave(payload);
       reset();
       onCancel(null);
     })();

package/src/components/metadata/list.tsx

@@ -3,6 +3,7 @@ import { Typography } from '@mui/material';
 import isEmpty from 'lodash/isEmpty';
 import isObject from 'lodash/isObject';
 
+import { isObjectContent } from '../../libs/util';
 import InfoRow from '../info-row';
 
 export default function MetadataList({ data }: { data: any }) {
@@ -12,14 +13,22 @@ export default function MetadataList({ data }: { data: any }) {
     return <Typography color="text.secondary">{t('common.metadata.empty')}</Typography>;
   }
 
+  const formatValue = (value: any) => {
+    if (isObjectContent(value)) {
+      return <pre>{JSON.stringify(JSON.parse(value), null, 2)}</pre>;
+    }
+    if (isObject(value)) {
+      return <pre>{JSON.stringify(value, null, 2)}</pre>;
+    }
+    return value;
+  };
+
   // skip non-string values
   return (
     <>
-      {Object.keys(data || {})
-        .filter((key) => isObject(data[key]) === false)
-        .map((key) => (
-          <InfoRow key={key} label={key} value={data[key]} />
-        ))}
+      {Object.keys(data || {}).map((key) => (
+        <InfoRow key={key} label={key} value={formatValue(data[key])} />
+      ))}
     </>
   );
 }

package/src/components/payment-link/chrome.tsx

@@ -11,5 +11,8 @@ const Root = styled(Box)`
   margin-top: 40px;
   position: relative;
   overflow: hidden;
-  box-shadow: 0 20px 44px #32325d1f, 0 -1px 32px #32325d0f, 0 3px 12px #00000014;
+  box-shadow:
+    0 20px 44px #32325d1f,
+    0 -1px 32px #32325d0f,
+    0 3px 12px #00000014;
 `;

package/src/components/refund/list.tsx

@@ -141,6 +141,22 @@ export default function RefundList({ customer_id, invoice_id, subscription_id, s
         },
       },
     },
+    {
+      label: t('common.type'),
+      name: 'type',
+      width: 60,
+      options: {
+        filter: true,
+        customBodyRenderLite: (_: string, index: number) => {
+          const item = data.list[index] as TRefundExpanded;
+          return (
+            <Link to={`/admin/payments/${item.id}`}>
+              <Status label={t(`refund.type.${item.type}`)} />
+            </Link>
+          );
+        },
+      },
+    },
     {
       label: t('common.description'),
       name: 'description',

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

@@ -1,7 +1,7 @@
 import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
 import { api, formatAmount, formatTime } from '@blocklet/payment-react';
 import type { TSubscriptionExpanded } from '@blocklet/payment-types';
-import { Box, Divider, FormControlLabel, Radio, RadioGroup, Stack, TextField, Typography } from '@mui/material';
+import { Box, Divider, FormControlLabel, Radio, RadioGroup, Stack, TextField, Typography, styled } from '@mui/material';
 import { useRequest } from 'ahooks';
 import { useEffect } from 'react';
 import { Controller, useFormContext, useWatch } from 'react-hook-form';
@@ -10,18 +10,24 @@ const fetchData = (id: string, time: string): Promise<{ total: string; unused: s
   return api.get(`/api/subscriptions/${id}/proration?time=${encodeURIComponent(time)}`).then((res: any) => res.data);
 };
 
+const fetchStakingData = (id: string, time: string): Promise<{ return_amount: string }> => {
+  return api.get(`/api/subscriptions/${id}/staking?time=${encodeURIComponent(time)}`).then((res: any) => res.data);
+};
+
 export default function SubscriptionCancelForm({ data }: { data: TSubscriptionExpanded }) {
   const { t } = useLocaleContext();
   const { control, setValue, formState } = useFormContext();
   const cancelAt = useWatch({ control, name: 'cancel.at' });
   const cancelTime = useWatch({ control, name: 'cancel.time' });
   const refundType = useWatch({ control, name: 'cancel.refund' });
+  const stakingType = useWatch({ control, name: 'cancel.staking' });
   const {
     loading,
     data: refund,
     refresh,
   } = useRequest(() => fetchData(data.id, cancelAt === 'custom' ? cancelTime : ''));
 
+  const { data: staking } = useRequest(() => fetchStakingData(data.id, cancelAt === 'custom' ? cancelTime : ''));
   useEffect(() => {
     if (data) {
       refresh();
@@ -35,9 +41,9 @@ export default function SubscriptionCancelForm({ data }: { data: TSubscriptionEx
   const { decimal, symbol } = data.paymentCurrency;
 
   return (
-    <Box sx={{ width: 400 }}>
+    <Root sx={{ width: 400 }}>
       <Stack direction="row" spacing={3} alignItems="flex-start">
-        <Typography>{t('admin.subscription.cancel.at.title')}</Typography>
+        <Typography className="form-title">{t('admin.subscription.cancel.at.title')}</Typography>
         <Stack>
           <RadioGroup>
             <FormControlLabel
@@ -84,7 +90,7 @@ export default function SubscriptionCancelForm({ data }: { data: TSubscriptionEx
       </Stack>
       <Divider sx={{ my: 1 }} />
       <Stack direction="row" spacing={3} alignItems="flex-start">
-        <Typography>{t('admin.subscription.cancel.refund.title')}</Typography>
+        <Typography className="form-title">{t('admin.subscription.cancel.refund.title')}</Typography>
         <Stack>
           <RadioGroup>
             <FormControlLabel
@@ -118,6 +124,39 @@ export default function SubscriptionCancelForm({ data }: { data: TSubscriptionEx
           </RadioGroup>
         </Stack>
       </Stack>
-    </Box>
+      {data.paymentMethod.type === 'arcblock' && (
+        <>
+          <Divider sx={{ my: 1 }} />
+          <Stack direction="row" spacing={3} alignItems="flex-start">
+            <Typography className="form-title">{t('admin.subscription.cancel.staking.title')}</Typography>
+            <RadioGroup>
+              <FormControlLabel
+                value="none"
+                disabled={loading || !staking}
+                onClick={() => setValue('cancel.staking', 'none')}
+                control={<Radio checked={stakingType === 'none'} />}
+                label={t('admin.subscription.cancel.staking.none')}
+              />
+              <FormControlLabel
+                value="proration"
+                disabled={loading || !staking}
+                onClick={() => setValue('cancel.staking', 'proration')}
+                control={<Radio checked={stakingType === 'proration'} />}
+                label={t('admin.subscription.cancel.staking.proration', {
+                  unused: formatAmount(staking?.return_amount || '0', decimal),
+                  symbol,
+                })}
+              />
+            </RadioGroup>
+          </Stack>
+        </>
+      )}
+    </Root>
   );
 }
+
+const Root = styled(Box)`
+  .form-title {
+    width: 60px;
+  }
+`;

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

@@ -150,6 +150,7 @@ export default function SubscriptionActions(props: Props) {
         at: 'now',
         time: '',
         refund: 'none',
+        staking: 'none',
       },
       pause: {
         type: 'never',

package/src/libs/util.ts

@@ -14,6 +14,7 @@ import type {
 } from '@blocklet/payment-types';
 import { Hasher } from '@ocap/mcrypto';
 import { hexToNumber } from '@ocap/util';
+import { isObject } from 'lodash';
 import cloneDeep from 'lodash/cloneDeep';
 import isEqual from 'lodash/isEqual';
 import { joinURL } from 'ufo';
@@ -224,3 +225,11 @@ export function goBackOrFallback(fallback: string) {
     }
   }, 500);
 }
+
+export function isObjectContent(value: string) {
+  try {
+    return isObject(JSON.parse(value));
+  } catch (err) {
+    return false;
+  }
+}

package/src/locales/en.tsx

@@ -409,6 +409,11 @@ export default flat({
           last: 'Last payment {total}{symbol}',
           proration: 'Proration amount {unused}/{total}{symbol}',
         },
+        staking: {
+          title: 'Stake',
+          none: 'No return',
+          proration: 'Return Remaining Stake {unused}{symbol}',
+        },
       },
       pause: {
         title: 'Pause payment collection',

package/src/locales/zh.tsx

@@ -400,6 +400,11 @@ export default flat({
           last: '退款最近付款的全部 {total}{symbol}',
           proration: '退款最近付款的未使用部分 {unused}/{total}{symbol}',
         },
+        staking: {
+          title: '质押',
+          none: '不退还质押',
+          proration: '退还剩余部分 {unused}{symbol}',
+        },
       },
       pause: {
         title: '暂停付款',

package/src/pages/admin/payments/refunds/detail.tsx

@@ -135,6 +135,7 @@ export default function RefundDetail(props: { id: string }) {
               </Stack>
             }
           />
+          <InfoRow label={t('common.type')} value={t(`refund.type.${data.type}`)} />
           <InfoRow label={t('common.description')} value={data.description} />
           <InfoRow label={t('common.createdAt')} value={formatTime(data.created_at)} />
           <InfoRow label={t('common.updatedAt')} value={formatTime(data.updated_at)} />