@abtnode/core 1.16.0-beta-8ee536d7 → 1.16.0-beta-62b42401

package/lib/api/team.js

@@ -12,6 +12,7 @@ const {
   WELLKNOWN_SERVICE_PATH_PREFIX,
   MAX_USER_PAGE_SIZE,
   STORE_DETAIL_PAGE_PATH_PREFIX,
+  USER_TYPE,
 } = require('@abtnode/constant');
 const { isValid: isValidDid } = require('@arcblock/did');
 const { BlockletEvents } = require('@blocklet/constant');
@@ -182,6 +183,10 @@ class TeamAPI extends EventEmitter {
             'remark',
             'avatar',
             'locale',
+            // oauth relate fields
+            'source',
+            'derivedAccount',
+            'connectedAccounts',
           ])
         // eslint-disable-next-line function-paren-newline
       ),
@@ -592,6 +597,13 @@ class TeamAPI extends EventEmitter {
 
   // Issue Passport
 
+  /**
+   * 为指定用户颁发 passport
+   * @param {string} param.teamDid - 应用的 did
+   * @param {string} param.ownerDid - 指定用户的 did
+   * @param {string} param.name - passport 的 role
+   * @returns {object} passport-info
+   */
   async createPassportIssuance({ teamDid, ownerDid, name }) {
     if (!name) {
       throw new Error('Passport cannot be empty');
@@ -613,6 +625,45 @@ class TeamAPI extends EventEmitter {
     const expireDate = Date.now() + this.memberInviteExpireTime;
 
     const state = await this.getSessionState(teamDid);
+
+    const currentUser = await this.getUser({ teamDid, user: { did: ownerDid } });
+    if (currentUser?.source === USER_TYPE.DERIVED) {
+      const userDid = currentUser.did;
+      const blocklet = await getBlocklet({ did: teamDid, states: this.states, dataDirs: this.dataDirs });
+      const nodeInfo = await this.node.read();
+      const blockletInfo = getBlockletInfo(blocklet, nodeInfo.sk);
+      const { wallet, passportColor, appUrl, name: issuerName } = blockletInfo;
+      const vc = createPassportVC({
+        issuerName,
+        issuerWallet: wallet,
+        ownerDid: userDid,
+        passport: await createPassport({
+          role,
+        }),
+        endpoint: getPassportStatusEndpoint({
+          baseUrl: joinUrl(appUrl, WELLKNOWN_SERVICE_PATH_PREFIX),
+          userDid,
+          teamDid,
+        }),
+        ownerProfile: {
+          ...currentUser,
+          // avatar: await parseUserAvatar(currentUser.avatar, { dataDir: blocklet.env.dataDir }),
+        },
+        preferredColor: passportColor,
+      });
+
+      // write passport to db
+      const passport = createUserPassport(vc, { role: role.name });
+      const passports = upsertToPassports(currentUser.passports || [], passport);
+      await this.updateUser({
+        teamDid,
+        user: {
+          did: ownerDid,
+          passports,
+        },
+      });
+      return undefined;
+    }
     const { id } = await state.start({
       type: 'passport-issuance',
       expireDate, // session expireDate

package/lib/blocklet/manager/disk.js

@@ -11,9 +11,11 @@ const cloneDeep = require('lodash/cloneDeep');
 const { isNFTExpired, getNftExpirationDate } = require('@abtnode/util/lib/nft');
 const didDocument = require('@abtnode/util/lib/did-document');
 const { sign } = require('@arcblock/jwt');
+const { isEthereumDid } = require('@arcblock/did');
 const { toSvg: createDidLogo } =
   process.env.NODE_ENV !== 'test' ? require('@arcblock/did-motif') : require('@arcblock/did-motif/dist/did-motif.cjs');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
+const { createBlockiesSvg } = require('@blocklet/meta/lib/blockies');
 const sleep = require('@abtnode/util/lib/sleep');
 
 const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager');
@@ -60,6 +62,7 @@ const {
   BLOCKLET_LATEST_SPEC_VERSION,
   BLOCKLET_META_FILE,
   BLOCKLET_CONFIGURABLE_KEY,
+  RESTORE_PROGRESS_STATUS,
 } = require('@blocklet/constant');
 const util = require('../../util');
 const {
@@ -109,7 +112,10 @@ const handleInstanceInStore = require('../../util/public-to-store');
 const { BlockletRuntimeMonitor } = require('../../monitor/blocklet-runtime-monitor');
 const getHistoryList = require('../../monitor/get-history-list');
 const { SpacesBackup } = require('../storage/backup/spaces');
+const { DiskBackup } = require('../storage/backup/disk');
+const { getBackupList, removeBackup } = require('../storage/utils/disk');
 const { SpacesRestore } = require('../storage/restore/spaces');
+const { DiskRestore } = require('../storage/restore/disk');
 const { installApplicationFromGeneral } = require('./helper/install-application-from-general');
 const { installApplicationFromDev } = require('./helper/install-application-from-dev');
 const { installApplicationFromBackup } = require('./helper/install-application-from-backup');
@@ -566,51 +572,45 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   /**
-   * FIXME: @wangshijun create audit log for this
-   * @param {import('@abtnode/client').RequestBackupToSpacesInput} input
+   * @param {import('@abtnode/client').RequestBackupBlockletInput} input
    * @memberof BlockletManager
    */
   // eslint-disable-next-line no-unused-vars
-  async backupToSpaces({ appDid }, context) {
+  async backup({ appDid, to }, context) {
     const blocklet = await states.blocklet.getBlocklet(appDid);
     if (blocklet.structVersion !== APP_STRUCT_VERSION) {
       throw new Error('Only new version app can be backup to spaces, please migrate this app first');
     }
 
-    const userDid = context.user.did;
-    const { referrer } = context;
+    if (to === 'spaces') {
+      return this._backupToSpaces({ blocklet }, context);
+    }
 
-    const spacesBackup = new SpacesBackup({ appDid, event: this, userDid, referrer });
-    this.emit(BlockletEvents.backupProgress, { appDid, message: 'Start backup...', progress: 10, completed: false });
-    await spacesBackup.backup();
-    this.emit(BlockletEvents.backupProgress, { appDid, completed: true, progress: 100 });
+    if (to === 'disk') {
+      return this._backupToDisk({ blocklet }, context);
+    }
+
+    throw new Error('Can only backup to spaces or disk');
   }
 
   /**
    * FIXME: @linchen support cancel
    * FIXME: @wangshijun create audit log for this
-   * @param {import('@abtnode/client').RequestRestoreFromSpacesInput} input
+   * @param {import('@abtnode/client').RequestRestoreBlockletInput} input
    * @memberof BlockletManager
    */
   // eslint-disable-next-line no-unused-vars
-  async restoreFromSpaces(input, context) {
-    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, message: 'Start restore...', completed: false });
-
-    const userDid = context.user.did;
-
-    const spacesRestore = new SpacesRestore({ ...input, event: this, userDid, referrer: context.referrer });
-    const params = await spacesRestore.restore();
+  async restore(input, context) {
+    const { from, ...param } = input;
+    if (from === 'spaces') {
+      return this._restoreFromSpaces(param, context);
+    }
 
-    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, message: 'Installing blocklet...' });
-    await installApplicationFromBackup({
-      url: `file://${spacesRestore.restoreDir}`,
-      moveDir: true,
-      ...merge(...params),
-      manager: this,
-      states,
-    });
+    if (from === 'disk') {
+      return this._restoreFromDisk(param, context);
+    }
 
-    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, completed: true });
+    throw new Error('Can only restore from spaces or disk');
   }
 
   /**
@@ -982,6 +982,10 @@ class BlockletManager extends BaseBlockletManager {
     return blocklets;
   }
 
+  async listBackups() {
+    return getBackupList(this.dataDirs.data);
+  }
+
   // CAUTION: this method currently only support config by blocklet.meta.did
   // eslint-disable-next-line no-unused-vars
   async config({ did, configs: newConfigs, skipHook, skipDidDocument }, context) {
@@ -1150,6 +1154,15 @@ class BlockletManager extends BaseBlockletManager {
     return blocklet;
   }
 
+  async configOAuth({ did, oauth = {} }) {
+    const oldOAuth = await states.blockletExtras.getSettings(did, 'oauth', {});
+    const mergeConfig = { ...oldOAuth, ...JSON.parse(oauth) };
+    await states.blockletExtras.setSettings(did, { oauth: mergeConfig });
+    const newState = await this.getBlocklet(did);
+    this.emit(BlockletEvents.updated, newState);
+    return newState;
+  }
+
   async updateComponentTitle({ did, rootDid: inputRootDid, title }) {
     await titleSchema.validateAsync(title);
 
@@ -1402,6 +1415,7 @@ class BlockletManager extends BaseBlockletManager {
       throwOnError,
       skipCheckStatusBeforeDownload,
       selectedComponentDids,
+      skipCheckIntegrity,
     } = params;
     const { meta } = blocklet;
     const { name, did, version } = meta;
@@ -1443,7 +1457,10 @@ class BlockletManager extends BaseBlockletManager {
           return x;
         }),
       };
-      const { isCancelled } = await this._downloadBlocklet(blockletForDownload, context);
+      const { isCancelled } = await this._downloadBlocklet(
+        blockletForDownload,
+        Object.assign({}, context, { skipCheckIntegrity })
+      );
 
       if (isCancelled) {
         logger.info('Download was canceled', { name, did, version });
@@ -1869,7 +1886,11 @@ class BlockletManager extends BaseBlockletManager {
         await fs.copy(src, dist);
       }
 
-      await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
+      if (isEthereumDid(blocklet.meta.did)) {
+        await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createBlockiesSvg(blocklet.meta.did));
+      } else {
+        await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
+      }
 
       // Init db
       await this.teamManager.initTeam(blocklet.meta.did);
@@ -1910,6 +1931,7 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       await this._rollbackCache.remove({ did: blocklet.meta.did });
+      removeBackup(this.dataDirs.data, blocklet.appDid);
       return blocklet;
     } catch (err) {
       const { meta } = await states.blocklet.getBlocklet(did);
@@ -2473,6 +2495,85 @@ class BlockletManager extends BaseBlockletManager {
 
     await states.blocklet.updateBlocklet(blocklet.meta.did, { children: blocklet.children });
   }
+
+  /**
+   * FIXME: @wangshijun create audit log for this
+   * @param {import('@abtnode/client').BlockletState} blocklet
+   * @memberof BlockletManager
+   */
+  // eslint-disable-next-line no-unused-vars
+  async _backupToSpaces({ blocklet }, context) {
+    const userDid = context.user.did;
+    const { referrer } = context;
+    const { appDid } = blocklet;
+
+    const spacesBackup = new SpacesBackup({ appDid, event: this, userDid, referrer });
+    this.emit(BlockletEvents.backupProgress, { appDid, message: 'Start backup...', progress: 10, completed: false });
+    await spacesBackup.backup();
+    this.emit(BlockletEvents.backupProgress, { appDid, completed: true, progress: 100 });
+  }
+
+  /**
+   * @param {import('@abtnode/client').BlockletState} blocklet
+   */
+  // eslint-disable-next-line no-unused-vars
+  async _backupToDisk({ blocklet }, context) {
+    const { appDid } = blocklet;
+
+    const diskBackup = new DiskBackup({ appDid, event: this });
+    await diskBackup.backup();
+  }
+
+  /**
+   * FIXME: @linchen support cancel
+   * FIXME: @wangshijun create audit log for this
+   * @param {import('@abtnode/client').RequestRestoreBlockletInput} input
+   * @memberof BlockletManager
+   */
+  // eslint-disable-next-line no-unused-vars
+  async _restoreFromSpaces(input, context) {
+    if (input.delay) {
+      await sleep(input.delay);
+    }
+
+    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, status: RESTORE_PROGRESS_STATUS.start });
+
+    const userDid = context.user.did;
+
+    const spacesRestore = new SpacesRestore({ ...input, event: this, userDid, referrer: context.referrer });
+    const params = await spacesRestore.restore();
+
+    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, status: RESTORE_PROGRESS_STATUS.installing });
+    await installApplicationFromBackup({
+      url: `file://${spacesRestore.restoreDir}`,
+      moveDir: true,
+      ...merge(...params),
+      manager: this,
+      states,
+      controller: input.controller,
+      context: { ...context, startImmediately: true },
+    });
+
+    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, status: RESTORE_PROGRESS_STATUS.completed });
+  }
+
+  async _restoreFromDisk(input) {
+    if (input.delay) {
+      await sleep(input.delay);
+    }
+
+    const diskRestore = new DiskRestore({ ...input, event: this });
+    const params = await diskRestore.restore();
+
+    await installApplicationFromBackup({
+      url: `file://${diskRestore.restoreDir}`,
+      ...merge(...params),
+      manager: this,
+      states,
+      move: true,
+      sync: false, // use queue to download and install application
+    });
+  }
 }
 
 module.exports = BlockletManager;

