@abtnode/core 1.16.11-next-09bc31f8 → 1.16.11-next-7cff3891

package/lib/blocklet/manager/disk.js

@@ -70,6 +70,8 @@ const {
   BLOCKLET_CONFIGURABLE_KEY,
   RESTORE_PROGRESS_STATUS,
   CHAIN_PROP_MAP_REVERSE,
+  BLOCKLET_CONTROLLER_STATUS,
+  SUSPENDED_REASON,
 } = require('@blocklet/constant');
 const { consumeServerlessNFT, consumeLauncherSession } = require('../../util/launcher');
 const util = require('../../util');
@@ -111,7 +113,7 @@ const {
   getProcessState,
   getBlockletStatus,
   shouldSkipComponent,
-  shouldCleanExpiredBlocklet,
+  exceedRedemptionPeriod,
 } = require('../../util/blocklet');
 const states = require('../../states');
 const BaseBlockletManager = require('./base');
@@ -457,6 +459,8 @@ class BlockletManager extends BaseBlockletManager {
     // should check blocklet integrity
     const blocklet = await this.ensureBlocklet(did, { e2eMode });
 
+    await this.checkControllerStatus(blocklet, 'start');
+
     try {
       // blocklet may be manually stopped durning starting
       // so error message would not be sent if blocklet is stopped
@@ -651,7 +655,6 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   /**
-   * FIXME: @linchen support cancel
    * @param {import('@abtnode/client').RequestRestoreBlockletInput} input
    * @memberof BlockletManager
    */
@@ -677,6 +680,8 @@ class BlockletManager extends BaseBlockletManager {
    */
   async restart({ did, componentDids }, context) {
     logger.info('restart blocklet', { did });
+    const blocklet = await this.getBlocklet(did);
+    await this.checkControllerStatus(blocklet, 'restart');
 
     await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping, { componentDids });
     const result = await states.blocklet.getBlocklet(did);
@@ -712,6 +717,8 @@ class BlockletManager extends BaseBlockletManager {
   async reload({ did, componentDids: list }, context) {
     const blocklet = await this.getBlocklet(did);
 
+    await this.checkControllerStatus(blocklet, 'reload');
+
     const componentDids = (blocklet.children || [])
       .filter((x) => x.status === BlockletStatus.running)
       .filter((x) => !shouldSkipComponent(x.meta.did, list))
@@ -1042,22 +1049,9 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async list({ includeRuntimeInfo = true, query, filter } = {}, context) {
+  async list({ includeRuntimeInfo = true, query } = {}, context) {
     const condition = { ...flat(query || {}) };
-    if (filter === 'external-only') {
-      condition.controller = {
-        $exists: true,
-      };
-    }
-
-    if (filter === 'external-excluded') {
-      condition.controller = {
-        $exists: false,
-      };
-    }
-
     const blocklets = await states.blocklet.getBlocklets(condition);
-
     if (includeRuntimeInfo) {
       return this._attachBlockletListRuntimeInfo({ blocklets }, context);
     }
@@ -1559,22 +1553,29 @@ class BlockletManager extends BaseBlockletManager {
       {
         name: 'refresh-accessible-ip',
         time: '0 */10 * * * *', // 10min
+        options: { runOnInit: true },
         fn: async () => {
           const nodeInfo = await states.node.read();
           await refreshAccessibleExternalNodeIp(nodeInfo);
         },
       },
       {
-        name: 'delete-expired-external-blocklet',
+        name: 'check-renewed-blocklet',
+        time: '0 */10 * * * *', // 10min
+        options: { runOnInit: false },
+        fn: () => this.checkRenewedBlocklet(),
+      },
+      {
+        name: 'stop-expired-external-blocklet',
         time: '0 */30 * * * *', // 30min
         options: { runOnInit: false },
-        fn: () => this._deleteExpiredExternalBlocklet(),
+        fn: () => this.stopExpiredBlocklets(),
       },
       {
         name: 'clean-expired-blocklet-data',
         time: '0 */20 0 * * *', // 每天凌晨 0 点的每 20 分钟
         options: { runOnInit: false },
-        fn: () => this._cleanExpiredBlockletData(),
+        fn: () => this.cleanExpiredBlocklets(),
       },
       {
         name: 'record-blocklet-runtime-history',
@@ -2856,71 +2857,102 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _deleteExpiredExternalBlocklet() {
+  async checkRenewedBlocklet() {
     try {
-      logger.info('start check expired external blocklet');
+      logger.info('start check renewed blocklet');
+
+      // 只检查因为过期而被 suspended 的 blocklet
+      const blockletExtras = await states.blockletExtras.find(
+        {
+          'controller.status.value': BLOCKLET_CONTROLLER_STATUS.suspended,
+          'controller.status.reason': SUSPENDED_REASON.expired,
+        },
+        { did: 1, meta: 1, controller: 1 }
+      );
+
+      for (const data of blockletExtras) {
+        const blocklet = await states.blocklet.getBlocklet(data.did);
+        if (!blocklet) {
+          logger.error('blocklet not found', { did: data.did });
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        const assetState = await util.getNFTState(data.controller.chainHost, data.controller.nftId);
+        const isExpired = isNFTExpired(assetState);
+        if (isExpired === false) {
+          logger.info('blocklet is renewed', { did: data.did });
+          await states.blockletExtras.updateByDid(data.did, {
+            ...data.controller,
+            status: { value: BLOCKLET_CONTROLLER_STATUS.normal, reason: '' },
+          });
+
+          logger.info('start to start blocklet', { did: data.did });
+
+          if (![BlockletStatus.starting, BlockletStatus.running].includes(blocklet.status)) {
+            await this.start({ did: data.did });
+            logger.info('start blocklet success', { did: data.did });
+          }
+        }
+      }
+    } catch (error) {
+      logger.error('start check renewed blocklet failed', { error });
+    }
+  }
+
+  async stopExpiredBlocklets() {
+    try {
+      logger.info('start checking expired blocklet');
       const blockletExtras = await states.blockletExtras.find(
         {
           controller: {
             $exists: true,
           },
-          expiredAt: {
-            $exists: false,
-          },
         },
         { did: 1, meta: 1, controller: 1 }
       );
 
-      logger.info('external blocklet count', { count: blockletExtras.length });
+      if (blockletExtras.length === 0) {
+        logger.info('no expired blocklet');
+        return;
+      }
+
+      logger.info('expired blocklet count', { count: blockletExtras.length });
 
       for (const data of blockletExtras) {
         try {
-          if (isEmpty(data.controller)) {
-            logger.info('skip the blocklet without controller', { blockletDid: data.did, controller: data.controller });
-            // eslint-disable-next-line no-continue
-            continue;
-          }
-
           const { did } = data;
           const assetState = await util.getNFTState(data.controller.chainHost, data.controller.nftId);
           const isExpired = isNFTExpired(assetState);
+          const blocklet = await states.blocklet.getBlocklet(did);
 
-          if (isExpired) {
-            logger.info('the blocklet already expired', {
+          if (isExpired && blocklet.status !== BlockletStatus.stopped) {
+            const expiredAt = getNftExpirationDate(assetState);
+            logger.info('the blocklet already expired and will be stopped', {
               blockletDid: did,
               nftId: data.controller.nftId,
+              expiredAt,
             });
 
-            const blocklet = await states.blocklet.getBlocklet(did);
-            if (blocklet) {
-              // 预防 Blocklet 已经删除，但是 blocklet extra data 没有清理的场景
-              await this._backupToDisk({ blocklet });
-              logger.info('backed up the expired blocklet', {
-                blockletDid: did,
-                nftId: data.controller.nftId,
-              });
-
-              await this.delete({ did, keepData: true, keepConfigs: true, keepLogsDir: true });
-              logger.info('the expired blocklet already deleted', {
-                blockletDid: did,
-                nftId: data.controller.nftId,
-              });
-            }
-
-            const expiredAt = getNftExpirationDate(assetState);
-            await states.blockletExtras.updateExpireInfo({ did, expiredAt });
-            logger.info('updated expired blocklet extra info', {
-              nftId: data.controller.nftId,
-              blockletDid: did,
+            await this.stop({ did });
+            await states.blockletExtras.updateByDid(did, {
+              controller: {
+                ...data.controller,
+                status: {
+                  value: BLOCKLET_CONTROLLER_STATUS.suspended,
+                  reason: SUSPENDED_REASON.expired,
+                },
+              },
             });
+            logger.info('the expired blocklet is stopped', { did });
 
-            // 删除 blocklet 后会 reload nginx, 所以这里每次删除一个
+            // 为了减小服务器压力，每次删除一个 blocklet 后，休息 10s
             if (process.env.NODE_ENV !== 'test') {
               await sleep(10 * 1000);
             }
           }
         } catch (error) {
-          logger.error('delete expired blocklet failed', {
+          logger.error('stop expired blocklet failed', {
             blockletDid: data.did,
             nftId: data.controller?.nftId,
             error,
@@ -2934,62 +2966,68 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _cleanExpiredBlockletData() {
+  async cleanExpiredBlocklets() {
     try {
-      logger.info('start clean expired blocklet data');
-      const blockletExtras = await states.blockletExtras.getExpiredList();
+      logger.info('start checking exceeding the redemption period blocklet');
+      const blockletExtras = await states.blockletExtras.find(
+        {
+          'controller.status.value': BLOCKLET_CONTROLLER_STATUS.suspended,
+        },
+        { did: 1, meta: 1, controller: 1 }
+      );
+
       if (blockletExtras.length === 0) {
-        logger.info('no expired blocklet data');
+        logger.info('no exceeding the redemption blocklet need to be cleaned');
         return;
       }
 
-      const tasks = blockletExtras.map(async ({ appDid, did, meta, controller }) => {
-        const blocklet = await this.getBlocklet(did);
-        if (blocklet) {
-          logger.error('skip cleaning the blocklet which is not deleted', { blockletDid: did });
-          return;
-        }
-
-        const assetState = await util.getNFTState(controller.chainHost, controller.nftId);
-        const expirationDate = getNftExpirationDate(assetState);
+      logger.info('exceeding the redemption blocklet count', { count: blockletExtras.length });
 
-        if (!shouldCleanExpiredBlocklet(expirationDate)) {
-          logger.error('skip cleaning the blocklet which is not expired', { blockletDid: did, expirationDate });
-          await blockletExtras.updateExpireInfo({ did, expiredAt: expirationDate });
-          return;
-        }
-
-        let blockletMeta = meta;
-        if (isEmpty(blockletMeta)) {
-          // 旧版本的 blocklet 没有 meta 信息，这里补充一下
-          blockletMeta = { did, name: did };
-          logger.error('the blocklet original meta is empty', { did, blockletMeta });
-        }
+      for (const data of blockletExtras) {
+        try {
+          const { did } = data;
+          const assetState = await util.getNFTState(data.controller.chainHost, data.controller.nftId);
+          const expiredAt = getNftExpirationDate(assetState);
 
-        await this._cleanBlockletData({
-          blocklet: { meta: blockletMeta },
-          keepData: false,
-          keepLogsDir: false,
-          keepConfigs: false,
-        });
-        logger.info(`clean blocklet ${blockletMeta.did} extra data`);
+          if (!exceedRedemptionPeriod(expiredAt)) {
+            logger.error('skip cleaning the non-exceed redemption blocklet', {
+              blockletDid: did,
+              expiredAt,
+            });
+            // eslint-disable-next-line no-continue
+            continue;
+          }
 
-        await removeBackup(this.dataDirs.data, appDid);
-        logger.info(`removed blocklet ${blockletMeta.did} backup`);
+          logger.info('the blocklet already exceed redemption and will be deleted', {
+            blockletDid: did,
+            nftId: data.controller.nftId,
+            expiredAt,
+          });
 
-        this.emit(BlockletEvents.dataCleaned, {
-          blocklet: { meta: blockletMeta },
-          keepRouting: false,
-        });
+          // TODO: 如果绑定了 DID Space 备份到 DID Space
 
-        logger.info(`cleaned expired blocklet blocklet ${blockletMeta.did} data`);
-      });
+          await this.delete({ did, keepData: false, keepConfigs: false, keepLogsDir: false });
+          logger.info('the exceed redemption blocklet already deleted', {
+            blockletDid: did,
+            nftId: data.controller.nftId,
+          });
 
-      await Promise.all(tasks);
+          // 删除 blocklet 后会 reload nginx, 所以这里每次删除一个
+          if (process.env.NODE_ENV !== 'test') {
+            await sleep(10 * 1000);
+          }
+        } catch (error) {
+          logger.error('delete exceed redemption blocklet failed', {
+            blockletDid: data.did,
+            nftId: data.controller?.nftId,
+            error,
+          });
+        }
+      }
 
-      logger.info('clean expired blocklet data done');
+      logger.info('check exceeding the redemption period blocklet end');
     } catch (error) {
-      logger.error('clean expired blocklet data failed', { error });
+      logger.error('checking exceeding the redemption period blocklet failed', { error });
     }
   }
 
@@ -3193,6 +3231,38 @@ class BlockletManager extends BaseBlockletManager {
     }
     await this._setConfigsFromMeta(did);
   }
+
+  async checkControllerStatus(blocklet, action) {
+    if (isEmpty(blocklet.controller)) {
+      return;
+    }
+
+    const assetState = await util.getNFTState(blocklet.controller?.chainHost, blocklet.controller?.nftId);
+
+    if (isNFTExpired(assetState)) {
+      logger.error(`try to ${action} an expired blocklet`, {
+        did: blocklet.meta.did,
+        nftId: blocklet.controller?.nftId,
+      });
+      throw new Error(`can not ${action} an expired blocklet`);
+    }
+
+    if (
+      blocklet.controller.status?.value === BLOCKLET_CONTROLLER_STATUS.suspended &&
+      blocklet.controller.status?.reason === SUSPENDED_REASON.expired
+    ) {
+      // 如果是因为过期被暂停的，续期后, 并且不影响启动
+      await states.blockletExtras.updateByDid(blocklet.meta.did, {
+        controller: {
+          ...blocklet.controller,
+          status: {
+            value: BLOCKLET_CONTROLLER_STATUS.normal,
+            reason: '',
+          },
+        },
+      });
+    }
+  }
 }
 
 module.exports = BlockletManager;

package/lib/states/blocklet-extras.js

@@ -2,15 +2,13 @@
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable consistent-return */
 const logger = require('@abtnode/logger')('@abtnode/core:states:blocklet-extras');
-const { EXPIRED_BLOCKLET_DATA_RETENTION_DAYS } = require('@abtnode/constant');
 const camelCase = require('lodash/camelCase');
 const get = require('lodash/get');
-const dayjs = require('dayjs');
 
 const BaseState = require('./base');
 
 const { mergeConfigs, parseConfigs, encryptConfigs } = require('../blocklet/extras');
-const { validateAddMeta, validateExpiredInfo } = require('../validators/blocklet-extra');
+const { validateAddMeta } = require('../validators/blocklet-extra');
 
 const noop = (k) => (v) => v[k];
 
@@ -213,19 +211,6 @@ class BlockletExtrasState extends BaseState {
     return super.findOne({ did }, { did: 1, controller: 1, meta: 1 });
   }
 
-  async updateExpireInfo({ did, expiredAt } = {}) {
-    const entity = { did, expiredAt };
-    await validateExpiredInfo(entity);
-
-    return this.updateByDid(did, { expiredAt });
-  }
-
-  async getExpiredList() {
-    const deadline = dayjs().subtract(EXPIRED_BLOCKLET_DATA_RETENTION_DAYS, 'days').toISOString();
-    const docs = await super.find({ expiredAt: { $exists: true } });
-    return docs.filter((x) => x.controller?.nftId).filter((x) => x.expiredAt <= deadline);
-  }
-
   async isLauncherSessionConsumed(sessionId) {
     const count = await super.count({ 'controller.sessionId': sessionId });
     return count > 0;

package/lib/team/manager.js

@@ -104,7 +104,7 @@ class TeamManager extends EventEmitter {
     return this.getState(teamDid, 'passport');
   }
 
-  async getConnectedAccount(teamDid) {
+  async getConnectedAccountState(teamDid) {
     return this.getState(teamDid, 'connectedAccount');
   }
 

package/lib/util/blocklet.js

@@ -892,13 +892,15 @@ const checkBlockletProcessHealthy = async (blocklet, { minConsecutiveTime, timeo
         return;
       }
 
-      await _checkProcessHealthy(b, { minConsecutiveTime, timeout });
+      const logToTerminal = [blocklet.mode, b.mode].includes(BLOCKLET_MODES.DEVELOPMENT);
+
+      await _checkProcessHealthy(b, { minConsecutiveTime, timeout, logToTerminal });
     },
     { parallel: true }
   );
 };
 
-const _checkProcessHealthy = async (blocklet, { minConsecutiveTime, timeout }) => {
+const _checkProcessHealthy = async (blocklet, { minConsecutiveTime, timeout, logToTerminal }) => {
   const { meta, ports, env } = blocklet;
   const { name } = meta;
   const { processId } = env;
@@ -934,6 +936,14 @@ const _checkProcessHealthy = async (blocklet, { minConsecutiveTime, timeout }) =
     }
 
     const port = findInterfacePortByName({ meta, ports }, webInterface.name);
+    if (logToTerminal) {
+      // eslint-disable-next-line no-console
+      console.log(
+        `Checking endpoint healthy for ${meta.title}, port: ${port}, minConsecutiveTime: ${
+          minConsecutiveTime / 1000
+        }s, timeout: ${timeout / 1000}s`
+      );
+    }
     try {
       await ensureEndpointHealthy({
         port,
@@ -1953,7 +1963,7 @@ const shouldSkipComponent = (componentDid, whiteList) => {
   return !arr.includes(componentDid);
 };
 
-const shouldCleanExpiredBlocklet = (expirationDate) => {
+const exceedRedemptionPeriod = (expirationDate) => {
   return dayjs().diff(dayjs(expirationDate), 'day') > EXPIRED_BLOCKLET_DATA_RETENTION_DAYS;
 };
 
@@ -2016,6 +2026,6 @@ module.exports = {
   getProcessState,
   getBlockletStatus,
   shouldSkipComponent,
-  shouldCleanExpiredBlocklet,
   getBlockletURLForLauncher,
+  exceedRedemptionPeriod,
 };

package/lib/util/get-accessible-external-node-ip.js

@@ -1,6 +1,7 @@
 const joinUrl = require('url-join');
 const axios = require('@abtnode/util/lib/axios');
 const { DEFAULT_IP_DOMAIN, DEFAULT_ADMIN_PATH } = require('@abtnode/constant');
+const logger = require('@abtnode/logger')('@abtnode/core:util:get-accessible-external-node-ip');
 const { get: getIp } = require('./ip');
 
 const getNodeDomain = (ip) => (ip ? DEFAULT_IP_DOMAIN.replace(/^\*/, ip.replace(/\./g, '-')) : '');
@@ -23,6 +24,7 @@ const checkConnected = async ({ ip, nodeInfo }) => {
  */
 const fetch = async (nodeInfo) => {
   const { external } = await getIp();
+  logger.info('refresh external ip:', external);
 
   if (!external) {
     return null;

package/lib/util/reset-node.js

@@ -12,9 +12,13 @@ const resetOwner = async ({ teamManager }) => {
     const nodeInfo = await states.node.read();
     const teamDid = nodeInfo.did;
     const userState = await teamManager.getUserState(teamDid);
-    const count = await userState.remove({ role: 'owner' });
+    const passportState = await teamManager.getPassportState(teamDid);
+    const connectedAccountState = await teamManager.getConnectedAccountState(teamDid);
+    await passportState.remove({ userDid: nodeInfo.nodeOwner.did });
+    await connectedAccountState.remove({ userDid: nodeInfo.nodeOwner.did });
+    await userState.remove({ did: nodeInfo.nodeOwner.did });
     await states.node.updateNodeInfo({ nodeOwner: null });
-    logger.info('reset node owner', result, count);
+    logger.info('reset node owner', result);
   } catch (err) {
     // Do nothing
   }
@@ -69,22 +73,21 @@ const resetCertificates = async ({ certManager }) => {
 };
 
 const resetUsers = async ({ teamManager }) => {
-  const nodeInfo = await states.node.read();
-
-  const teamDid = nodeInfo.did;
-  const userState = await teamManager.getUserState(teamDid);
-  const users = await userState.find({});
+  try {
+    const nodeInfo = await states.node.read();
 
-  let count = 0;
-  for (const user of users) {
-    if (nodeInfo.nodeOwner.did !== user.did) {
-      // eslint-disable-next-line no-await-in-loop
-      await userState.remove({ did: user.did });
-      count++;
-    }
+    const teamDid = nodeInfo.did;
+    const userState = await teamManager.getUserState(teamDid);
+    const passportState = await teamManager.getPassportState(teamDid);
+    const connectedAccountState = await teamManager.getConnectedAccountState(teamDid);
+    await passportState.remove({ userDid: { $ne: nodeInfo.nodeOwner.did } });
+    await connectedAccountState.remove({ userDid: { $ne: nodeInfo.nodeOwner.did } });
+    await userState.remove({ did: { $ne: nodeInfo.nodeOwner.did } });
+
+    logger.info('reset users');
+  } catch (error) {
+    logger.error('failed reset users', { error });
   }
-
-  logger.info('reset users', { count });
 };
 
 const resetInvitations = async ({ teamManager }) => {

package/lib/validators/blocklet-extra.js

@@ -13,12 +13,6 @@ const addMeta = Joi.object({
   controller: blockletController.optional(),
 }).required();
 
-const updateExpiredInfo = Joi.object({
-  did: Joi.DID().required(),
-  expiredAt: Joi.string().required(),
-});
-
 module.exports = {
   validateAddMeta: createValidator(addMeta),
-  validateExpiredInfo: createValidator(updateExpiredInfo),
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.11-next-09bc31f8",
+  "version": "1.16.11-next-7cff3891",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,18 +19,18 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/auth": "1.16.11-next-09bc31f8",
-    "@abtnode/certificate-manager": "1.16.11-next-09bc31f8",
-    "@abtnode/constant": "1.16.11-next-09bc31f8",
-    "@abtnode/cron": "1.16.11-next-09bc31f8",
-    "@abtnode/logger": "1.16.11-next-09bc31f8",
-    "@abtnode/models": "1.16.11-next-09bc31f8",
-    "@abtnode/queue": "1.16.11-next-09bc31f8",
-    "@abtnode/rbac": "1.16.11-next-09bc31f8",
-    "@abtnode/router-provider": "1.16.11-next-09bc31f8",
-    "@abtnode/static-server": "1.16.11-next-09bc31f8",
-    "@abtnode/timemachine": "1.16.11-next-09bc31f8",
-    "@abtnode/util": "1.16.11-next-09bc31f8",
+    "@abtnode/auth": "1.16.11-next-7cff3891",
+    "@abtnode/certificate-manager": "1.16.11-next-7cff3891",
+    "@abtnode/constant": "1.16.11-next-7cff3891",
+    "@abtnode/cron": "1.16.11-next-7cff3891",
+    "@abtnode/logger": "1.16.11-next-7cff3891",
+    "@abtnode/models": "1.16.11-next-7cff3891",
+    "@abtnode/queue": "1.16.11-next-7cff3891",
+    "@abtnode/rbac": "1.16.11-next-7cff3891",
+    "@abtnode/router-provider": "1.16.11-next-7cff3891",
+    "@abtnode/static-server": "1.16.11-next-7cff3891",
+    "@abtnode/timemachine": "1.16.11-next-7cff3891",
+    "@abtnode/util": "1.16.11-next-7cff3891",
     "@arcblock/did": "1.18.80",
     "@arcblock/did-auth": "1.18.80",
     "@arcblock/did-ext": "^1.18.80",
@@ -41,10 +41,10 @@
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/validator": "^1.18.80",
     "@arcblock/vc": "1.18.80",
-    "@blocklet/constant": "1.16.11-next-09bc31f8",
-    "@blocklet/meta": "1.16.11-next-09bc31f8",
-    "@blocklet/sdk": "1.16.11-next-09bc31f8",
-    "@did-space/client": "^0.2.112",
+    "@blocklet/constant": "1.16.11-next-7cff3891",
+    "@blocklet/meta": "1.16.11-next-7cff3891",
+    "@blocklet/sdk": "1.16.11-next-7cff3891",
+    "@did-space/client": "^0.2.113",
     "@fidm/x509": "^1.2.1",
     "@ocap/mcrypto": "1.18.80",
     "@ocap/util": "1.18.80",
@@ -96,5 +96,5 @@
     "express": "^4.18.2",
     "jest": "^27.5.1"
   },
-  "gitHead": "c51355ac77d07dc27e2fb6c44ce2a45432a9469b"
+  "gitHead": "53ffbcdca9cda278337d80bfafa44e7ef5635af1"
 }