@abtnode/core 1.8.64-beta-b3d407e0 → 1.8.64-beta-0b5ede51

package/lib/api/team.js

@@ -408,6 +408,26 @@ class TeamAPI extends EventEmitter {
 
   // Invite member
 
+  /**
+   * @type InvitationSession {
+   *   type: 'invite';
+   *   role: string;
+   *   remark: string;
+   *   expireDate: number;
+   *   inviter: {
+   *     did: string;
+   *     email?: string;
+   *     fullName?: string;
+   *     role?: string;
+   *   };
+   *   teamDid: string;
+   *   status: '' | 'success';
+   *   receiver: {
+   *     did: string;
+   *   };
+   * }
+   * @returns
+   */
   async createMemberInvitation({ teamDid, role, expireTime, remark }, context) {
     await this.teamManager.checkEnablePassportIssuance(teamDid);
 
@@ -484,15 +504,17 @@ class TeamAPI extends EventEmitter {
       expireDate: new Date(invitation.expireDate).toString(),
       inviter: invitation.inviter,
       teamDid: invitation.teamDid,
+      status: invitation.status,
+      receiver: invitation.receiver,
     };
   }
 
-  async getInvitations({ teamDid }) {
+  async getInvitations({ teamDid, filter }) {
     const state = await this.getSessionState(teamDid);
 
     const invitations = await state.find({ type: 'invite' });
 
-    return invitations.map((d) => ({
+    return invitations.filter(filter || ((x) => x.status !== 'success')).map((d) => ({
       // eslint-disable-next-line no-underscore-dangle
       inviteId: d._id,
       role: d.role,
@@ -500,6 +522,8 @@ class TeamAPI extends EventEmitter {
       expireDate: new Date(d.expireDate).toString(),
       inviter: d.inviter,
       teamDid: d.teamDid,
+      status: d.status,
+      receiver: d.receiver,
     }));
   }
 
@@ -516,7 +540,7 @@ class TeamAPI extends EventEmitter {
     return true;
   }
 
-  async processInvitation({ teamDid, inviteId }) {
+  async checkInvitation({ teamDid, inviteId }) {
     const state = await this.getSessionState(teamDid);
 
     const invitation = await state.read(inviteId);
@@ -538,16 +562,33 @@ class TeamAPI extends EventEmitter {
       throw new Error(`Role does not exist: ${role}`);
     }
 
-    await state.end(inviteId);
-
-    logger.info('Invitation session completed successfully', { inviteId, role });
-
     return {
       role,
       remark,
     };
   }
 
+  async closeInvitation({ teamDid, inviteId, status, receiver, timeout = 30 * 1000 }) {
+    const state = await this.getSessionState(teamDid);
+
+    const invitation = await state.read(inviteId);
+
+    if (!invitation) {
+      throw new Error(`The invitation does not exist: ${inviteId}`);
+    }
+
+    await state.update(inviteId, { status, receiver });
+
+    setTimeout(async () => {
+      try {
+        logger.info('Invitation session closed', { inviteId });
+        await state.end(inviteId);
+      } catch (error) {
+        logger.error('close invitation failed', { error });
+      }
+    }, timeout);
+  }
+
   // Issue Passport
 
   async createPassportIssuance({ teamDid, ownerDid, name }) {

package/lib/blocklet/manager/disk.js

@@ -134,6 +134,8 @@ const handleInstanceInStore = require('../../util/public-to-store');
 const { getNFTState, getServerDidDomain } = require('../../util');
 const { BlockletRuntimeMonitor } = require('../../monitor/blocklet-runtime-monitor');
 const getHistoryList = require('../../monitor/get-history-list');
+const { SpacesBackup } = require('../storage/backup/spaces');
+const { SpacesRestore } = require('../storage/restore/spaces');
 const installFromBackup = require('./helper/install-from-backup');
 
 const {
@@ -609,6 +611,35 @@ class BlockletManager extends BaseBlockletManager {
     return blocklet;
   }
 
+  /**
+   *
+   *
+   * @param {import('@abtnode/client').BackupToSpacesParams} input
+   * @memberof BlockletManager
+   */
+  async backupToSpaces(input) {
+    const spacesBackup = new SpacesBackup(input);
+    await spacesBackup.backup();
+  }
+
+  /**
+   *
+   *
+   * @param {import('@abtnode/client').RequestRestoreFromSpacesInput} input
+   * @memberof BlockletManager
+   */
+  async restoreFromSpaces(input) {
+    const spacesRestore = new SpacesRestore(input);
+    await spacesRestore.restore();
+
+    // FIXME: 需要改成队列执行，本次失败，下次还需要重试，页面刷新后也能知道最新的状态
+    await this._installFromBackup({
+      url: `file://${spacesRestore.blockletRestoreDir}`,
+      blockletSecretKey: spacesRestore.blockletWallet.secretKey,
+      moveDir: true,
+    });
+  }
+
   async restart({ did }, context) {
     logger.info('restart blocklet', { did });
 
@@ -1617,6 +1648,11 @@ class BlockletManager extends BaseBlockletManager {
    *  /data
    *  /blocklet.json
    *  /blocklet_extras.json
+   * @see Blocklet 端到端备份方案的设计与实现（一期） https://team.arcblock.io/comment/discussions/e62084d5-fafa-489e-91d5-defcd6e93223
+   * @param {{ url: string, blockletSecretKey: string, moveDir: boolean}} [{ url }={}]
+   * @param {Record<string, string>} [context={}]
+   * @return {Promise<any>}
+   * @memberof BlockletManager
    */
   async _installFromBackup({ url, blockletSecretKey, moveDir } = {}, context = {}) {
     return installFromBackup({ url, blockletSecretKey, moveDir, context, manager: this, states });
@@ -2090,10 +2126,9 @@ class BlockletManager extends BaseBlockletManager {
 
     if (controller?.nftId) {
       // sometimes nedb will throw error if use states.blocklet.count({ ['controller.nftId']: controller.nftId })
-      const blocklets = await states.blocklet.find({}, { controller: 1 });
-      const count = blocklets.filter((x) => x.controller?.nftId === controller.nftId).length;
+      const installedCount = await states.blockletExtras.count({ 'controller.nftId': controller.nftId });
 
-      if (count >= (controller.appMaxCount || 1)) {
+      if (installedCount >= (controller.appMaxCount || 1)) {
         throw new Error(
           `You can only install ${controller.appMaxCount} blocklet with this credential: ${controller.nftId}`
         );
@@ -2691,7 +2726,6 @@ class BlockletManager extends BaseBlockletManager {
         source,
         deployedFrom,
         children,
-        controller,
       });
 
       await validateBlocklet(blocklet);
@@ -3798,7 +3832,8 @@ class BlockletManager extends BaseBlockletManager {
 
   async _createNotification(did, notification) {
     try {
-      const isExternal = await states.blocklet.isExternalBlocklet(did);
+      const extra = await states.blockletExtras.getMeta(did);
+      const isExternal = !!extra?.controller;
 
       if (isExternal) {
         return;

package/lib/blocklet/storage/backup/audit-log.js

@@ -0,0 +1,27 @@
+const { removeSync, outputJsonSync } = require('fs-extra');
+const { join } = require('path');
+const states = require('../../../states');
+const { BaseBackup } = require('./base');
+
+/**
+ *
+ *
+ * @class AuditLogBackup
+ */
+class AuditLogBackup extends BaseBackup {
+  filename = 'audit-log.json';
+
+  async export() {
+    /**
+     * @type {import('@abtnode/client').AuditLog}
+     */
+    const auditLogs = await states.auditLog.find({
+      scope: this.blocklet.meta.did,
+    });
+
+    removeSync(join(this.blockletBackupDir, this.filename));
+    outputJsonSync(join(this.blockletBackupDir, this.filename), auditLogs);
+  }
+}
+
+module.exports = { AuditLogBackup };

package/lib/blocklet/storage/backup/base.js

@@ -0,0 +1,63 @@
+class BaseBackup {
+  /**
+   *
+   * @type {import('./spaces').SpaceBackupInput}
+   * @memberof BaseBackup
+   */
+  input;
+
+  /**
+   * @description blocklet state 对象
+   * @type {import('@abtnode/client').BlockletState}
+   * @memberof BaseBackup
+   */
+  blocklet;
+
+  /**
+   * @description 当前 blocklet 的数据目录
+   * @type {string}
+   * @memberof BaseBackup
+   */
+  blockletBackupDir;
+
+  /**
+   *
+   * @description spaces 的 endpoint
+   * @type {import('@ocap/wallet').WalletObject}
+   * @memberof BaseBackup
+   */
+  blockletWallet;
+
+  /**
+   *
+   * @description server 的数据目录
+   * @type {string}
+   * @memberof BaseBackup
+   */
+  serverDataDir;
+
+  constructor(input) {
+    this.input = input;
+  }
+
+  /**
+   *
+   *
+   * @param {import('./spaces').SpacesBackup} spacesBackup
+   * @memberof BaseBackup
+   */
+  ensureParams(spacesBackup) {
+    this.blocklet = spacesBackup.blocklet;
+    this.serverDataDir = spacesBackup.serverDataDir;
+    this.blockletBackupDir = spacesBackup.blockletBackupDir;
+    this.blockletWallet = spacesBackup.blockletWallet;
+  }
+
+  async export() {
+    throw new Error('not implemented');
+  }
+}
+
+module.exports = {
+  BaseBackup,
+};

package/lib/blocklet/storage/backup/blocklet-extras.js

@@ -0,0 +1,105 @@
+const { removeSync, outputJsonSync, readFileSync } = require('fs-extra');
+const { isEmpty, cloneDeep } = require('lodash');
+const { join } = require('path');
+const security = require('@abtnode/util/lib/security');
+const { BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/constant');
+const states = require('../../../states');
+const { BaseBackup } = require('./base');
+
+class BlockletExtrasBackup extends BaseBackup {
+  filename = 'blocklet-extras.json';
+
+  async export() {
+    const blockletExtra = await this.getBlockletExtra();
+    removeSync(join(this.blockletBackupDir, this.filename));
+    outputJsonSync(join(this.blockletBackupDir, this.filename), blockletExtra);
+  }
+
+  /**
+   *
+   * @description
+   * @return {Promise<import('@abtnode/client').BlockletState>}
+   * @memberof BlockletExtrasBackup
+   */
+  async getBlockletExtra() {
+    /**
+     * @type {import('@abtnode/client').BlockletState}
+     */
+    const blockletExtra = await states.blockletExtras.findOne({
+      did: this.blocklet.meta.did,
+    });
+    if (isEmpty(blockletExtra)) {
+      throw new Error('blockletExtra cannot be empty');
+    }
+
+    return this.cleanDate(blockletExtra);
+  }
+
+  /**
+   *
+   * @description 清理数据并加密
+   * @param {import('@abtnode/client').BlockletState} blockletExtraInput
+   * @return {Promise<void>}
+   * @memberof BlockletExtrasBackup
+   */
+  async cleanDate(blockletExtraInput) {
+    const blockletExtra = cloneDeep(blockletExtraInput);
+
+    const queue = [blockletExtra];
+    while (queue.length) {
+      const currentBlockletExtra = queue.pop();
+
+      // 删除父 blocklet 的某些数据
+      if (currentBlockletExtra._id) {
+        delete currentBlockletExtra._id;
+        delete currentBlockletExtra.createdAt;
+        delete currentBlockletExtra.updatedAt;
+      }
+
+      // 加解密
+      this.useBlockletEncryptConfigs(currentBlockletExtra.configs);
+
+      if (currentBlockletExtra?.children) {
+        queue.push(...currentBlockletExtra.children);
+      }
+    }
+
+    return blockletExtra;
+  }
+
+  /**
+   *
+   * @description 清理数据并加密
+   * @param {import('@abtnode/client').ConfigEntry[]} configs
+   * @return {void}
+   * @memberof BlockletExtrasBackup
+   */
+  useBlockletEncryptConfigs(configs) {
+    // 准备加解密所需的参数
+    // @see: https://github.com/ArcBlock/blocklet-server/blob/f561ba7290285f2e23dccb6d5323eb4d43c3cc3e/core/state/lib/index.js#L59
+    const dek = readFileSync(join(this.serverDataDir, '.sock'));
+
+    for (const config of configs) {
+      // 置空 blocklet 的密钥，但是保留其他属性，这很重要
+      if (config.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK) {
+        config.value = '';
+      } else if (config.secure) {
+        // secure 为 true 的配置才需要被加密保存上次到 did spaces
+
+        const encryptByServer = config.value;
+        // 先从 blocklet server 解密
+        // @see https://github.com/ArcBlock/blocklet-server/blob/f40338168a66893f325464cea79ae54c43f623b1/core/state/lib/blocklet/extras.js#L139
+        const decryptByServer = security.decrypt(encryptByServer, this.blocklet.meta.did, dek);
+        // 再用 blocklet secret 加密，然后才可以上传到 spaces
+        const encryptByBlocklet = security.encrypt(
+          decryptByServer,
+          this.blockletWallet.address,
+          Buffer.from(this.blockletWallet.secretKey)
+        );
+        config.value = encryptByBlocklet;
+      }
+    }
+  }
+}
+
+module.exports = { BlockletExtrasBackup };

package/lib/blocklet/storage/backup/blocklet.js

@@ -0,0 +1,53 @@
+const { removeSync, outputJsonSync } = require('fs-extra');
+const { cloneDeep } = require('lodash');
+const { join } = require('path');
+const { BaseBackup } = require('./base');
+
+class BlockletBackup extends BaseBackup {
+  filename = 'blocklet.json';
+
+  async export() {
+    const blocklet = await this.cleanData();
+    removeSync(join(this.blockletBackupDir, this.filename));
+    outputJsonSync(join(this.blockletBackupDir, this.filename), blocklet);
+  }
+
+  /**
+   * @description 清理数据
+   * @see blocklet.db 中需要删除哪些字段呢？ https://github.com/ArcBlock/blocklet-server/issues/6120#issuecomment-1383798348
+   * @return {Promise<void>}
+   * @memberof BlockletBackup
+   */
+  async cleanData() {
+    const originalBlocklet = cloneDeep(this.blocklet);
+
+    /** @type {import('@abtnode/client').ComponentState[]} */
+    const queue = [originalBlocklet];
+
+    // 广度优先遍历
+    while (queue.length) {
+      const currentBlocklet = queue.pop();
+
+      // 父组件才需要删除的属性
+      if (currentBlocklet._id) {
+        delete currentBlocklet._id;
+        delete currentBlocklet.createdAt;
+        delete currentBlocklet.startedAt;
+        delete currentBlocklet.installedAt;
+      }
+
+      // 子组件和父组件都需要删除的属性
+      delete currentBlocklet.status;
+      delete currentBlocklet.ports;
+      delete currentBlocklet.environments;
+
+      if (currentBlocklet.children) {
+        queue.push(...currentBlocklet.children);
+      }
+    }
+
+    return originalBlocklet;
+  }
+}
+
+module.exports = { BlockletBackup };

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

@@ -0,0 +1,80 @@
+const { removeSync, existsSync, ensureDirSync, createWriteStream } = require('fs-extra');
+const { join, dirname } = require('path');
+const archiver = require('archiver');
+const { BaseBackup } = require('./base');
+
+class BlockletsBackup extends BaseBackup {
+  /**
+   *
+   * @returns {Promise<void>}
+   * @memberof BlockletsBackup
+   */
+  async export() {
+    const blockletMetas = this.getBlockletMetas(this.blocklet);
+    const serverBlockletsDir = join(this.serverDataDir, 'blocklets');
+
+    const dirs = [];
+    for (const blockletMeta of blockletMetas) {
+      const sourceDir = join(serverBlockletsDir, blockletMeta.name, blockletMeta.version);
+      const destDir = join(blockletMeta.name, blockletMeta.version);
+      dirs.push({ sourceDir, destDir });
+    }
+
+    await this.dirsToZip(dirs, join(this.blockletBackupDir, 'blocklets.zip'));
+  }
+
+  /**
+   *
+   *
+   * @param {import('@abtnode/client').BlockletState} blocklet
+   * @returns {Array<{name: string, version: string}>}
+   * @memberof BlockletsBackup
+   */
+  getBlockletMetas(blocklet) {
+    if (!blocklet?.meta?.bundleName || !blocklet?.meta?.version) {
+      return [];
+    }
+
+    const metas = [];
+    metas.push({
+      name: blocklet.meta.bundleName,
+      version: blocklet.meta.version,
+    });
+
+    for (const child of blocklet.children) {
+      metas.push(...this.getBlockletMetas(child));
+    }
+
+    return metas;
+  }
+
+  /**
+   * @param {Array<{sourceDir: string, destDir: string}>} dirs: /some/folder/to/compress
+   * @param {String} zipPath: /path/to/created.zip
+   * @returns {Promise}
+   * @memberof BlockletsBackup
+   */
+  async dirsToZip(dirs, zipPath) {
+    ensureDirSync(dirname(zipPath));
+    if (existsSync(zipPath)) {
+      removeSync(zipPath);
+    }
+
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    const stream = createWriteStream(zipPath);
+
+    return new Promise((resolve, reject) => {
+      archive.on('error', (err) => reject(err));
+      stream.on('close', () => resolve());
+
+      for (const dir of dirs) {
+        archive.directory(dir.sourceDir, dir.destDir);
+      }
+
+      archive.pipe(stream);
+      archive.finalize();
+    });
+  }
+}
+
+module.exports = { BlockletsBackup };

package/lib/blocklet/storage/backup/data.js

@@ -0,0 +1,19 @@
+const { copySync } = require('fs-extra');
+const { join } = require('path');
+const { BaseBackup } = require('./base');
+
+class DataBackup extends BaseBackup {
+  /**
+   *
+   * @returns {Promise<void>}
+   * @memberof BlockletsBackup
+   */
+  async export() {
+    const blockletDataDir = join(this.serverDataDir, 'data', this.blocklet.meta.name);
+    const blockletBackupDataDir = join(this.blockletBackupDir, 'data');
+
+    copySync(blockletDataDir, blockletBackupDataDir, { overwrite: true });
+  }
+}
+
+module.exports = { DataBackup };

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

@@ -0,0 +1,23 @@
+const { ensureDirSync, copySync, statSync } = require('fs-extra');
+const { join } = require('path');
+const { BaseBackup } = require('./base');
+
+class LogsBackup extends BaseBackup {
+  async export() {
+    const sourceLogsDir = join(this.serverDataDir, 'logs', this.blocklet.meta.name);
+    ensureDirSync(sourceLogsDir);
+
+    const targetLogsDir = join(this.blockletBackupDir, 'logs');
+
+    copySync(sourceLogsDir, targetLogsDir, {
+      overwrite: true,
+      filter: (src) => {
+        return !statSync(src).isSymbolicLink();
+      },
+    });
+  }
+}
+
+module.exports = {
+  LogsBackup,
+};

package/lib/blocklet/storage/backup/routing-rule.js

@@ -0,0 +1,19 @@
+const { removeSync, outputJsonSync } = require('fs-extra');
+const { join } = require('path');
+const states = require('../../../states');
+const { BaseBackup } = require('./base');
+
+class RoutingRuleBackup extends BaseBackup {
+  filename = 'routing_rule.json';
+
+  async export() {
+    const routingRule = await states.site.findOne({
+      domain: `${this.blocklet.meta.did}.blocklet-domain-group`,
+    });
+
+    removeSync(join(this.blockletBackupDir, this.filename));
+    outputJsonSync(join(this.blockletBackupDir, this.filename), routingRule);
+  }
+}
+
+module.exports = { RoutingRuleBackup };

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

@@ -0,0 +1,189 @@
+/**
+ * @typedef {{
+ *  did?: string
+ * }} SpaceBackupInput
+ */
+
+const { isValid } = require('@arcblock/did');
+const { BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/constant');
+const { getBlockletInfo } = require('@blocklet/meta');
+const { SpaceClient, SyncFolderPushCommand } = require('@did-space/client');
+const { ensureDirSync, existsSync, rmdirSync, removeSync } = require('fs-extra');
+const { isEmpty } = require('lodash');
+const { join } = require('path');
+const states = require('../../../states');
+const { AuditLogBackup } = require('./audit-log');
+const { BlockletBackup } = require('./blocklet');
+const { BlockletExtrasBackup } = require('./blocklet-extras');
+const { BlockletsBackup } = require('./blocklets');
+const { DataBackup } = require('./data');
+const { LogsBackup } = require('./logs');
+const { RoutingRuleBackup } = require('./routing-rule');
+
+class SpacesBackup {
+  /**
+   *
+   * @type {SpaceBackupInput}
+   * @memberof SpacesBackup
+   */
+  input;
+
+  /**
+   * @description blocklet state 对象
+   * @type {import('@abtnode/client').BlockletState}
+   * @memberof SpacesBackup
+   */
+  blocklet;
+
+  /**
+   * @description 当前 blocklet 的数据目录
+   * @type {string}
+   * @memberof SpacesBackup
+   */
+  blockletBackupDir;
+
+  /**
+   *
+   * @description server 的数据目录
+   * @type {string}
+   * @memberof SpacesBackup
+   */
+  serverDataDir;
+
+  /**
+   *
+   * @description spaces 的 endpoint
+   * @type {string}
+   * @memberof SpacesBackup
+   */
+  spacesEndpoint;
+
+  /**
+   *
+   * @description spaces 的 endpoint
+   * @type {import('@ocap/wallet').WalletObject}
+   * @memberof SpacesBackup
+   */
+  blockletWallet;
+
+  storages;
+
+  /**
+   *
+   * @param {SpaceBackupInput} input
+   * @memberof SpacesBackup
+   */
+  constructor(input) {
+    this.verify(input);
+    this.input = input;
+    this.storages = [
+      new AuditLogBackup(this.input),
+      new LogsBackup(this.input),
+      new BlockletBackup(this.input),
+      new BlockletsBackup(this.input),
+      new BlockletExtrasBackup(this.input),
+      new RoutingRuleBackup(this.input),
+      new DataBackup(this.input),
+    ];
+  }
+
+  /**
+   * @param {SpaceBackupInput} input
+   * @returns {void}
+   * @memberof SpacesBackup
+   */
+  verify(input) {
+    if (isEmpty(input?.did) || !isValid(input?.did)) {
+      throw new Error(`input.did(${input?.did}) is not a valid did`);
+    }
+  }
+
+  /**
+   *
+   * @returns {Promise<void>}
+   * @memberof SpacesBackup
+   */
+  async backup() {
+    await this.initialize();
+    await this.export();
+    await this.syncToSpaces();
+    await this.destroy();
+  }
+
+  async initialize() {
+    this.blocklet = await states.blocklet.findOne({
+      appDid: this.input.did,
+    });
+    if (isEmpty(this.blocklet)) {
+      throw new Error('blocklet cannot be empty');
+    }
+
+    this.serverDataDir = process.env.ABT_NODE_DATA_DIR;
+
+    this.blockletBackupDir = join(process.env.ABT_NODE_DATA_DIR, 'tmp/backup', this.blocklet.meta.did);
+    if (existsSync(this.blockletBackupDir)) {
+      rmdirSync(this.blockletBackupDir, { recursive: true });
+    }
+    ensureDirSync(this.blockletBackupDir);
+
+    this.spacesEndpoint = this.blocklet.environments.find(
+      (e) => e.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SPACE_ENDPOINT
+    )?.value;
+    if (isEmpty(this.spacesEndpoint)) {
+      throw new Error('spacesEndpoint cannot be empty');
+    }
+
+    this.blockletWallet = await this.getBlockletWallet();
+  }
+
+  async export() {
+    await Promise.all(
+      this.storages.map((storage) => {
+        storage.ensureParams(this);
+        return storage.export();
+      })
+    );
+  }
+
+  async syncToSpaces() {
+    const wallet = await this.getBlockletWallet();
+    const spaceClient = new SpaceClient({
+      endpoint: this.spacesEndpoint,
+      wallet,
+    });
+
+    // FIXME: 在 Spaces 里面预览出 blocklet 的样式，需要规划一个好的数据结构
+    const { errorCount } = await spaceClient.send(
+      new SyncFolderPushCommand({
+        source: join(this.blockletBackupDir, '/'),
+        target: join('.did-objects', this.blocklet.appDid),
+        debug: true,
+        retryCount: 3,
+        filter: (object) => {
+          return object.name !== '.DS_Store';
+        },
+      })
+    );
+
+    if (errorCount !== 0) {
+      throw new Error(`Sync to spaces encountered ${errorCount} error`);
+    }
+  }
+
+  async getBlockletWallet() {
+    const blockletInfo = await states.blocklet.getBlocklet(this.input.did);
+    const nodeInfo = await states.node.read();
+    const { wallet } = getBlockletInfo(blockletInfo, nodeInfo.sk);
+    return wallet;
+  }
+
+  async destroy() {
+    if (existsSync(this.blockletBackupDir)) {
+      removeSync(this.blockletBackupDir);
+    }
+  }
+}
+
+module.exports = {
+  SpacesBackup,
+};

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

@@ -0,0 +1,55 @@
+class BaseRestore {
+  /**
+   *
+   * @type {import('./spaces').SpaceRestoreInput}
+   * @memberof BaseRestore
+   */
+  input;
+
+  /**
+   * @description 当前 blocklet 的数据目录
+   * @type {string}
+   * @memberof BaseRestore
+   */
+  blockletRestoreDir;
+
+  /**
+   *
+   * @description spaces 的 endpoint
+   * @type {import('@ocap/wallet').WalletObject}
+   * @memberof BaseRestore
+   */
+  blockletWallet;
+
+  /**
+   *
+   * @description server 的数据目录
+   * @type {string}
+   * @memberof BaseRestore
+   */
+  serverDataDir;
+
+  constructor(input) {
+    this.input = input;
+  }
+
+  /**
+   *
+   *
+   * @param {import('./spaces').SpacesRestore} spaces
+   * @memberof BaseRestore
+   */
+  ensureParams(spaces) {
+    this.blockletRestoreDir = spaces.blockletRestoreDir;
+    this.blockletWallet = spaces.blockletWallet;
+    this.serverDataDir = spaces.serverDataDir;
+  }
+
+  async import() {
+    throw new Error('not implemented');
+  }
+}
+
+module.exports = {
+  BaseRestore,
+};

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

@@ -0,0 +1,84 @@
+const { removeSync, outputJsonSync, readJSONSync } = require('fs-extra');
+const { cloneDeep } = require('lodash');
+const { join } = require('path');
+const security = require('@abtnode/util/lib/security');
+const { BaseRestore } = require('./base');
+
+class BlockletExtrasRestore extends BaseRestore {
+  filename = 'blocklet-extras.json';
+
+  async import() {
+    const blockletExtra = await this.getBlockletExtra();
+    removeSync(join(this.blockletRestoreDir, this.filename));
+    outputJsonSync(join(this.blockletRestoreDir, this.filename), blockletExtra);
+  }
+
+  /**
+   *
+   * @description
+   * @return {Promise<import('@abtnode/client').BlockletState>}
+   * @memberof BlockletExtrasRestore
+   */
+  async getBlockletExtra() {
+    /**
+     * @type {import('@abtnode/client').BlockletState}
+     */
+    const blockletExtra = readJSONSync(join(this.blockletRestoreDir, this.filename));
+
+    return this.cleanData(blockletExtra);
+  }
+
+  /**
+   *
+   * @description 清理数据并加密
+   * @param {import('@abtnode/client').BlockletState} blockletExtraInput
+   * @return {Promise<void>}
+   * @memberof BlockletExtrasRestore
+   */
+  async cleanData(blockletExtraInput) {
+    const blockletExtra = cloneDeep(blockletExtraInput);
+
+    const queue = [blockletExtra];
+    while (queue.length) {
+      const currentBlockletExtra = queue.pop();
+
+      // 加解密
+      this.useBlockletDecryptConfigs(currentBlockletExtra.configs);
+
+      if (currentBlockletExtra?.children) {
+        queue.push(...currentBlockletExtra.children);
+      }
+    }
+
+    return blockletExtra;
+  }
+
+  /**
+   *
+   * @description 清理数据并加密
+   * @param {import('@abtnode/client').ConfigEntry[]} configs
+   * @return {void}
+   * @memberof BlockletExtrasRestore
+   */
+  useBlockletDecryptConfigs(configs) {
+    for (const config of configs) {
+      // secure 为 true 的配置才需要被加密保存上次到 did spaces
+      if (config.secure) {
+        const encryptByBlocklet = config.value;
+
+        // 再用 blocklet secret 加密，然后才可以上传到 spaces
+        const decryptByBlocklet = security.decrypt(
+          encryptByBlocklet,
+          this.blockletWallet.address,
+          Buffer.from(this.blockletWallet.secretKey)
+        );
+
+        config.value = decryptByBlocklet;
+      }
+    }
+
+    return configs;
+  }
+}
+
+module.exports = { BlockletExtrasRestore };

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

@@ -0,0 +1,24 @@
+const { existsSync, removeSync } = require('fs-extra');
+const { join } = require('path');
+const StreamZip = require('node-stream-zip');
+const { BaseRestore } = require('./base');
+
+class BlockletsRestore extends BaseRestore {
+  filename = 'blocklets.zip';
+
+  async import() {
+    const blockletZipPath = join(this.blockletRestoreDir, this.filename);
+
+    if (!existsSync(blockletZipPath)) {
+      throw new Error(`file not found: ${blockletZipPath}`);
+    }
+
+    // eslint-disable-next-line new-cap
+    const zip = new StreamZip.async({ file: blockletZipPath });
+    await zip.extract(null, join(this.blockletRestoreDir, 'blocklets'));
+    await zip.close();
+    removeSync(blockletZipPath);
+  }
+}
+
+module.exports = { BlockletsRestore };

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

@@ -0,0 +1,137 @@
+/**
+ * @typedef {{
+ *  endpoint: string;
+ *  blockletSecretKey: 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 { BlockletExtrasRestore } = require('./blocklet-extras');
+const { BlockletsRestore } = require('./blocklets');
+
+class SpacesRestore {
+  /**
+   *
+   * @type {SpaceRestoreInput}
+   * @memberof SpacesRestore
+   */
+  input;
+
+  /**
+   * @description 当前 blocklet 的数据目录
+   * @type {string}
+   * @memberof SpacesRestore
+   */
+  blockletRestoreDir;
+
+  /**
+   *
+   * @description server 的数据目录
+   * @type {string}
+   * @memberof SpacesRestore
+   */
+  serverDataDir;
+
+  /**
+   *
+   * @description spaces 的 endpoint
+   * @type {import('@ocap/wallet').WalletObject}
+   * @memberof SpacesRestore
+   */
+  blockletWallet;
+
+  storages;
+
+  /**
+   *
+   * @param {SpaceRestoreInput} input
+   * @memberof SpacesRestore
+   */
+  constructor(input) {
+    this.verify(input);
+    this.input = input;
+    this.storages = [new BlockletExtrasRestore(this.input), new BlockletsRestore(this.input)];
+  }
+
+  /**
+   *
+   * @param {SpaceRestoreInput} input
+   * @returns {void}
+   * @memberof SpacesRestore
+   */
+  verify(input) {
+    if (!validUrl.isWebUri(input.endpoint)) {
+      throw new Error(`endpoint(${input.endpoint}) must be a WebUri`);
+    }
+  }
+
+  async initialize() {
+    this.serverDataDir = process.env.ABT_NODE_DATA_DIR;
+    this.blockletWallet = await this.getBlockletWallet();
+
+    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);
+  }
+
+  /**
+   *
+   * @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 }));
+
+    return wallet;
+  }
+
+  async syncFromSpaces() {
+    const { endpoint } = this.input;
+    const wallet = await this.getBlockletWallet();
+
+    const spaceClient = new SpaceClient({
+      endpoint,
+      wallet,
+    });
+
+    const { errorCount } = await spaceClient.send(
+      new SyncFolderPullCommand({
+        source: join('.did-objects', this.blockletWallet.address, '/'),
+        target: this.blockletRestoreDir,
+        debug: true,
+        retryCount: 3,
+      })
+    );
+
+    if (errorCount !== 0) {
+      throw new Error(`Sync from spaces encountered ${errorCount} error`);
+    }
+  }
+
+  async import() {
+    await Promise.all(
+      this.storages.map((storage) => {
+        storage.ensureParams(this);
+        return storage.import();
+      })
+    );
+  }
+}
+
+module.exports = {
+  SpacesRestore,
+};

package/lib/index.js

@@ -216,6 +216,8 @@ function ABTNode(options) {
     updateWhoCanAccess: blockletManager.updateWhoCanAccess.bind(blockletManager),
     updateComponentTitle: blockletManager.updateComponentTitle.bind(blockletManager),
     updateComponentMountPoint: blockletManager.updateComponentMountPoint.bind(blockletManager),
+    backupToSpaces: blockletManager.backupToSpaces.bind(blockletManager),
+    restoreFromSpaces: blockletManager.restoreFromSpaces.bind(blockletManager),
 
     // For diagnose purpose
     syncBlockletStatus: blockletManager.status.bind(blockletManager),
@@ -259,8 +261,9 @@ function ABTNode(options) {
     createTransferInvitation: teamAPI.createTransferInvitation.bind(teamAPI),
     getInvitation: teamAPI.getInvitation.bind(teamAPI),
     getInvitations: teamAPI.getInvitations.bind(teamAPI),
-    processInvitation: teamAPI.processInvitation.bind(teamAPI),
+    checkInvitation: teamAPI.checkInvitation.bind(teamAPI),
     deleteInvitation: teamAPI.deleteInvitation.bind(teamAPI),
+    closeInvitation: teamAPI.closeInvitation.bind(teamAPI),
 
     // Account
     getUsers: teamAPI.getUsers.bind(teamAPI),

package/lib/states/blocklet-extras.js

@@ -199,6 +199,10 @@ class BlockletExtrasState extends BaseState {
     return super.update({ did }, { $set: entity }, { upsert: true });
   }
 
+  async getMeta(did) {
+    return super.findOne({ did }, { did: 1, controller: 1, meta: 1 });
+  }
+
   async updateExpireInfo({ did, expiredAt } = {}) {
     const entity = { did, expiredAt };
     await validateExpiredInfo(entity);

package/lib/states/blocklet.js

@@ -23,7 +23,6 @@ const logger = require('@abtnode/logger')('state-blocklet');
 const BaseState = require('./base');
 const { checkDuplicateComponents, ensureMeta } = require('../util/blocklet');
 const { validateBlockletMeta } = require('../util');
-const { validateBlockletController } = require('../validators/blocklet');
 
 const lock = new Lock('blocklet-port-assign-lock');
 
@@ -122,21 +121,6 @@ class BlockletState extends BaseState {
     });
   }
 
-  async isExternalBlocklet(did) {
-    if (!did) {
-      return false;
-    }
-
-    const exist = await this.findOne({
-      $or: [{ 'meta.did': did }, { appDid: did }],
-      controller: {
-        $exists: true,
-      },
-    });
-
-    return !!exist;
-  }
-
   async getBlockletStatus(did) {
     return new Promise((resolve, reject) => {
       if (!did) {
@@ -212,7 +196,6 @@ class BlockletState extends BaseState {
     deployedFrom = '',
     mode = BLOCKLET_MODES.PRODUCTION,
     children: rawChildren = [],
-    controller,
   } = {}) {
     return this.getBlocklet(meta.did).then(
       (exist) =>
@@ -251,13 +234,8 @@ class BlockletState extends BaseState {
               ports,
               environments: [],
               children,
-              controller,
             };
 
-            if (controller) {
-              data.controller = await validateBlockletController(controller);
-            }
-
             // add to db
             this.insert(data, (err, doc) => {
               lock.release();

package/lib/util/blocklet.js

@@ -88,6 +88,7 @@ const {
   findInterfacePortByName,
   validateBlockletMeta,
   prettyURL,
+  getNFTState,
 } = require('./index');
 
 const getComponentConfig = (meta) => meta.components || meta.children;
@@ -1392,6 +1393,11 @@ const getBlocklet = async ({
   blocklet.enablePassportIssuance = get(settings, 'enablePassportIssuance', true);
   blocklet.settings = settings || {};
 
+  const extrasMeta = await states.blockletExtras.getMeta(blocklet.meta.did);
+  if (extrasMeta) {
+    blocklet.controller = extrasMeta.controller;
+  }
+
   blocklet.settings.storeList = blocklet.settings.storeList || [];
 
   if (!blocklet.settings.storeList.find((x) => x.url === BLOCKLET_STORE.url)) {
@@ -1491,7 +1497,11 @@ const getConfigFromPreferences = (blocklet) => {
 
 const consumeServerlessNFT = async ({ nftId, nodeInfo, blocklet }) => {
   try {
-    const { url } = nodeInfo.launcher;
+    const state = await getNFTState(blocklet.controller.chainHost, nftId);
+    if (!state) {
+      throw new Error(`get nft state failed, chainHost: ${blocklet.controller.chainHost}, nftId: ${nftId}`);
+    }
+
     const type = WalletType({
       role: types.RoleType.ROLE_APPLICATION,
       pk: types.KeyType.ED25519,
@@ -1502,7 +1512,8 @@ const consumeServerlessNFT = async ({ nftId, nodeInfo, blocklet }) => {
 
     const body = { nftId, appURL };
 
-    const { data } = await axios.post(joinURL(url, '/api/serverless/consume'), body, {
+    const { launcherUrl } = state.data.value;
+    const { data } = await axios.post(joinURL(launcherUrl, '/api/serverless/consume'), body, {
       headers: {
         'x-sig': toBase58(wallet.sign(stableStringify(body))),
       },
@@ -1618,6 +1629,16 @@ const validateAppConfig = async (config, blockletDid, states) => {
       throw new Error(`${x.key}(${x.value}) is not a valid http address`);
     }
   }
+
+  if (x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SPACES_URL) {
+    if (isEmpty(x.value)) {
+      throw new Error(`${x.key} can not be empty`);
+    }
+
+    if (!isUrl(x.value)) {
+      throw new Error(`${x.key}(${x.value}) is not a valid http address`);
+    }
+  }
 };
 
 const checkDuplicateAppSk = async ({ sk, did, states }) => {

package/lib/validators/util.js

@@ -13,6 +13,7 @@ const getMultipleLangParams = (context) => ({
 const blockletController = Joi.object({
   nftId: Joi.DID().required(),
   nftOwner: Joi.DID().required(),
+  chainHost: Joi.string().uri().required(),
   appMaxCount: Joi.number().required().min(1),
 }).options({ stripUnknown: true });
 

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.64-beta-b3d407e0",
+  "version": "1.8.64-beta-0b5ede51",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,32 +19,33 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/auth": "1.8.64-beta-b3d407e0",
-    "@abtnode/certificate-manager": "1.8.64-beta-b3d407e0",
-    "@abtnode/constant": "1.8.64-beta-b3d407e0",
-    "@abtnode/cron": "1.8.64-beta-b3d407e0",
-    "@abtnode/db": "1.8.64-beta-b3d407e0",
-    "@abtnode/logger": "1.8.64-beta-b3d407e0",
-    "@abtnode/queue": "1.8.64-beta-b3d407e0",
-    "@abtnode/rbac": "1.8.64-beta-b3d407e0",
-    "@abtnode/router-provider": "1.8.64-beta-b3d407e0",
-    "@abtnode/static-server": "1.8.64-beta-b3d407e0",
-    "@abtnode/timemachine": "1.8.64-beta-b3d407e0",
-    "@abtnode/util": "1.8.64-beta-b3d407e0",
-    "@arcblock/did": "1.18.36",
+    "@abtnode/auth": "1.8.64-beta-0b5ede51",
+    "@abtnode/certificate-manager": "1.8.64-beta-0b5ede51",
+    "@abtnode/constant": "1.8.64-beta-0b5ede51",
+    "@abtnode/cron": "1.8.64-beta-0b5ede51",
+    "@abtnode/db": "1.8.64-beta-0b5ede51",
+    "@abtnode/logger": "1.8.64-beta-0b5ede51",
+    "@abtnode/queue": "1.8.64-beta-0b5ede51",
+    "@abtnode/rbac": "1.8.64-beta-0b5ede51",
+    "@abtnode/router-provider": "1.8.64-beta-0b5ede51",
+    "@abtnode/static-server": "1.8.64-beta-0b5ede51",
+    "@abtnode/timemachine": "1.8.64-beta-0b5ede51",
+    "@abtnode/util": "1.8.64-beta-0b5ede51",
+    "@arcblock/did": "1.18.37",
     "@arcblock/did-motif": "^1.1.10",
-    "@arcblock/did-util": "1.18.36",
-    "@arcblock/event-hub": "1.18.36",
-    "@arcblock/jwt": "^1.18.36",
+    "@arcblock/did-util": "1.18.37",
+    "@arcblock/event-hub": "1.18.37",
+    "@arcblock/jwt": "^1.18.37",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/vc": "1.18.36",
-    "@blocklet/constant": "1.8.64-beta-b3d407e0",
-    "@blocklet/meta": "1.8.64-beta-b3d407e0",
-    "@blocklet/sdk": "1.8.64-beta-b3d407e0",
+    "@arcblock/vc": "1.18.37",
+    "@blocklet/constant": "1.8.64-beta-0b5ede51",
+    "@blocklet/meta": "1.8.64-beta-0b5ede51",
+    "@blocklet/sdk": "1.8.64-beta-0b5ede51",
+    "@did-space/client": "^0.1.66",
     "@fidm/x509": "^1.2.1",
-    "@ocap/mcrypto": "1.18.36",
-    "@ocap/util": "1.18.36",
-    "@ocap/wallet": "1.18.36",
+    "@ocap/mcrypto": "1.18.37",
+    "@ocap/util": "1.18.37",
+    "@ocap/wallet": "1.18.37",
     "@slack/webhook": "^5.0.4",
     "archiver": "^5.3.1",
     "axios": "^0.27.2",
@@ -55,7 +56,7 @@
     "detect-port": "^1.5.1",
     "escape-string-regexp": "^4.0.0",
     "flat": "^5.0.2",
-    "fs-extra": "^10.1.0",
+    "fs-extra": "^11.1.0",
     "get-port": "^5.1.1",
     "is-base64": "^1.1.0",
     "is-ip": "^3.1.0",
@@ -64,6 +65,7 @@
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
     "lru-cache": "^6.0.0",
+    "node-stream-zip": "^1.15.0",
     "p-limit": "^3.1.0",
     "pm2": "^5.2.0",
     "semver": "^7.3.8",
@@ -77,7 +79,8 @@
     "ua-parser-js": "^1.0.2",
     "unzipper": "^0.10.11",
     "url-join": "^4.0.1",
-    "uuid": "7.0.3"
+    "uuid": "7.0.3",
+    "valid-url": "^1.0.9"
   },
   "devDependencies": {
     "compression": "^1.7.4",
@@ -85,5 +88,5 @@
     "express": "^4.18.2",
     "jest": "^27.5.1"
   },
-  "gitHead": "e076a9cab4c15cfafb82d0aef9a66dd1b825ec75"
+  "gitHead": "fbb72fdf88ea44c949ea951b84ab0506805bda7d"
 }

package/lib/validators/blocklet.js

@@ -1,5 +0,0 @@
-const { blockletController } = require('./util');
-
-module.exports = {
-  validateBlockletController: (entity) => blockletController.validateAsync(entity),
-};