@abtnode/core 1.16.6-beta-4562aa60 → 1.16.6-beta-eaa4d39d

package/lib/processes/updater.js

@@ -0,0 +1,160 @@
+/* eslint-disable no-console */
+const fs = require('fs-extra');
+const axon = require('axon');
+const path = require('path');
+const shell = require('shelljs');
+const semver = require('semver');
+
+const VERBOSE = '';
+// const VERBOSE = '--verbose';
+
+const BINARY_NAME = process.env.ABT_NODE_BINARY_NAME;
+const COMMAND_NAME = process.env.ABT_NODE_COMMAND_NAME;
+const PACKAGE_NAME = process.env.ABT_NODE_PACKAGE_NAME;
+const VALID_BINARY_NAMES = ['blocklet', 'abtnode'];
+
+console.info(`binary name: ${BINARY_NAME}`);
+console.info(`command name: ${COMMAND_NAME}`);
+console.info(`package name: ${PACKAGE_NAME}`);
+
+// async and promise style of shelljs.exec
+const runAsync = (command, options) =>
+  new Promise((resolve) => {
+    console.info(`Run command: ${command}`);
+    shell.exec(command, { async: true, ...options }, (code, stdout, stderr) => {
+      resolve({ code, stdout, stderr });
+    });
+  });
+
+const getInstaller = () => {
+  const { stdout: pnpmPath } = shell.which('pnpm') || {};
+  if (pnpmPath) {
+    const { stdout: expectedDir } = shell.exec('pnpm bin -g', { silent: true });
+    const { stdout: binPath } = shell.which(BINARY_NAME);
+    if (expectedDir && binPath && expectedDir.trim() === path.dirname(binPath)) {
+      return 'pnpm';
+    }
+  }
+
+  const { stdout: yarnPath } = shell.which('yarn') || {};
+  if (yarnPath) {
+    const { stdout: binaryDir } = shell.exec(`yarn global bin ${BINARY_NAME}`, { silent: true });
+    const binaryPath = path.join(binaryDir, BINARY_NAME);
+    if (fs.existsSync(binaryPath)) {
+      return 'yarn';
+    }
+  }
+
+  return 'npm';
+};
+
+const getBinaryDir = () => {
+  const installer = getInstaller();
+  if (installer === 'pnpm') {
+    const { stdout: binaryDir } = shell.exec('pnpm bin -g', { silent: true });
+    return binaryDir.trim();
+  }
+
+  if (installer === 'yarn') {
+    const { stdout: binaryDir } = shell.exec(`yarn global bin ${BINARY_NAME}`, { silent: true });
+    return binaryDir.trim();
+  }
+
+  const { stdout: binaryDir } = shell.exec(`npm bin -g ${BINARY_NAME}`, { silent: true });
+  return binaryDir.trim();
+};
+
+const installBlockletServer = async (version) => {
+  if (VALID_BINARY_NAMES.includes(BINARY_NAME) === false) {
+    return { code: 1, stderr: 'Abort because you are not using a standard @blocklet/cli setup' };
+  }
+
+  const installer = getInstaller();
+  const commands = {
+    pnpm: `pnpm add -g ${PACKAGE_NAME}@${version} ${VERBOSE}`,
+    npm: `npm install -g ${PACKAGE_NAME}@${version} ${VERBOSE}`,
+    yarn: `yarn global add ${PACKAGE_NAME}@${version} ${VERBOSE}`,
+  };
+  const command = commands[installer];
+  console.info('Installing blocklet server', { version, installer, command });
+  const result = await runAsync(command);
+  console.info('Installing blocklet server done', { version });
+  return result;
+};
+
+const verifyBlockletServer = async (version) => {
+  console.info('Verifying blocklet server', { version });
+  const result = await runAsync(`${BINARY_NAME} --version`);
+  console.info('Verifying blocklet server done', { version });
+
+  if (result.code === 0) {
+    const actual = semver.coerce(result.stdout);
+    if (actual && actual.version === version) {
+      return result;
+    }
+
+    return { code: 1, stderr: `Blocklet server version is not expected ${version}` };
+  }
+
+  return result;
+};
+
+// Restart Blocklet Server
+const restartBlockletServer = async (dataDir) => {
+  // We put this in the event loop because it will terminate the current node process
+  // But we need to wait for the session state to transition from restarting to cleanup
+  process.nextTick(async () => {
+    const binaryDir = getBinaryDir();
+    console.info('Restarting blocklet server', { dataDir, binaryDir });
+
+    if (!binaryDir) {
+      console.error('Can not restart blocklet server because no binaryDir found');
+      return;
+    }
+
+    // restart the server
+    if (VALID_BINARY_NAMES.includes(BINARY_NAME)) {
+      await runAsync(`${binaryDir}/${COMMAND_NAME} start`, { cwd: path.dirname(dataDir) });
+    } else {
+      await runAsync(`${COMMAND_NAME} start`, { cwd: path.dirname(dataDir) });
+    }
+    console.info('Restarting blocklet server done');
+  });
+
+  return dataDir;
+};
+
+// Start the server
+const sock = axon.socket('rep');
+const port = Number(process.env.ABT_NODE_UPDATER_PORT);
+sock.bind(port, '127.0.0.1');
+sock.on('message', async (raw, reply) => {
+  console.info('receive', { raw });
+
+  try {
+    const message = JSON.parse(raw);
+    if (message.command === 'install') {
+      const result = await installBlockletServer(message.version);
+      reply(result);
+    } else if (message.command === 'verify') {
+      const result = await verifyBlockletServer(message.version);
+      reply(result);
+    } else if (message.command === 'restart') {
+      const result = await restartBlockletServer(message.dataDir);
+      reply(result);
+    } else if (message.command === 'shutdown') {
+      reply('Terminate myself after this message');
+      setTimeout(() => {
+        process.exit(0);
+      }, 500);
+    } else if (message.command === 'ping') {
+      reply('pong');
+    } else {
+      reply({ error: 'Unknown command' });
+    }
+  } catch (err) {
+    console.error('failed to process command', { error: err });
+  }
+});
+
+console.info(`Blocklet Server Updater process is ready on port ${port}`);

