@abtnode/core 1.8.68 → 1.8.69-beta-e0666d0d

package/lib/blocklet/storage/restore/blocklet.js

@@ -0,0 +1,49 @@
+const { removeSync, outputJsonSync, readJSONSync } = require('fs-extra');
+const { join } = require('path');
+const security = require('@abtnode/util/lib/security');
+const { BaseRestore } = require('./base');
+
+class BlockletRestore extends BaseRestore {
+  filename = 'blocklet.json';
+
+  async import(params) {
+    const blocklet = this.decrypt(this.getBlocklet(), params);
+    removeSync(join(this.restoreDir, this.filename));
+    outputJsonSync(join(this.restoreDir, this.filename), blocklet);
+  }
+
+  /**
+   *
+   * @description
+   * @return {import('@abtnode/client').BlockletState}
+   * @memberof BlockletRestore
+   */
+  getBlocklet() {
+    return readJSONSync(join(this.restoreDir, this.filename));
+  }
+
+  /**
+   *
+   * @description 解密加密的数据
+   * @param {import('@abtnode/client').BlockletState} blocklet
+   * @return {import('@abtnode/client').BlockletState}
+   * @memberof BlockletRestore
+   */
+  decrypt(blocklet, params) {
+    const { password } = this.input;
+    if (Array.isArray(blocklet.migratedFrom)) {
+      blocklet.migratedFrom = blocklet.migratedFrom.map((x) => {
+        x.appSk = security.decrypt(x.appSk, params.salt, password);
+        return x;
+      });
+    }
+
+    return blocklet;
+  }
+
+  getImportParams() {
+    return { salt: this.getBlocklet().appDid };
+  }
+}
+
+module.exports = { BlockletRestore };

package/lib/blocklet/storage/restore/blocklets.js

@@ -1,4 +1,4 @@
-const { existsSync, remove } = require('fs-extra');
+const { existsSync, remove, ensureDirSync } = require('fs-extra');
 const { join } = require('path');
 const fg = require('fast-glob');
 const { BaseRestore } = require('./base');
