payment-kit 1.18.54 → 1.18.55

package/api/src/libs/queue/index.ts

@@ -8,6 +8,7 @@ import { nanoid } from 'nanoid';
 import { AsyncLocalStorage } from 'async_hooks';
 import logger from '../logger';
 import { sleep, tryWithTimeout } from '../util';
+import dayjs from '../dayjs';
 import createQueueStore from './store';
 import { Job } from '../../store/models/job';
 import { sequelize } from '../../store/sequelize';
@@ -112,6 +113,7 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
       queueEvents.emit(e, data);
       jobEvents.emit(e, data);
     };
+    const now = dayjs().unix();
 
     if (!job) {
       throw new Error('Can not queue empty job');
@@ -134,7 +136,8 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
         attrs.delay = delay;
         attrs.will_run_at = Date.now() + delay * 1000;
       }
-      if (runAt) {
+      if (runAt && runAt > now) {
+        // 如果 runAt 大于当前时间，则延迟执行，否则直接执行
         attrs.delay = 1;
         attrs.will_run_at = runAt * 1000;
       }

package/api/src/queues/payment.ts

@@ -42,6 +42,7 @@ import createQueue from '../libs/queue';
 import { CHARGE_SUPPORTED_CHAIN_TYPES, EVM_CHAIN_TYPES } from '../libs/constants';
 import { getCheckoutSessionSubscriptionIds, getSubscriptionCreateSetup } from '../libs/session';
 import { syncStripeSubscriptionAfterRecovery } from '../integrations/stripe/handlers/subscription';
+import { getLock } from '../libs/lock';
 
 type PaymentJob = {
   paymentIntentId: string;
@@ -798,11 +799,26 @@ export const handlePayment = async (job: PaymentJob) => {
   // try payment capture and reschedule on error
   logger.info('PaymentIntent capture attempt', { id: paymentIntent.id, attempt: invoice?.attempt_count });
   let result;
+
+  // Use lock to prevent race condition with subscription queue
+  const lock = getLock(`payment-${paymentIntent.id}`);
+
   try {
-    await paymentIntent.update({ status: 'processing', last_payment_error: null });
-    logger.info('PaymentIntent status updated to processing', {
-      paymentIntentId: paymentIntent.id,
+    await lock.acquire();
+    logger.debug('Acquired lock for payment processing', {
+      paymentIntent: paymentIntent.id,
+      invoice: invoice?.id,
     });
+
+    // Re-check payment intent status after acquiring lock
+    await paymentIntent.reload();
+    if (paymentIntent.status === 'succeeded') {
+      logger.info('PaymentIntent already succeeded, skipping', { id: paymentIntent.id });
+      return;
+    }
+
+    await paymentIntent.update({ status: 'processing', last_payment_error: null });
+
     if (paymentMethod.type === 'arcblock') {
       if (invoice?.billing_reason === 'slash_stake') {
         await handleStakeSlash(invoice, paymentIntent, paymentMethod, customer, paymentCurrency);
@@ -984,6 +1000,8 @@ export const handlePayment = async (job: PaymentJob) => {
         paymentQueue.delete(paymentIntent.id);
       }
     }
+  } finally {
+    await lock.release();
   }
 };
 

package/api/src/queues/subscription.ts

@@ -1,5 +1,6 @@
 import type { LiteralUnion } from 'type-fest';
 
+import { Op } from 'sequelize';
 import { createEvent } from '../libs/audit';
 import { ensurePassportRevoked } from '../integrations/blocklet/passport';
 import { batchHandleStripeSubscriptions } from '../integrations/stripe/resource';
@@ -8,7 +9,7 @@ import dayjs from '../libs/dayjs';
 import { events } from '../libs/event';
 import { getLock } from '../libs/lock';
 import logger from '../libs/logger';
-import { getGasPayerExtra } from '../libs/payment';
+import { getGasPayerExtra, isDelegationSufficientForPayment } from '../libs/payment';
 import createQueue from '../libs/queue';
 import { getStatementDescriptor } from '../libs/session';
 import {
@@ -240,9 +241,17 @@ const handleSubscriptionBeforeCancel = async (subscription: Subscription) => {
   });
 
   if (invoice) {
-    // schedule invoice job
-    invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
-    logger.info('Invoice job scheduled before cancel', { invoice: invoice.id, subscription: subscription.id });
+    // Just schedule the invoice processing, don't wait for completion
+    // The actual payment will be handled by handleFinalInvoicePayment during stake operations
+    await invoiceQueue.pushAndWait({
+      id: invoice.id,
+      job: { invoiceId: invoice.id, retryOnError: false },
+    });
+
+    logger.info('Final invoice job scheduled for async processing', {
+      invoice: invoice.id,
+      subscription: subscription.id,
+    });
 
     // persist invoice id
     await subscription.update({ latest_invoice_id: invoice.id });
@@ -341,9 +350,94 @@ const handleSubscriptionAfterRecover = async (subscription: Subscription) => {
   logger.info(`Subscription job scheduled for next billing cycle after recover: ${subscription.id}`);
 };
 
-const handleStakeSlashAfterCancel = async (subscription: Subscription) => {
+/**
+ * Handle final metered invoice payment before stake operations
+ * Checks user balance and slashes stake if insufficient funds
+ */
+const handleFinalInvoicePayment = async (
+  subscription: Subscription,
+  paymentMethod: PaymentMethod,
+  paymentCurrency: PaymentCurrency
+) => {
+  // Check if there's any unpaid final metered invoice
+  const lastInvoice = await Invoice.findOne({
+    where: {
+      subscription_id: subscription.id,
+      billing_reason: 'subscription_cancel',
+      status: { [Op.in]: ['open', 'uncollectible'] },
+      amount_remaining: { [Op.gt]: '0' },
+    },
+    order: [['created_at', 'DESC']],
+  });
+
+  if (!lastInvoice) {
+    logger.info('No unpaid final invoice found, skipping payment handling', {
+      subscription: subscription.id,
+    });
+    return;
+  }
+
+  // Check payment status and handle accordingly
+  const paymentIntent = await PaymentIntent.findByPk(lastInvoice.payment_intent_id);
+  if (!paymentIntent) {
+    logger.warn('PaymentIntent not found for final invoice', {
+      subscription: subscription.id,
+      invoice: lastInvoice.id,
+    });
+    return;
+  }
+
+  // If payment already succeeded, skip processing
+  if (paymentIntent.status === 'succeeded') {
+    logger.info('Final invoice already paid successfully, skipping', {
+      subscription: subscription.id,
+      invoice: lastInvoice.id,
+      paymentIntentStatus: paymentIntent.status,
+    });
+    return;
+  }
+
+  const customer = await Customer.findByPk(subscription.customer_id);
+  if (!customer) {
+    logger.warn('Final invoice settlement skipped because customer not found', {
+      subscription: subscription.id,
+      invoice: lastInvoice.id,
+    });
+    return;
+  }
+
+  logger.info('Found unpaid final invoice, checking user delegation balance', {
+    subscription: subscription.id,
+    invoice: lastInvoice.id,
+    amount: lastInvoice.amount_remaining,
+  });
+
+  const paymentSettings = lastInvoice.payment_settings;
+  const payer = paymentSettings?.payment_method_options?.arcblock?.payer as string;
+
+  const hasSufficientBalance = await isDelegationSufficientForPayment({
+    paymentMethod,
+    paymentCurrency,
+    userDid: payer || customer.did,
+    amount: lastInvoice.amount_remaining,
+  });
+
+  if (!hasSufficientBalance.sufficient) {
+    logger.info('User has insufficient balance, slashing stake to pay final invoice', {
+      subscription: subscription.id,
+      invoice: lastInvoice.id,
+      userBalance: hasSufficientBalance,
+    });
+
+    await handleStakeSlashAfterCancel(subscription, true);
+
+    logger.info('Stake slashed for final invoice, proceeding with remaining stake return');
+  }
+};
+
+export const handleStakeSlashAfterCancel = async (subscription: Subscription, forceSlash: boolean = false) => {
   const invoice = await Invoice.findByPk(subscription.latest_invoice_id);
-  if (!invoice || invoice.status !== 'uncollectible') {
+  if (!invoice || (invoice.status !== 'uncollectible' && !forceSlash)) {
     logger.warn('Stake slashing aborted because invoice status', {
       subscription: subscription.id,
       invoice: invoice?.id,
@@ -379,125 +473,155 @@ const handleStakeSlashAfterCancel = async (subscription: Subscription) => {
     return;
   }
   const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
-  if (!paymentIntent || paymentIntent.status === 'succeeded') {
-    logger.warn('Stake slashing aborted because payment intent', {
+  if (!paymentIntent) {
+    logger.warn('Stake slashing aborted because payment intent not found', {
       subscription: subscription.id,
-      paymentIntent: paymentIntent?.id,
-      status: paymentIntent?.status,
+      invoice: invoice.id,
     });
     return;
   }
 
-  // check the staking
-  const client = method.getOcapClient();
-  const address = await getSubscriptionStakeAddress(subscription, customer.did);
-  const { state } = await client.getStakeState({ address });
-  if (!state || !state.data?.value) {
-    logger.warn('Stake slashing aborted because no staking state', {
+  // Use lock to prevent race condition with payment queue
+  const lock = getLock(`payment-${paymentIntent.id}`);
+
+  try {
+    await lock.acquire();
+    logger.debug('Acquired lock for stake slashing', {
       subscription: subscription.id,
-      address,
+      paymentIntent: paymentIntent.id,
     });
-    return;
-  }
-  // check for staking for this subscription
-  const data = JSON.parse(state.data.value || '{}');
-  if (!data[subscription.id] && !state.nonce) {
-    logger.warn('Stake slashing aborted because no staking for subscription', {
+
+    // Re-check payment intent status after acquiring lock
+    await paymentIntent.reload();
+    if (paymentIntent.status === 'succeeded') {
+      logger.info('Payment already succeeded, skipping stake slashing', {
+        subscription: subscription.id,
+        paymentIntent: paymentIntent.id,
+        status: paymentIntent.status,
+      });
+      return;
+    }
+
+    // check the staking
+    const client = method.getOcapClient();
+    const address = await getSubscriptionStakeAddress(subscription, customer.did);
+    const { state } = await client.getStakeState({ address });
+    if (!state || !state.data?.value) {
+      logger.warn('Stake slashing aborted because no staking state', {
+        subscription: subscription.id,
+        address,
+      });
+      return;
+    }
+    // check for staking for this subscription
+    const data = JSON.parse(state.data.value || '{}');
+    if (!data[subscription.id] && !state.nonce) {
+      logger.warn('Stake slashing aborted because no staking for subscription', {
+        subscription: subscription.id,
+        address,
+        data,
+      });
+      return;
+    }
+
+    // check for staking for amount
+    const stakeEnough = await checkRemainingStake(method, currency, address, invoice.amount_remaining);
+    if (!stakeEnough.enough) {
+      logger.warn('Stake slashing aborted because no enough staking', {
+        subscription: subscription.id,
+        address,
+        staked: stakeEnough.staked,
+        revoked: stakeEnough.revoked,
+      });
+      return;
+    }
+
+    if (invoice.amount_remaining === '0') {
+      logger.warn('Stake slashing aborted because amount_remaining is 0', {
+        subscription: subscription.id,
+        address,
+        invoice: invoice.id,
+      });
+      return;
+    }
+
+    // do the slash
+    const signed = await client.signSlashStakeTx({
+      tx: {
+        itx: {
+          address,
+          outputs: [
+            { owner: wallet.address, tokens: [{ address: currency.contract, value: invoice.amount_remaining }] },
+          ],
+          message: 'uncollectible_past_due_invoice',
+          data: {
+            typeUrl: 'json',
+            // @ts-ignore
+            value: {
+              appId: wallet.address,
+              reason: 'subscription_cancel',
+              subscriptionId: subscription.id,
+              invoiceId: invoice.id,
+              paymentIntentId: paymentIntent.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 slashing done', {
       subscription: subscription.id,
+      amount: invoice.amount_remaining,
       address,
-      data,
+      txHash,
+      invoice: invoice.id,
     });
-    return;
-  }
 
-  // check for staking for amount
-  const stakeEnough = await checkRemainingStake(method, currency, address, invoice.amount_remaining);
-  if (!stakeEnough.enough) {
-    logger.warn('Stake slashing aborted because no enough staking', {
+    await paymentIntent.update({
+      status: 'succeeded',
+      amount_received: invoice.amount_remaining,
+      capture_method: 'manual',
+      last_payment_error: null,
+      payment_details: {
+        arcblock: {
+          tx_hash: txHash,
+          payer: getSubscriptionPaymentAddress(subscription, 'arcblock'),
+          type: 'slash',
+        },
+      },
+    });
+    logger.info('PaymentIntent updated after stake slash', {
       subscription: subscription.id,
-      address,
-      staked: stakeEnough.staked,
-      revoked: stakeEnough.revoked,
+      paymentIntent: paymentIntent.id,
+      status: 'succeeded',
+    });
+    await invoice.update({
+      paid: true,
+      status: 'paid',
+      amount_paid: paymentIntent.amount,
+      amount_remaining: '0',
+      attempt_count: invoice.attempt_count + 1,
+      attempted: true,
+      status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
     });
-    return;
-  }
 
-  if (invoice.amount_remaining === '0') {
-    logger.warn('Stake slashing aborted because amount_remaining is 0', {
+    logger.info('Invoice updated after stake slash', {
       subscription: subscription.id,
-      address,
       invoice: invoice.id,
+      status: 'paid',
+    });
+  } finally {
+    // Always release the lock
+    await lock.release();
+    logger.debug('Released lock for stake slashing', {
+      subscription: subscription.id,
+      paymentIntent: paymentIntent.id,
     });
-    return;
   }
-
-  // do the slash
-  const signed = await client.signSlashStakeTx({
-    tx: {
-      itx: {
-        address,
-        outputs: [{ owner: wallet.address, tokens: [{ address: currency.contract, value: invoice.amount_remaining }] }],
-        message: 'uncollectible_past_due_invoice',
-        data: {
-          typeUrl: 'json',
-          // @ts-ignore
-          value: {
-            appId: wallet.address,
-            reason: 'subscription_cancel',
-            subscriptionId: subscription.id,
-            invoiceId: invoice.id,
-            paymentIntentId: paymentIntent.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 slashing done', {
-    subscription: subscription.id,
-    amount: invoice.amount_remaining,
-    address,
-    txHash,
-    invoice: invoice.id,
-  });
-
-  await paymentIntent.update({
-    status: 'succeeded',
-    amount_received: invoice.amount_remaining,
-    capture_method: 'manual',
-    last_payment_error: null,
-    payment_details: {
-      arcblock: {
-        tx_hash: txHash,
-        payer: getSubscriptionPaymentAddress(subscription, 'arcblock'),
-        type: 'slash',
-      },
-    },
-  });
-  logger.info('PaymentIntent updated after stake slash', {
-    subscription: subscription.id,
-    paymentIntent: paymentIntent.id,
-    status: 'succeeded',
-  });
-  await invoice.update({
-    paid: true,
-    status: 'paid',
-    amount_paid: paymentIntent.amount,
-    amount_remaining: '0',
-    attempt_count: invoice.attempt_count + 1,
-    attempted: true,
-    status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
-  });
-
-  logger.info('Invoice updated after stake slash', {
-    subscription: subscription.id,
-    invoice: invoice.id,
-    status: 'paid',
-  });
 };
 
 const ensureReturnStake = async (subscription: Subscription, paymentCurrencyId?: string, stakingAddress?: string) => {
@@ -528,6 +652,9 @@ const ensureReturnStake = async (subscription: Subscription, paymentCurrencyId?:
     return;
   }
 
+  // Handle any unpaid final invoice before stake return
+  await handleFinalInvoicePayment(subscription, paymentMethod, paymentCurrency);
+
   const result = await getSubscriptionStakeReturnSetup(subscription, address, paymentMethod, paymentCurrencyId);
 
   const stakeEnough = await checkRemainingStake(paymentMethod, paymentCurrency, address, result.return_amount);
@@ -562,7 +689,7 @@ const ensureReturnStake = async (subscription: Subscription, paymentCurrencyId?:
       invoice_id: invoice?.id,
       customer_id: subscription.customer_id,
       payment_method_id: paymentMethod.id,
-      payment_intent_id: result?.lastInvoice?.payment_intent_id as string,
+      payment_intent_id: invoice?.payment_intent_id || '',
       subscription_id: subscription.id,
       attempt_count: 0,
       attempted: false,
@@ -959,6 +1086,13 @@ export const startSubscriptionQueue = async () => {
           return;
         }
         if (['past_due', 'paused'].includes(x.status)) {
+          const willCancel = x.cancel_at || x.cancel_at_period_end;
+          if (x.status === 'past_due' && willCancel) {
+            const existingJob = await subscriptionQueue.get(`cancel-${x.id}`);
+            if (!existingJob) {
+              await addSubscriptionJob(x, 'cancel', true, x.cancel_at || x.current_period_end);
+            }
+          }
           logger.info(`skip add cycle subscription job because status is ${x.status}`, {
             subscription: x.id,
             action: 'cycle',
@@ -1086,10 +1220,11 @@ export async function addSubscriptionJob(
   sync?: boolean
 ) {
   const fn = sync ? 'pushAndWait' : 'push';
-  const jobId = action === 'cycle' ? subscription.id : `${action}-${subscription.id}`;
-  const cycleJob = await subscriptionQueue.get(jobId);
+  const cycleJobId = subscription.id;
+  const jobId = action === 'cycle' ? cycleJobId : `${action}-${subscription.id}`;
+  const cycleJob = await subscriptionQueue.get(cycleJobId);
   if (replace && cycleJob) {
-    await subscriptionQueue.delete(jobId);
+    await subscriptionQueue.delete(cycleJobId);
     logger.info(`subscription cycle job replaced with ${action} job`, { subscription: subscription.id });
   }
   if (action === 'cycle') {

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

@@ -45,8 +45,8 @@ export default {
         amount: fastCheckoutAmount,
       });
       const needDelegation = delegation.sufficient === false;
-      const noStake = subscription.billing_thresholds?.no_stake;
-      if (needDelegation || noStake) {
+      const requiredStake = !subscription.billing_thresholds?.no_stake;
+      if (needDelegation || !requiredStake) {
         claimsList.push({
           signature: await getDelegationTxClaim({
             mode: 'setup',
@@ -59,11 +59,12 @@ export default {
             trialing,
             billingThreshold,
             items,
+            requiredStake,
           }),
         });
       }
 
-      if (!noStake) {
+      if (requiredStake) {
         claimsList.push({
           prepareTx: await getStakeTxClaim({
             userDid,
@@ -109,7 +110,7 @@ export default {
     const { setupIntent, subscription, paymentMethod, paymentCurrency, customer } =
       await ensureChangePaymentContext(subscriptionId);
 
-    const noStake = subscription.billing_thresholds?.no_stake;
+    const requiredStake = !subscription.billing_thresholds?.no_stake;
 
     const result = request?.context?.store?.result || [];
     result.push({
@@ -123,7 +124,7 @@ export default {
     // 判断是否为最后一步
     const staking = result.find((x: any) => x.claim?.type === 'prepareTx' && x.claim?.meta?.purpose === 'staking');
     const isFinalStep =
-      (paymentMethod.type === 'arcblock' && (staking || noStake)) || paymentMethod.type !== 'arcblock';
+      (paymentMethod.type === 'arcblock' && (staking || !requiredStake)) || paymentMethod.type !== 'arcblock';
 
     if (!isFinalStep) {
       await updateSession({

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

@@ -691,6 +691,7 @@ export async function getDelegationTxClaim({
   paymentMethod,
   trialing = false,
   billingThreshold = 0,
+  requiredStake = true,
 }: {
   userDid: string;
   userPk: string;
@@ -702,6 +703,7 @@ export async function getDelegationTxClaim({
   paymentMethod: PaymentMethod;
   trialing: boolean;
   billingThreshold?: number;
+  requiredStake?: boolean;
 }) {
   const amount = getFastCheckoutAmount(items, mode, paymentCurrency.id);
   const address = toDelegateAddress(userDid, wallet.address);
@@ -713,8 +715,8 @@ export async function getDelegationTxClaim({
     billingThreshold,
     paymentMethod,
     paymentCurrency,
+    requiredStake
   });
-
   if (mode === 'delegation') {
     tokenRequirements = [];
   }
@@ -1003,6 +1005,7 @@ export type TokenRequirementArgs = {
   paymentCurrency: PaymentCurrency;
   trialing: boolean;
   billingThreshold: number;
+  requiredStake?: boolean;
 };
 
 export async function getTokenRequirements({
@@ -1012,6 +1015,7 @@ export async function getTokenRequirements({
   paymentCurrency,
   trialing = false,
   billingThreshold = 0,
+  requiredStake
 }: TokenRequirementArgs) {
   const tokenRequirements = [];
   let amount = getFastCheckoutAmount(items, mode, paymentCurrency.id, !!trialing);
@@ -1039,7 +1043,7 @@ export async function getTokenRequirements({
   }
 
   // Add stake requirement to token requirement
-  if ((paymentMethod.type === 'arcblock' && mode !== 'delegation') || mode === 'setup') {
+  if (requiredStake && ((paymentMethod.type === 'arcblock' && mode !== 'delegation') || mode === 'setup')) {
     const staking = getSubscriptionStakeSetup(
       items,
       paymentCurrency.id,

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

@@ -66,6 +66,7 @@ export default {
     const claimsList: any[] = [];
 
     const allSubscriptionIds = subscriptions.map((sub) => sub.id);
+    const requiredStake = !checkoutSession.subscription_data?.no_stake;
     if (paymentMethod.type === 'arcblock') {
       const delegation = await isDelegationSufficientForPayment({
         paymentMethod,
@@ -76,7 +77,7 @@ export default {
 
       // if we can complete purchase without any wallet interaction
       // we forced to delegate if we can skip stake
-      if (delegation.sufficient === false || checkoutSession.subscription_data?.no_stake) {
+      if (delegation.sufficient === false || !requiredStake) {
         claimsList.push({
           signature: await getDelegationTxClaim({
             mode: checkoutSession.mode,
@@ -93,11 +94,12 @@ export default {
             trialing,
             billingThreshold: Math.max(minStakeAmount, billingThreshold),
             items,
+            requiredStake,
           }),
         });
       }
 
-      if (!checkoutSession.subscription_data?.no_stake) {
+      if (requiredStake) {
         claimsList.push({
           prepareTx: await getStakeTxClaim({
             userDid,
@@ -162,10 +164,10 @@ export default {
         headers: request?.headers,
       },
     });
+    const requiredStake = !checkoutSession.subscription_data?.no_stake;
     const staking = result.find((x: any) => x.claim?.type === 'prepareTx' && x.claim?.meta?.purpose === 'staking');
     const isFinalStep =
-      (paymentMethod.type === 'arcblock' && (staking || checkoutSession.subscription_data?.no_stake)) ||
-      paymentMethod.type !== 'arcblock';
+      (paymentMethod.type === 'arcblock' && (staking || !requiredStake)) || paymentMethod.type !== 'arcblock';
     if (!isFinalStep) {
       await updateSession({
         result,

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.18.54",
+  "version": "1.18.55",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -45,30 +45,30 @@
   },
   "dependencies": {
     "@abtnode/cron": "^1.16.44",
-    "@arcblock/did": "^1.20.13",
+    "@arcblock/did": "^1.20.14",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
-    "@arcblock/did-connect": "^2.13.62",
-    "@arcblock/did-util": "^1.20.13",
-    "@arcblock/jwt": "^1.20.13",
-    "@arcblock/ux": "^2.13.62",
-    "@arcblock/validator": "^1.20.13",
-    "@blocklet/did-space-js": "^1.0.58",
+    "@arcblock/did-connect": "^2.13.66",
+    "@arcblock/did-util": "^1.20.14",
+    "@arcblock/jwt": "^1.20.14",
+    "@arcblock/ux": "^2.13.66",
+    "@arcblock/validator": "^1.20.14",
+    "@blocklet/did-space-js": "^1.0.60",
     "@blocklet/js-sdk": "^1.16.44",
     "@blocklet/logger": "^1.16.44",
-    "@blocklet/payment-react": "1.18.54",
+    "@blocklet/payment-react": "1.18.55",
     "@blocklet/sdk": "^1.16.44",
-    "@blocklet/ui-react": "^2.13.62",
+    "@blocklet/ui-react": "^2.13.66",
     "@blocklet/uploader": "^0.1.95",
     "@blocklet/xss": "^0.1.36",
     "@mui/icons-material": "^5.16.6",
     "@mui/lab": "^5.0.0-alpha.173",
     "@mui/material": "^5.16.6",
     "@mui/system": "^5.16.6",
-    "@ocap/asset": "^1.20.13",
-    "@ocap/client": "^1.20.13",
-    "@ocap/mcrypto": "^1.20.13",
-    "@ocap/util": "^1.20.13",
-    "@ocap/wallet": "^1.20.13",
+    "@ocap/asset": "^1.20.14",
+    "@ocap/client": "^1.20.14",
+    "@ocap/mcrypto": "^1.20.14",
+    "@ocap/util": "^1.20.14",
+    "@ocap/wallet": "^1.20.14",
     "@stripe/react-stripe-js": "^2.7.3",
     "@stripe/stripe-js": "^2.4.0",
     "ahooks": "^3.8.0",
@@ -123,7 +123,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.44",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.18.54",
+    "@blocklet/payment-types": "1.18.55",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -169,5 +169,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "6315d7f4272e88e6a840a1948fd9745db9011e16"
+  "gitHead": "87893b50ad72026312cd6b5d35e7f6f1181ad53a"
 }