package/lib/blocklet/manager/helper/install-application-from-backup.js

@@ -5,7 +5,7 @@ const omit = require('lodash/omit');
 const { forEachBlockletSync, getBlockletAppIdList } = require('@blocklet/meta/lib/util');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
 
-const { BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/constant');
+const { BLOCKLET_CONFIGURABLE_KEY, BlockletEvents, BlockletStatus } = require('@blocklet/constant');
 
 const logger = require('@abtnode/logger')('@abtnode/core:install-app-backup');
 
@@ -18,12 +18,21 @@ const { validateBlocklet, checkDuplicateAppSk, getAppDirs } = require('../../../
  *  /blocklets/<name3>version>
  *  /data
  *  /blocklet.json
- *  /blocklet_extras.json
+ *  /blocklet-extras.json
  * @see Blocklet 端到端备份方案的设计与实现（一期） https://team.arcblock.io/comment/discussions/e62084d5-fafa-489e-91d5-defcd6e93223
  * @param {{ url: string, appSk: string, moveDir: boolean, manager: import('../disk'), states: import('../../../states/index'), context: Record<string, string> }}
  * @return {Promise<any>}
  */
-const installApplicationFromBackup = async ({ url, appSk, moveDir, context = {}, states, manager } = {}) => {
+const installApplicationFromBackup = async ({
+  url,
+  appSk,
+  moveDir,
+  context = {},
+  states,
+  manager,
+  sync = true,
+  controller,
+} = {}) => {
   // TODO: support more url schema feature (http, did-spaces)
   if (!url.startsWith('file://')) {
     throw new Error('url must starts with file://');
@@ -41,7 +50,7 @@ const installApplicationFromBackup = async ({ url, appSk, moveDir, context = {},
   const srcDataDir = path.join(dir, 'data');
 
   /** @type {import('@abtnode/client').BlockletState} */
-  const state = omit(fs.readJSONSync(path.join(dir, 'blocklet.json')), [
+  const blockletState = omit(fs.readJSONSync(path.join(dir, 'blocklet.json')), [
     '_id',
     'createdAt',
     'updatedAt',
@@ -49,22 +58,24 @@ const installApplicationFromBackup = async ({ url, appSk, moveDir, context = {},
     'startedAt',
   ]);
 
-  if (!state.structVersion) {
+  if (!blockletState.structVersion) {
     throw new Error(
       'Only application of structVersion 2 can be restored on this server. Please migrate you application and re-backup your application on your previous server.'
     );
   }
 
-  const { meta } = state;
+  const { meta } = blockletState;
   const { did, name: appName } = meta;
 
   const extra = omit(fs.readJSONSync(path.join(dir, 'blocklet-extras.json')), ['_id', 'createdAt', 'updatedAt']);
 
-  if (state.meta.did !== extra.did) {
-    throw new Error(`did does not match in blocklet.json (${state.meta.did}) and blocklet_extra.json ${extra.did}`);
+  if (blockletState.meta.did !== extra.did) {
+    throw new Error(
+      `did does not match in blocklet.json (${blockletState.meta.did}) and blocklet_extra.json ${extra.did}`
+    );
   }
 
-  forEachBlockletSync(state, (component) => {
+  forEachBlockletSync(blockletState, (component) => {
     delete component.status;
     delete component.ports;
     delete component.environments;
@@ -98,8 +109,11 @@ const installApplicationFromBackup = async ({ url, appSk, moveDir, context = {},
 
   // validate appDid
   const nodeInfo = await states.node.read();
-  const appIdList = getBlockletAppIdList(state);
-  const { wallet } = getBlockletInfo({ meta: state.meta, configs: extra.configs, environments: [] }, nodeInfo.sk);
+  const appIdList = getBlockletAppIdList(blockletState);
+  const { wallet } = getBlockletInfo(
+    { meta: blockletState.meta, configs: extra.configs, environments: [] },
+    nodeInfo.sk
+  );
   if (appIdList.includes(wallet.address) === false) {
     throw new Error('blocklet appDid is different from the previous one');
   }
@@ -117,11 +131,15 @@ const installApplicationFromBackup = async ({ url, appSk, moveDir, context = {},
       logger.error('old extra state exists and will be force removed', { existExtra });
       await states.blockletExtras.remove({ did });
     }
+    if (controller) {
+      extra.controller = controller;
+    }
+
     await states.blockletExtras.insert(extra);
     logger.info('blocklet extra is copied successfully');
 
     // add blocklet
-    await states.blocklet.addBlocklet(state);
+    await states.blocklet.addBlocklet(blockletState);
     logger.info('blocklet state is added successfully');
 
     // copy bundle
@@ -145,9 +163,8 @@ const installApplicationFromBackup = async ({ url, appSk, moveDir, context = {},
         logger.info(`bundle  is ${moveDir ? 'moved' : 'copied'} successfully`, { installDir });
       })
     );
-    // 从 store 下载 blocklet
-    await manager.blockletDownloader.download(state, { skipCheckIntegrity: true });
 
+    // copy data
     const dataDir = path.join(manager.dataDirs.data, appName);
     if (fs.existsSync(dataDir)) {
       logger.error('old data exists and will be force removed', { dataDir });
@@ -170,8 +187,76 @@ const installApplicationFromBackup = async ({ url, appSk, moveDir, context = {},
     throw error;
   }
 
-  logger.info('start install blocklet', { did });
-  return manager._installBlocklet({ did, context });
+  if (sync) {
+    try {
+      logger.info('start download blocklet', { did });
+      // 从 store 下载 blocklet
+      await manager.blockletDownloader.download(blockletState, { skipCheckIntegrity: true });
+    } catch (error) {
+      logger.error('download blocklet failed', { did, error });
+
+      await manager._rollback('install', did);
+
+      throw error;
+    }
+    logger.info('start install blocklet', { did });
+    return manager._installBlocklet({ did, context });
+  }
+
+  try {
+    const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
+    manager.emit(BlockletEvents.added, blocklet1);
+
+    const downloadParams = {
+      blocklet: { ...blocklet1 },
+      skipCheckIntegrity: true,
+      context,
+      postAction: 'install',
+    };
+
+    // backup rollback data
+    await manager._rollbackCache.backup({ did, action: 'install' });
+
+    const ticket = manager.installQueue.push(
+      {
+        entity: 'blocklet',
+        action: 'download',
+        id: did,
+        ...downloadParams,
+      },
+      did
+    );
+    ticket.on('failed', async (err) => {
+      logger.error('failed to install blocklet', { did, error: err });
+      try {
+        await manager._rollback('install', did, {});
+      } catch (e) {
+        logger.error('failed to remove blocklet on install error', { did, error: e });
+      }
+
+      manager._createNotification(did, {
+        title: 'Blocklet Install Failed',
+        description: `Blocklet ${blockletState?.meta?.title} install failed with error: ${
+          err.message || 'queue exception'
+        }`,
+        entityType: 'blocklet',
+        entityId: did,
+        severity: 'error',
+      });
+    });
+
+    return blocklet1;
+  } catch (err) {
+    logger.error('failed to install blocklet', { did, error: err });
+
+    try {
+      await manager._rollback('install', did, {});
+    } catch (e) {
+      logger.error('failed to remove blocklet on install error', { did, error: e });
+    }
+
+    throw err;
+  }
 };
 
 module.exports = { installApplicationFromBackup };

package/lib/blocklet/manager/helper/install-application-from-dev.js

@@ -1,5 +1,7 @@
 const path = require('path');
 const fs = require('fs-extra');
+const { isEthereumDid } = require('@arcblock/did');
+const { createBlockiesSvg } = require('@blocklet/meta/lib/blockies');
 
 const { toSvg: createDidLogo } =
   process.env.NODE_ENV !== 'test' ? require('@arcblock/did-motif') : require('@arcblock/did-motif/dist/did-motif.cjs');
@@ -86,7 +88,11 @@ const installApplicationFromDev = async ({ folder, meta, states, manager } = {})
 
   blocklet = await manager.getBlocklet(did);
 
-  await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
+  if (isEthereumDid(blocklet.meta.did)) {
+    await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createBlockiesSvg(blocklet.meta.did));
+  } else {
+    await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
+  }
 
   return blocklet;
 };

package/lib/blocklet/manager/helper/install-application-from-general.js

@@ -63,28 +63,16 @@ const installApplicationFromGeneral = async ({
     }
   }
 
-  // app wallet
-  const wallet = getApplicationWallet(appSk);
-  const did = wallet.address;
-  const name = wallet.address;
-
-  // check exist
-  const exist = await states.blocklet.hasBlocklet(did);
-  if (exist) {
-    throw new Error(`blocklet ${did} already exists`);
-  }
-
-  // remove dirty data
-  const oldExtraState = await states.blockletExtras.findOne({ did });
-  if (oldExtraState) {
-    logger.error('find dirty data in blocklet extra', { did });
-    await states.blockletExtras.remove({ did });
-  }
+  let blockletWalletType;
 
   // create component
   let component;
   if (componentSourceUrl) {
     const meta = await getBlockletMetaFromUrl(componentSourceUrl);
+    const blockletWalletTypeEnv = (meta.environments || []).find((x) => x.name === 'BLOCKLET_WALLET_TYPE');
+    if (blockletWalletTypeEnv) {
+      blockletWalletType = blockletWalletTypeEnv.default;
+    }
 
     if (nodeInfo.mode === NODE_MODES.SERVERLESS) {
       validateInServerless({ blockletMeta: meta });
@@ -97,6 +85,24 @@ const installApplicationFromGeneral = async ({
     };
   }
 
+  // app wallet
+  const wallet = getApplicationWallet(appSk, undefined, blockletWalletType);
+  const did = wallet.address;
+  const name = wallet.address;
+
+  // check exist
+  const exist = await states.blocklet.hasBlocklet(did);
+  if (exist) {
+    throw new Error(`blocklet ${did} already exists`);
+  }
+
+  // remove dirty data
+  const oldExtraState = await states.blockletExtras.findOne({ did });
+  if (oldExtraState) {
+    logger.error('find dirty data in blocklet extra', { did });
+    await states.blockletExtras.remove({ did });
+  }
+
   // create app
   const blocklet = await manager._addBlocklet({ component, name, did, title, description });
   logger.info('blocklet added to database', { did: blocklet.meta.did });

package/lib/blocklet/manager/helper/install-component-from-upload.js

@@ -138,7 +138,7 @@ const diff = async ({ did, hashFiles: clientFiles, rootDid: inputRootDid, states
 
   const rootBlocklet = await states.blocklet.getBlocklet(rootDid);
   if (childDid && !rootBlocklet) {
-    throw new Error('Root blocklet does not exist');
+    throw new Error(`Root blocklet does not exist: ${rootDid}`);
   }
 
   const state = childDid ? await (rootBlocklet.children || []).find((x) => x.meta.did === childDid) : rootBlocklet;