@@ -8,10 +8,13 @@ class BlockletsRestore extends BaseRestore {
   filename = 'blocklets';
 
   async import() {
-    const blockletsDir = join(this.blockletRestoreDir, this.filename);
+    const blockletsDir = join(this.restoreDir, this.filename);
 
+    // blockletsDir 可以不存在, 因为还原的 blocklet 可能所有的组件都是来自 store 的
     if (!existsSync(blockletsDir)) {
-      throw new Error(`dir not found: ${blockletsDir}`);
+      // FIXME: 如果文件夹不存在，需要创建文件夹，因为 installFromBackup 未做容错处理
+      ensureDirSync(blockletsDir);
+      return;
     }
 
     const paths = await fg('**/*.zip', {

package/lib/blocklet/storage/restore/logs.js

@@ -7,13 +7,13 @@ class LogsRestore extends BaseRestore {
   filename = 'logs.zip';
 
   async import() {
-    const blockletZipPath = join(this.blockletRestoreDir, this.filename);
+    const blockletZipPath = join(this.restoreDir, this.filename);
 
     if (!existsSync(blockletZipPath)) {
       throw new Error(`file not found: ${blockletZipPath}`);
     }
 
-    await zipToDir(blockletZipPath, join(this.blockletRestoreDir, 'logs'));
+    await zipToDir(blockletZipPath, join(this.restoreDir, 'logs'));
     removeSync(blockletZipPath);
   }
 }

package/lib/blocklet/storage/restore/spaces.js

@@ -1,17 +1,27 @@
 /**
  * @typedef {{
+ *  appDid: string;
  *  endpoint: string;
- *  blockletSecretKey: string;
+ *  password: Buffer;
+ *  delegation: string;
+ *  wallet: import('@ocap/wallet').WalletObject;
+ *  event: import('events').EventEmitter,
+ *  userDid: string,
+ *  referrer: string,
  * }} SpaceRestoreInput
  */
 
-const { SpaceClient, SyncFolderPullCommand } = require('@did-space/client');
-const { types } = require('@ocap/mcrypto');
-const { fromSecretKey, WalletType } = require('@ocap/wallet');
-const { ensureDirSync, existsSync, rmdirSync } = require('fs-extra');
-const { join } = require('path');
 const validUrl = require('valid-url');
+const merge = require('lodash/merge');
+const { BlockletEvents } = require('@blocklet/constant');
+const { SpaceClient, RestoreBlockletCommand } = require('@did-space/client');
+const { ensureDirSync, existsSync, rmdirSync } = require('fs-extra');
+const { join, basename } = require('path');
+
+const logger = require('@abtnode/logger')('@abtnode/core:storage:restore');
+
 const { BlockletExtrasRestore } = require('./blocklet-extras');
+const { BlockletRestore } = require('./blocklet');
 const { BlockletsRestore } = require('./blocklets');
 
 class SpacesRestore {
@@ -27,7 +37,7 @@ class SpacesRestore {
    * @type {string}
    * @memberof SpacesRestore
    */
-  blockletRestoreDir;
+  restoreDir;
 
   /**
    *
@@ -35,15 +45,7 @@ class SpacesRestore {
    * @type {string}
    * @memberof SpacesRestore
    */
-  serverDataDir;
-
-  /**
-   *
-   * @description spaces 的 endpoint
-   * @type {import('@ocap/wallet').WalletObject}
-   * @memberof SpacesRestore
-   */
-  blockletWallet;
+  serverDir;
 
   storages;
 
@@ -55,7 +57,11 @@ class SpacesRestore {
   constructor(input) {
     this.verify(input);
     this.input = input;
-    this.storages = [new BlockletExtrasRestore(this.input), new BlockletsRestore(this.input)];
+    this.storages = [
+      new BlockletExtrasRestore(this.input),
+      new BlockletRestore(this.input),
+      new BlockletsRestore(this.input),
+    ];
   }
 
   /**
@@ -68,72 +74,80 @@ class SpacesRestore {
     if (!validUrl.isWebUri(input.endpoint)) {
       throw new Error(`endpoint(${input.endpoint}) must be a WebUri`);
     }
+    if (!input.endpoint.includes(input.appDid)) {
+      throw new Error(`endpoint and blocklet.appDid(${input.appDid}) do not match`);
+    }
   }
 
   async initialize() {
-    this.serverDataDir = process.env.ABT_NODE_DATA_DIR;
-    this.blockletWallet = await this.getBlockletWallet();
-
-    if (!this.input.endpoint.includes(this.blockletWallet.address)) {
-      throw new Error(`endpoint and blocklet.appDid(${this.blockletWallet.address}) do not match`);
+    this.serverDir = process.env.ABT_NODE_DATA_DIR;
+    this.restoreDir = join(this.serverDir, 'tmp/restore', this.input.appDid);
+    if (existsSync(this.restoreDir)) {
+      rmdirSync(this.restoreDir, { recursive: true });
     }
+    ensureDirSync(this.restoreDir);
 
-    this.blockletRestoreDir = join(process.env.ABT_NODE_DATA_DIR, 'tmp/restore', this.blockletWallet.address);
-    if (existsSync(this.blockletRestoreDir)) {
-      rmdirSync(this.blockletRestoreDir, { recursive: true });
-    }
-    ensureDirSync(this.blockletRestoreDir);
+    this.storages.map((x) => x.ensureParams(this));
   }
 
-  /**
-   *
-   * @returns {Promise<void>}
-   * @memberof SpacesRestore
-   */
   async restore() {
     await this.initialize();
     await this.syncFromSpaces();
-    await this.import();
-  }
 
-  async getBlockletWallet() {
-    // @FIXME: blocklet 钱包类型如何得知呢？
-    const wallet = fromSecretKey(this.input.blockletSecretKey, WalletType({ role: types.RoleType.ROLE_APPLICATION }));
+    const params = await Promise.all(this.storages.map((x) => x.getImportParams()));
+    await this.import(merge(...params));
 
-    return wallet;
+    return this.storages.map((x) => x.getInstallParams());
   }
 
   async syncFromSpaces() {
-    const { endpoint } = this.input;
-    const wallet = await this.getBlockletWallet();
+    const { endpoint, wallet, delegation } = this.input;
 
     const spaceClient = new SpaceClient({
       endpoint,
+      delegation,
       wallet,
     });
 
-    const { errorCount } = await spaceClient.send(
-      new SyncFolderPullCommand({
-        source: join('.did-objects', this.blockletWallet.address, '/'),
-        target: this.blockletRestoreDir,
+    const { errorCount, message } = await spaceClient.send(
+      new RestoreBlockletCommand({
+        appDid: this.input.appDid,
+        target: join(this.restoreDir, '/'),
         debug: true,
-        concurrency: 64,
-        retryCount: 100,
+        concurrency: 32,
+        retryCount: 10,
+        onProgress: (data) => {
+          logger.info('restore progress', { appDid: this.input.appDid, data });
+          this.input.event.emit(BlockletEvents.restoreProgress, {
+            appDid: this.input.appDid,
+            message: `Downloaded file ${basename(data.key)} (${data.completed}/${data.total})`,
+          });
+        },
+
+        userDid: this.input.userDid,
+        referrer: this.input.referrer,
       })
     );
 
     if (errorCount !== 0) {
-      throw new Error(`Sync from spaces encountered ${errorCount} error`);
+      throw new Error(`Sync from spaces encountered error: ${message}`);
     }
   }
 
-  async import() {
+  async import(params) {
+    this.input.event.emit(BlockletEvents.restoreProgress, {
+      appDid: this.input.appDid,
+      message: 'Preparing to import data...',
+    });
     await Promise.all(
       this.storages.map((storage) => {
-        storage.ensureParams(this);
-        return storage.import();
+        return storage.import(params);
       })
     );
+    this.input.event.emit(BlockletEvents.restoreProgress, {
+      appDid: this.input.appDid,
+      message: 'Importing data successfully...',
+    });
   }
 }
 

package/lib/event.js

@@ -81,7 +81,7 @@ module.exports = ({
     }
   };
 
-  const handleBlockletAdd = async (name, { blocklet, context }) => {
+  const handleBlockletInstall = async (name, { blocklet, context }) => {
     try {
       const changed = await ensureBlockletRouting(blocklet, context);
       if (changed) {
@@ -169,11 +169,17 @@ module.exports = ({
     });
   };
 
+  /**
+   *
+   * @description 事件必须注册在这里才能被发布出去
+   * @param {string} eventName
+   * @param {any} payload
+   */
   const handleBlockletEvent = async (eventName, payload) => {
     const blocklet = payload.blocklet || payload;
 
     if ([BlockletEvents.installed].includes(eventName)) {
-      await handleBlockletAdd(eventName, payload);
+      await handleBlockletInstall(eventName, payload);
 
       try {
         await node.createAuditLog({
@@ -236,6 +242,14 @@ module.exports = ({
       );
 
       logger.info('take snapshot after updated blocklet app', { event: eventName, did: blocklet.meta.did, hash });
+    } else if (BlockletEvents.spaceConnected === eventName) {
+      nodeState
+        .read()
+        .then((info) => handleRouting(info))
+        .catch((err) => {
+          logger.error('Reload gateway failed on blocklet.connectedSpace', { error: err });
+        });
+      logger.info('Reload gateway after blocklet connected to space', { event: eventName, did: blocklet.appDid });
     }
 
     if (
@@ -273,6 +287,13 @@ module.exports = ({
     }
   };
 
+  /**
+   *
+   *
+   * @param {*} subject
+   * @param {string} event
+   * @param {(event: string, data: any) => Promise<void> | void} handler
+   */
   const listen = (subject, event, handler) => subject.on(event, (data) => handler(event, data));
 
   [
@@ -291,6 +312,11 @@ module.exports = ({
     BlockletEvents.startFailed,
     BlockletEvents.stopped,
     BlockletEvents.appDidChanged,
+
+    BlockletEvents.backupProgress,
+    BlockletEvents.restoreProgress,
+
+    BlockletEvents.spaceConnected,
   ].forEach((eventName) => {
     listen(blockletManager, eventName, handleBlockletEvent);
   });

package/lib/index.js

@@ -26,7 +26,7 @@ const Maintain = require('./util/maintain');
 const resetNode = require('./util/reset-node');
 const DiskMonitor = require('./util/disk-monitor');
 const StoreUtil = require('./util/store');
-const createQueue = require('./queue');
+const createQueue = require('./util/queue');
 const createEvents = require('./event');
 const pm2Events = require('./blocklet/manager/pm2-events');
 const { createStateReadyQueue, createStateReadyHandler } = require('./util/ready');
@@ -99,7 +99,25 @@ function ABTNode(options) {
       concurrency,
       maxRetries: 3,
       retryDelay: 5000, // retry after 5 seconds
-      maxTimeout: 60 * 1000 * 15, // throw timeout error after 5 minutes
+      maxTimeout: 60 * 1000 * 15, // throw timeout error after 15 minutes
+      id: (job) => (job ? md5(`${job.entity}-${job.action}-${job.id}`) : ''),
+    },
+  });
+
+  const backupQueue = createQueue({
+    daemon: options.daemon,
+    name: 'backup_queue',
+    dataDir: dataDirs.core,
+    onJob: async (job) => {
+      if (typeof blockletManager.onJob === 'function') {
+        await blockletManager.onJob(job);
+      }
+    },
+    options: {
+      concurrency,
+      maxRetries: 3,
+      retryDelay: 10000, // retry after 10 seconds
+      maxTimeout: 60 * 1000 * 30, // throw timeout error after 30 minutes
       id: (job) => (job ? md5(`${job.entity}-${job.action}-${job.id}`) : ''),
     },
   });
@@ -129,6 +147,7 @@ function ABTNode(options) {
     dataDirs,
     startQueue,
     installQueue,
+    backupQueue,
     daemon: options.daemon,
     teamManager,
   });
@@ -192,7 +211,6 @@ function ABTNode(options) {
 
     // Blocklet manager
     installBlocklet: blockletManager.install.bind(blockletManager),
-    installBlockletFromVc: blockletManager.installBlockletFromVc.bind(blockletManager),
     installComponent: blockletManager.installComponent.bind(blockletManager),
     startBlocklet: blockletManager.start.bind(blockletManager),
     stopBlocklet: blockletManager.stop.bind(blockletManager),

package/lib/router/helper.js

@@ -3,6 +3,7 @@
 const fs = require('fs-extra');
 const path = require('path');
 const tar = require('tar');
+const isUrl = require('is-url');
 const get = require('lodash/get');
 const cloneDeep = require('lodash/cloneDeep');
 const isEqual = require('lodash/isEqual');
@@ -26,7 +27,6 @@ const {
   NAME_FOR_WELLKNOWN_SITE,
   DEFAULT_HTTP_PORT,
   DEFAULT_HTTPS_PORT,
-  NODE_MODES,
   ROUTING_RULE_TYPES,
   CERTIFICATE_EXPIRES_OFFSET,
   DEFAULT_SERVICE_PATH,
@@ -44,6 +44,7 @@ const {
   BLOCKLET_INTERFACE_PUBLIC,
   BLOCKLET_INTERFACE_WELLKNOWN,
   BLOCKLET_INTERFACE_TYPE_WELLKNOWN,
+  BLOCKLET_CONFIGURABLE_KEY,
   BlockletEvents,
   BLOCKLET_MODES,
 } = require('@blocklet/constant');
@@ -56,6 +57,7 @@ const {
   findInterfacePortByName,
   getWellknownSitePort,
   getServerDidDomain,
+  isGatewayCacheEnabled,
 } = require('../util');
 const { getIpDnsDomainForBlocklet, getDidDomainForBlocklet } = require('../util/get-domain-for-blocklet');
 const { getFromCache: getAccessibleExternalNodeIp } = require('../util/get-accessible-external-node-ip');
@@ -122,7 +124,7 @@ const addCorsToSite = (site, rawUrl) => {
       site.corsAllowedOrigins.push(url.hostname);
     }
   } catch (err) {
-    // Do nothing
+    console.error('addCorsToSite', err);
   }
 };
 
@@ -336,6 +338,22 @@ const ensureCorsForWebWallet = async (sites) => {
   return sites;
 };
 
+const ensureCorsForDidSpace = async (sites = [], blocklets) => {
+  return sites.map((site) => {
+    const blocklet = blocklets.find((x) => x.meta.did === site.blockletDid);
+    if (blocklet) {
+      const endpoint = blocklet.environments.find(
+        (x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SPACE_ENDPOINT
+      );
+      if (endpoint && isUrl(endpoint.value)) {
+        addCorsToSite(site, endpoint.value);
+      }
+    }
+
+    return site;
+  });
+};
+
 const filterSitesForRemovedBlocklets = async (sites = [], blocklets) => {
   return sites.filter((site) => {
     if (!site.domain.endsWith(BLOCKLET_SITE_GROUP_SUFFIX)) {
@@ -382,7 +400,7 @@ const ensureBlockletCache = async (sites = [], blocklets) => {
             const clone = cloneDeep(rule);
             clone.from.pathPrefix = joinUrl(rule.from.pathPrefix, cachePrefix);
             clone.to.cacheGroup = 'blockletProxy';
-            clone.to.target = cachePrefix;
+            clone.to.targetPrefix = cachePrefix;
             clone.dynamic = true; // mark as dynamic to avoid redundant generated rules
             cacheRules.push(clone);
           });
@@ -407,6 +425,7 @@ const ensureLatestInfo = async (sites = [], { withDefaultCors = true } = {}) =>
   result = await ensureBlockletCache(result, blocklets);
   result = await ensureWellknownRule(result);
   result = await ensureCorsForWebWallet(result);
+  result = await ensureCorsForDidSpace(result, blocklets);
   result = await ensureLatestInterfaceInfo(result);
 
   return result;
@@ -518,7 +537,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
     const ensureDomainCert = async (domain, url) => {
       const cert = await certManager.getByDomain(domain);
-      if (!cert) {
+      if (!cert || get(cert, 'meta.validTo') <= Date.now()) {
         await downloadCert({
           domain,
           url,
@@ -1115,7 +1134,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
           configDir: path.join(dataDirs.router, providerName),
           httpPort: nodeInfo.routing.httpPort || DEFAULT_HTTP_PORT,
           httpsPort: nodeInfo.routing.httpsPort || DEFAULT_HTTPS_PORT,
-          cacheDisabled: nodeInfo.mode === NODE_MODES.DEBUG,
+          cacheEnabled: isGatewayCacheEnabled(nodeInfo),
         }),
         getRoutingParams: async () => {
           try {
@@ -1220,7 +1239,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
             configDir: path.join(dataDirs.router, info.routing.provider),
             httpPort: info.routing.httpPort || DEFAULT_HTTP_PORT,
             httpsPort: info.routing.httpsPort || DEFAULT_HTTPS_PORT,
-            cacheDisabled: info.mode === NODE_MODES.DEBUG,
+            cacheEnabled: isGatewayCacheEnabled(info),
           });
           await providerInstance.stop();
           logger.info('original router stopped:', { provider: info.routing.provider });
@@ -1408,6 +1427,8 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     deleteRoutingRule,
     addDomainAlias,
     deleteDomainAlias,
+
+    isGatewayCacheEnabled,
   };
 };
 

package/lib/router/index.js

@@ -11,8 +11,11 @@ const {
   GATEWAY_REQ_LIMIT,
 } = require('@abtnode/constant');
 const { BLOCKLET_UI_INTERFACES, BLOCKLET_MODES } = require('@blocklet/constant');
+
 const logger = require('@abtnode/logger')('@abtnode/core:router');
 
+const { isGatewayCacheEnabled } = require('../util');
+
 const expandSites = (sites = []) => {
   const result = [];
 
@@ -117,6 +120,7 @@ class Router {
       services,
       nodeInfo: pick(nodeInfo, ['name', 'version', 'port', 'mode', 'enableWelcomePage', 'routing']),
       requestLimit,
+      cacheEnabled: isGatewayCacheEnabled(nodeInfo),
     });
   }
 
@@ -183,6 +187,10 @@ Router.formatSites = (sites = []) => {
   result.forEach((site) => {
     if (Array.isArray(site.rules) && site.rules.length > 0) {
       const rules = cloneDeep(site.rules);
+
+      let hasRootPathBlockletRule = false;
+      let tmpBlockletRule;
+
       rules.forEach((rule) => {
         if ([ROUTING_RULE_TYPES.BLOCKLET].includes(rule.to.type) === false) {
           return;
@@ -197,6 +205,11 @@ Router.formatSites = (sites = []) => {
         }
 
         if (daemonRule) {
+          if (rule.from.pathPrefix === '/') {
+            hasRootPathBlockletRule = true;
+          }
+          tmpBlockletRule = rule;
+
           // Serve meta js: both prefix and suffix do not contain trailing slash
           // NOTICE: 这里隐含了一个约定
           //   如果安装的 blockletA 和 blockletB 都需要 __blocklet__.js
@@ -244,6 +257,24 @@ Router.formatSites = (sites = []) => {
           });
         }
       });
+
+      // ensure /__blocklet__.js should be proxy to daemon
+      if (daemonRule && !hasRootPathBlockletRule && tmpBlockletRule) {
+        site.rules.push({
+          from: {
+            pathPrefix: '/',
+            groupPathPrefix: '/',
+            pathSuffix: '/__blocklet__.js',
+          },
+          to: {
+            type: ROUTING_RULE_TYPES.DAEMON,
+            port: daemonRule.to.port,
+            did: tmpBlockletRule.to.did,
+            componentId: tmpBlockletRule.to.did,
+            cacheGroup: site.mode === BLOCKLET_MODES.PRODUCTION ? 'blockletJs' : '',
+          },
+        });
+      }
     }
   });
 

package/lib/states/audit-log.js

@@ -239,9 +239,11 @@ const getLogContent = async (action, args, context, result, info, node) => {
     case 'deleteRoutingRule':
       return `deleted routing rule from ${site}`; // prettier-ignore
     case 'updateGateway': {
-      let message = args.requestLimit.enabled ? `status: enabled, rate: ${args.requestLimit.rate}` : 'status: disabled';
-      message = `update gateway. ${message}`;
-
+      const changes = [
+        args.requestLimit.enabled ? `rate limit: enabled, rate: ${args.requestLimit.rate}` : 'rate limit: disabled',
+        args.cacheEnabled ? `global cache: enabled, rate: ${args.cacheEnabled}` : 'global cache: disabled',
+      ];
+      const message = `update gateway: ${changes.join('; ')}`;
       return message;
     }
     case 'createTransferInvitation':

package/lib/states/blocklet.js

@@ -28,6 +28,7 @@ const lock = new Lock('blocklet-port-assign-lock');
 
 const isHex = (str) => /^0x[0-9a-f]+$/i.test(str);
 const getMaxPort = (ports = {}) => Math.max(Object.values(ports).map(Number));
+const getConditions = (did) => [{ 'meta.did': did }, { appDid: did }, { appPid: did }];
 
 const getExternalPortsFromMeta = (meta) =>
   (meta.interfaces || []).map((x) => x.port && x.port.external).filter(Boolean);
@@ -48,7 +49,16 @@ const formatBlocklet = (blocklet, phase, dek) => {
       return;
     }
 
-    ['BLOCKLET_APP_SK'].forEach((key) => {
+    (Array.isArray(b.migratedFrom) ? b.migratedFrom : []).forEach((x) => {
+      if (phase === 'onUpdate' && isHex(x.appSk) === true) {
+        x.appSk = security.encrypt(x.appSk, b.meta.did, dek);
+      }
+      if (phase === 'onRead' && isHex(x.appSk) === false) {
+        x.appSk = security.decrypt(x.appSk, b.meta.did, dek);
+      }
+    });
+
+    ['BLOCKLET_APP_SK', 'BLOCKLET_APP_PSK'].forEach((key) => {
       const env = b.environments.find((x) => x.key === key);
       if (!env) {
         return;
@@ -98,7 +108,7 @@ class BlockletState extends BaseState {
         resolve(null);
       }
 
-      this.findOne({ $or: [{ 'meta.did': did }, { appDid: did }] }, (err, doc) => {
+      this.findOne({ $or: getConditions(did) }, (err, doc) => {
         if (err) {
           return reject(err);
         }
@@ -114,7 +124,7 @@ class BlockletState extends BaseState {
         resolve(null);
       }
 
-      this.findOne({ $or: [{ 'meta.did': did }, { appDid: did }] }, (err, doc) => {
+      this.findOne({ $or: getConditions(did) }, (err, doc) => {
         if (err) {
           return reject(err);
         }
@@ -130,7 +140,7 @@ class BlockletState extends BaseState {
         resolve(null);
       }
 
-      this.findOne({ $or: [{ 'meta.did': did }, { appDid: did }] }, { status: 1 }, (err, doc) => {
+      this.findOne({ $or: getConditions(did) }, { status: 1 }, (err, doc) => {
         if (err) {
           return reject(err);
         }
@@ -146,7 +156,7 @@ class BlockletState extends BaseState {
         resolve(false);
       }
 
-      this.count({ $or: [{ 'meta.did': did }, { appDid: did }] }, (err, count) => {
+      this.count({ $or: getConditions(did) }, (err, count) => {
         if (err) {
           return reject(err);
         }
@@ -199,6 +209,9 @@ class BlockletState extends BaseState {
     deployedFrom = '',
     mode = BLOCKLET_MODES.PRODUCTION,
     children: rawChildren = [],
+    appPid = null, // the permanent appDid, which will not change after initial set
+    migratedFrom = [], // the complete migrate history
+    externalSk = false, // whether sk is managed by some party beside server, such as did-wallet
   } = {}) {
     return this.getBlocklet(meta.did).then(
       (exist) =>
@@ -229,6 +242,7 @@ class BlockletState extends BaseState {
 
             const data = {
               appDid: null, // will updated later when updating blocklet environments
+              appPid,
               mode,
               meta: sanitized,
               status,
@@ -237,6 +251,8 @@ class BlockletState extends BaseState {
               ports,
               environments: [],
               children,
+              migratedFrom,
+              externalSk,
             };
 
             // add to db