package/lib/router/helper.js

@@ -61,13 +61,13 @@ const {
   isGatewayCacheEnabled,
   isBlockletSite,
 } = require('../util');
-const { getIpDnsDomainForBlocklet, getDidDomainForBlocklet } = require('../util/get-domain-for-blocklet');
+const { getIpDnsDomainForBlocklet } = require('../util/get-domain-for-blocklet');
 const { getFromCache: getAccessibleExternalNodeIp } = require('../util/get-accessible-external-node-ip');
 
 const Router = require('./index');
 const states = require('../states');
 const { getBlockletDomainGroupName, getDidFromDomainGroupName } = require('../util/router');
-const { getBlockletKnownAs } = require('../util/blocklet');
+const { getBlockletKnownAs, getBlockletDidDomainList } = require('../util/blocklet');
 
 const isServiceFeDevelopment = process.env.ABT_NODE_SERVICE_FE_PORT;
 
@@ -839,13 +839,10 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       });
 
     if (!existSite) {
-      const domainAliases = [];
-
-      const didDomain = getDidDomainForBlocklet({ appPid: blocklet.appPid, didDomain: nodeInfo.didDomain });
-      const ipEchoDnsDomain = getIpDnsDomainForBlocklet(blocklet);
+      const domainAliases = getBlockletDidDomainList(blocklet, nodeInfo);
 
       // let didDomain in front of ipEchoDnsDomain
-      domainAliases.push({ value: didDomain, isProtected: true }, { value: ipEchoDnsDomain, isProtected: true });
+      domainAliases.push({ value: getIpDnsDomainForBlocklet(blocklet), isProtected: true });
 
       await routerManager.addRoutingSite(
         {

package/lib/states/node.js

@@ -125,6 +125,7 @@ class NodeState extends BaseState {
                 docker,
                 mode,
                 enableWelcomePage: mode !== NODE_MODES.SERVERLESS,
+                enableBetaRelease: false,
                 runtimeConfig,
                 ownerNft,
                 diskAlertThreshold: DISK_ALERT_THRESHOLD_PERCENT,

package/lib/states/user.js

@@ -1,11 +1,17 @@
 const pickBy = require('lodash/pickBy');
 const escapeStringRegexp = require('escape-string-regexp');
-
+const pick = require('lodash/pick');
+const cloneDeep = require('lodash/cloneDeep');
 const logger = require('@abtnode/logger')('@abtnode/core:states:user');
 const { isValid } = require('@arcblock/did');
 const { PASSPORT_STATUS } = require('@abtnode/constant');
+const { upsertToPassports } = require('@abtnode/auth/lib/passport');
+const { fromAppDid } = require('@arcblock/did-ext');
+const { types } = require('@arcblock/did');
+
 const BaseState = require('./base');
 const { validateOwner } = require('../util');
+const { loginSchema } = require('../validators/user');
 
 const isNullOrUndefined = (x) => x === undefined || x === null;
 
@@ -39,15 +45,25 @@ const isNullOrUndefined = (x) => x === undefined || x === null;
  * WalletAccount
  * @typedef {Object} WalletAccount
  * @property {'wallet'} provider
- * @property {string} did - did for auth0 account
- * @property {string} pk - pk for auth0 account
+ * @property {string} did - did for wallet account
+ * @property {string} pk - pk for wallet account
+ * @property {string} lastLoginAt - Last login time new Date().toISOString()
+ * @property {string} firstLoginAt - First login time new Date().toISOString()
+ */
+
+/**
+ * NFTAccount
+ * @typedef {Object} NFTAccount
+ * @property {'nft'} provider
+ * @property {string} did - did for nft account
+ * @property {string} owner - owner for nft account
  * @property {string} lastLoginAt - Last login time new Date().toISOString()
  * @property {string} firstLoginAt - First login time new Date().toISOString()
  */
 
 /**
  * ConnectedAccount
- * @typedef {(Auth0Account|WalletAccount)} ConnectedAccount
+ * @typedef {(Auth0Account|WalletAccount|NFTAccount)} ConnectedAccount
  */
 
 /**
@@ -59,7 +75,6 @@ const isNullOrUndefined = (x) => x === undefined || x === null;
  * @property {string} avatar - url of user's avatar, eg: bn://avatar/7f8848569405f8cdf8b1b2788ebf7d0f.jpg
  * @property {string} did - user's did -> 实际上变为 uid, 是不可变的；真正的 wallet-did 转移到 extraConfigs 中去了
  * @property {string} pk - user's publicKey
- * @property {('owner'|'admin'|'member'|'guest'|string)} role - user's role
  * @property {UserPassport[]} passports - user's passport list
  * @property {boolean} approved - enable user to login
  * @property {string} locale - locale
@@ -72,8 +87,36 @@ const isNullOrUndefined = (x) => x === undefined || x === null;
  * @property {string} lastLoginIp - lastLoginIp
  * @property {Date} createdAt - createdAt
  * @property {Date} updatedAt - updatedAt
+ * @property {('owner'|'admin'|'member'|'guest'|string)} role - user's role deprecated
  */
 
+function updateConnectedAccount(connectedAccounts = [], connectedAccount = {}) {
+  const now = new Date().toISOString();
+  const filterAccounts = connectedAccounts.filter(Boolean);
+  const updated = cloneDeep(filterAccounts);
+  const updates = Array.isArray(connectedAccount) ? connectedAccount : [connectedAccount];
+  updates.filter(Boolean).forEach((x) => {
+    if (x.provider && x.did) {
+      const findAccountIndex = updated.findIndex((item) => item.provider === x.provider && item.did === x.did);
+      if (findAccountIndex > -1) {
+        updated[findAccountIndex] = {
+          ...filterAccounts[findAccountIndex],
+          ...x,
+          lastLoginAt: now,
+        };
+      } else {
+        updated.push({
+          ...x,
+          firstLoginAt: now,
+          lastLoginAt: now,
+        });
+      }
+    }
+  });
+
+  return updated;
+}
+
 class User extends BaseState {
   constructor(baseDir, config = {}) {
     super(baseDir, { filename: 'user.db', ...config });
@@ -296,14 +339,124 @@ class User extends BaseState {
     return this.find(queryParam);
   }
 
+  /**
+   * user 版本标准化，统一将 user 转换为最新的结构，结构参考 core/state/lib/states/user.js L12-L75
+   */
+  // 1: 没有 extraConfigs 字段
+  // 2: 有 source 和 extraConfigs 字段，oauth 账号的 extraConfigs 中包含 sourceId 和 sourceProvider 字段
+  // 3: 只有 extraConfigs 字段，且 extraConfigs.connectedAccounts 中包含 extraConfigs.sourceProvider 的 account
+  async normalize(user, { blockletSk }) {
+    if (!user) {
+      return user;
+    }
+    let version = 1;
+    if (user.extraConfigs) {
+      version = 2;
+
+      const connectedAccounts = user.extraConfigs?.connectedAccounts || [];
+      const sourceProvider = user.extraConfigs?.sourceProvider || '';
+      if (connectedAccounts.some((item) => item.provider === sourceProvider)) {
+        version = 3;
+      }
+    }
+
+    const versionMap = {
+      1: async () => {
+        const connectedAccounts = [
+          {
+            provider: 'wallet',
+            did: user.did,
+            pk: user.pk,
+            firstLoginAt: user.firstLoginAt,
+            lastLoginAt: user.lastLoginAt,
+          },
+        ];
+        const sourceProvider = 'wallet';
+        const updatedUser = await this.update({
+          did: user.did,
+          pk: user.pk,
+          extraConfigs: {
+            sourceProvider,
+            connectedAccounts,
+          },
+        });
+        return updatedUser;
+      },
+      2: async () => {
+        // eslint-disable-next-line prefer-const
+        let { sourceId, sourceProvider, connectedAccounts = [] } = user.extraConfigs || {};
+        if (sourceId && sourceProvider) {
+          connectedAccounts = [
+            {
+              provider: sourceProvider,
+              id: sourceId,
+              did: user.did,
+              pk: user.pk,
+              firstLoginAt: user.firstLoginAt,
+              lastLoginAt: user.lastLoginAt,
+            },
+          ];
+        } else {
+          sourceProvider = 'wallet';
+          connectedAccounts.forEach((account) => {
+            if (account.id && blockletSk) {
+              const accountWallet = fromAppDid(account.id, blockletSk, types.RoleType.ROLE_ACCOUNT);
+              account.did = accountWallet.address;
+              account.pk = accountWallet.publicKey;
+              account.firstLoginAt = account.firstLoginAt || new Date().toISOString();
+              account.lastLoginAt = account.lastLoginAt || new Date().toISOString();
+            }
+          });
+          connectedAccounts.unshift({
+            provider: 'wallet',
+            did: user.did,
+            pk: user.pk,
+            firstLoginAt: user.firstLoginAt,
+            lastLoginAt: user.lastLoginAt,
+          });
+        }
+        const updatedUser = await this.update({
+          did: user.did,
+          pk: user.pk,
+          extraConfigs: {
+            sourceProvider,
+            connectedAccounts,
+          },
+          source: undefined,
+        });
+        return updatedUser;
+      },
+      3: () => {
+        return user;
+      },
+    };
+    return versionMap[version]();
+  }
+
   /**
    * get user by did
    * @param {string} did user's did
    * @returns {BlockletUser}
    */
-  async getUser(did) {
-    const doc = await this.findOne({ did });
-    return doc;
+  async getUser(did, { enableConnectedAccout = false, enableNormalize = false, blockletSk } = {}) {
+    let user = await this.findOne({ did });
+    if (enableConnectedAccout) {
+      if (!user) {
+        user = await this.findOne({
+          'extraConfigs.connectedAccounts.did': did,
+        });
+      } else if (user.extraConfig?.bindDid) {
+        // @deprecated 已经不存在 bindDid 字段
+        ({ user } = await this.findOne({ did: user.extraConfig.bindDid }));
+      }
+    }
+    if (enableNormalize) {
+      if (!blockletSk) {
+        throw new Error('Normalize user must provide blockletSk params');
+      }
+      return this.normalize(user, { blockletSk });
+    }
+    return user;
   }
 
   /**
@@ -335,6 +488,82 @@ class User extends BaseState {
 
     return doc;
   }
+
+  /**
+   * 用户登录
+   * @param {Object} user
+   * @param {string} user.did
+   * @param {string} user.pk
+   * @param {ConnectedAccount} user.connectedAccount
+   * @param {passport} user.passport
+   * @param {string} user.fullName - user profile's name
+   * @param {string} user.avatar - url of user's avatar, eg: bn://avatar/7f8848569405f8cdf8b1b2788ebf7d0f.jpg
+   * @param {string} user.locale - locale
+   * @param {Object} [user.extra] - extra data of user
+   * @param {string} user.lastLoginIp - lastLoginIp
+   * @param {('owner'|'admin'|'member'|'guest'|string)} user.role - deprecated user's role
+   */
+  async login(_user) {
+    const { error, value: user } = loginSchema.validate(_user);
+    if (error) {
+      throw new Error(error);
+    }
+
+    let updatedUser;
+    let action = '';
+    const now = new Date().toISOString();
+    const oldUser = await this.getUser(user.did, {
+      enableConnectedAccout: true,
+    });
+    const cloneData = cloneDeep(user);
+    const passports = upsertToPassports(
+      oldUser?.passports || [],
+      cloneData.passport && {
+        ...cloneData.passport,
+        lastLoginAt: now,
+      }
+    );
+    const mergeData = {
+      ...pick(cloneData, ['type', 'fullName', 'email', 'avatar', 'role', 'locale', 'extra', 'lastLoginIp', 'remark']),
+      did: user.did,
+      pk: user.pk,
+      passports,
+      lastLoginAt: now,
+      extraConfigs: {
+        sourceProvider: 'wallet',
+        connectedAccounts: [],
+      },
+    };
+
+    if (oldUser) {
+      // update
+      action = 'update';
+      const extraConfigs = {
+        sourceProvider: oldUser?.extraConfigs?.sourceProvider || 'wallet',
+        connectedAccounts: updateConnectedAccount(
+          oldUser?.extraConfigs?.connectedAccounts || [],
+          cloneData.connectedAccount
+        ),
+      };
+      mergeData.extraConfigs = extraConfigs;
+      updatedUser = await this.update(mergeData);
+    } else {
+      // insert
+      action = 'add';
+      mergeData.firstLoginAt = now;
+      mergeData.approved = true;
+      const connectedAccount = Array.isArray(cloneData.connectedAccount)
+        ? cloneData.connectedAccount.filter(Boolean)[0]
+        : cloneData.connectedAccount;
+
+      mergeData.extraConfigs = {
+        sourceProvider: connectedAccount.provider,
+        connectedAccounts: updateConnectedAccount([], cloneData.connectedAccount),
+      };
+      updatedUser = await this.add(mergeData);
+    }
+    return { ...updatedUser, _action: action };
+  }
 }
 
 module.exports = User;

package/lib/util/blocklet.js

@@ -8,6 +8,8 @@ const os = require('os');
 const pRetry = require('p-retry');
 const tar = require('tar');
 const get = require('lodash/get');
+const uniq = require('lodash/uniq');
+const toLower = require('lodash/toLower');
 const isEmpty = require('lodash/isEmpty');
 const streamToPromise = require('stream-to-promise');
 const { Throttle } = require('stream-throttle');
@@ -18,9 +20,10 @@ const isUrl = require('is-url');
 const semver = require('semver');
 const axios = require('@abtnode/util/lib/axios');
 const { stableStringify } = require('@arcblock/vc');
+const { chainInfo: chainInfoSchema } = require('@arcblock/did-auth/lib/schema');
 
 const { fromSecretKey } = require('@ocap/wallet');
-const { toHex, toBase58, isHex, toDid } = require('@ocap/util');
+const { toHex, toBase58, isHex, toDid, toAddress } = require('@ocap/util');
 const { isValid: isValidDid, isEthereumDid } = require('@arcblock/did');
 const logger = require('@abtnode/logger')('@abtnode/core:util:blocklet');
 const pm2 = require('@abtnode/util/lib/async-pm2');
@@ -78,6 +81,7 @@ const {
   isEnvShareable,
   getBlockletAppIdList,
   isBeforeInstalled,
+  getChainInfo,
 } = require('@blocklet/meta/lib/util');
 const toBlockletDid = require('@blocklet/meta/lib/did');
 const { titleSchema, descriptionSchema, logoSchema } = require('@blocklet/meta/lib/schema');
@@ -294,19 +298,19 @@ const getAppSystemEnvironments = (blocklet, nodeInfo) => {
    * 2. 如果没有，再拼接
    */
 
-  let appUrl = '';
-
+  const pidDomain = getDidDomainForBlocklet({ appPid, didDomain: nodeInfo.didDomain });
   const domainAliases = get(blocklet, 'site.domainAliases') || [];
-  const didDomainAlias = domainAliases.find(
-    (item) => item.value.endsWith(nodeInfo.didDomain) || item.value.endsWith('did.staging.arcblock.io') // did.staging.arcblock.io 是旧 did domain, 但主要存在于比较旧的节点中, 需要做兼容
-  );
 
-  if (didDomainAlias) {
-    appUrl = prettyURL(didDomainAlias.value, true);
-  } else {
-    appUrl = `https://${getDidDomainForBlocklet({ appPid, didDomain: nodeInfo.didDomain })}`;
+  let didDomain = domainAliases.find((item) => toLower(item.value) === toLower(pidDomain));
+
+  if (!didDomain) {
+    didDomain = domainAliases.find(
+      (item) => item.value.endsWith(nodeInfo.didDomain) || item.value.endsWith('did.staging.arcblock.io') // did.staging.arcblock.io 是旧 did domain, 但主要存在于比较旧的节点中, 需要做兼容
+    );
   }
 
+  const appUrl = didDomain ? prettyURL(didDomain.value, true) : `https://${pidDomain}`;
+
   return {
     BLOCKLET_DID: did, // BLOCKLET_DID is always same as BLOCKLET_APP_PID in structV2 application
     BLOCKLET_APP_SK: appSk,
@@ -884,6 +888,21 @@ const validateBlocklet = (blocklet) =>
     validateEngine(getBlockletEngineNameByPlatform(b.meta));
   });
 
+const validateBlockletChainInfo = (blocklet) => {
+  const chainInfo = getChainInfo({
+    CHAIN_TYPE: blocklet.configObj[BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_CHAIN_TYPE],
+    CHAIN_ID: blocklet.configObj[BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_CHAIN_ID],
+    CHAIN_HOST: blocklet.configObj[BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_CHAIN_HOST],
+  });
+
+  const { error } = chainInfoSchema.validate(chainInfo);
+  if (error) {
+    throw error;
+  }
+
+  return chainInfo;
+};
+
 const checkBlockletProcessHealthy = async (blocklet, { minConsecutiveTime, timeout } = {}) => {
   await forEachBlocklet(
     blocklet,
@@ -1885,6 +1904,41 @@ const updateBlockletFallbackLogo = async (blocklet) => {
   }
 };
 
+const ensureAppLogo = async (blocklet, blockletsDir) => {
+  if (!blocklet) {
+    return;
+  }
+
+  if (
+    blocklet.source === BlockletSource.custom &&
+    (blocklet.children || [])[0]?.meta?.logo &&
+    blocklet.children[0].env.appDir
+  ) {
+    const fileName = blocklet.children[0].meta.logo;
+    const src = path.join(blocklet.children[0].env.appDir, fileName);
+    const dist = path.join(getBundleDir(blockletsDir, blocklet.meta), fileName);
+
+    if (fs.existsSync(src)) {
+      await fs.copy(src, dist);
+    }
+  }
+};
+
+const getBlockletDidDomainList = (blocklet, nodeInfo) => {
+  const domainAliases = [];
+  const alsoKnownAs = getBlockletKnownAs(blocklet);
+
+  const dids = [blocklet.appPid, blocklet.appDid, ...alsoKnownAs].filter(Boolean).map((did) => toAddress(did));
+
+  uniq(dids).forEach((did) => {
+    const domain = getDidDomainForBlocklet({ appPid: did, didDomain: nodeInfo.didDomain });
+
+    domainAliases.push({ value: domain, isProtected: true });
+  });
+
+  return domainAliases;
+};
+
 module.exports = {
   updateBlockletFallbackLogo,
   consumeServerlessNFT,
@@ -1897,6 +1951,7 @@ module.exports = {
   getComponentSystemEnvironments,
   getRuntimeEnvironments,
   validateBlocklet,
+  validateBlockletChainInfo,
   fillBlockletConfigs,
   ensureBlockletExpanded,
   startBlockletProcess,
@@ -1941,4 +1996,6 @@ module.exports = {
   validateBlockletMeta,
   getBlockletKnownAs,
   getFixedBundleSource,
+  ensureAppLogo,
+  getBlockletDidDomainList,
 };

package/lib/util/ip.js

@@ -1,9 +1,6 @@
 const getIp = require('@abtnode/util/lib/get-ip');
 const logger = require('@abtnode/logger')('@abtnode/core:ip');
 
-const doRpc = require('./rpc');
-const { memoizeAsync } = require('./index');
-
 let cache = null;
 const fetch = async () => {
   try {
@@ -25,9 +22,6 @@ const cron = {
   fn: fetch,
 };
 
-const lookup = memoizeAsync((ip) => doRpc({ command: 'lookup', ip }));
-
 module.exports.fetch = fetch;
 module.exports.get = get;
 module.exports.cron = cron;
-module.exports.lookup = lookup;