@abtnode/core 1.8.69-beta-54faead3 → 1.8.69-beta-76f8a46f

package/lib/util/blocklet.js

@@ -14,11 +14,12 @@ const ssri = require('ssri');
 const diff = require('deep-diff');
 const createArchive = require('archiver');
 const isUrl = require('is-url');
+const semver = require('semver');
 const axios = require('@abtnode/util/lib/axios');
 const { stableStringify } = require('@arcblock/vc');
 
 const { fromSecretKey, WalletType } = require('@ocap/wallet');
-const { toHex, toBase58, isHex } = require('@ocap/util');
+const { toHex, toBase58, isHex, toDid } = require('@ocap/util');
 const { types } = require('@ocap/mcrypto');
 const { isValid: isValidDid } = require('@arcblock/did');
 const logger = require('@abtnode/logger')('@abtnode/core:util:blocklet');
@@ -30,12 +31,12 @@ const CustomError = require('@abtnode/util/lib/custom-error');
 const getFolderSize = require('@abtnode/util/lib/get-folder-size');
 const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
 const hashFiles = require('@abtnode/util/lib/hash-files');
-const isPathPrefixEqual = require('@abtnode/util/lib/is-path-prefix-equal');
 const {
   BLOCKLET_MAX_MEM_LIMIT_IN_MB,
   BLOCKLET_STORE,
   BLOCKLET_INSTALL_TYPE,
   BLOCKLET_STORE_DEV,
+  APP_STRUCT_VERSION,
 } = require('@abtnode/constant');
 const formatBackSlash = require('@abtnode/util/lib/format-back-slash');
 
@@ -52,12 +53,10 @@ const {
   BLOCKLET_DEFAULT_PORT_NAME,
   BLOCKLET_INTERFACE_TYPE_WEB,
   BLOCKLET_CONFIGURABLE_KEY,
-  BLOCKLET_DYNAMIC_PATH_PREFIX,
   fromBlockletStatus,
   BLOCKLET_PREFERENCE_FILE,
   BLOCKLET_PREFERENCE_PREFIX,
 } = require('@blocklet/constant');
-const verifyMultiSig = require('@blocklet/meta/lib/verify-multi-sig');
 const validateBlockletEntry = require('@blocklet/meta/lib/entry');
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
@@ -91,13 +90,16 @@ const {
   isBeforeInstalled,
   expandBundle,
   findInterfacePortByName,
-  validateBlockletMeta,
   prettyURL,
   getNFTState,
   templateReplace,
 } = require('./index');
 
-const getComponentConfig = (meta) => meta.components || meta.children;
+const getComponentConfig = (meta) => {
+  const components = meta.components || meta.children || [];
+  const staticComponents = (meta.staticComponents || []).map((x) => ({ ...x, static: true }));
+  return [...components, ...staticComponents];
+};
 
 /**
  * get blocklet engine info, default is node
@@ -284,6 +286,10 @@ const getAppSystemEnvironments = (blocklet, nodeInfo) => {
   const appName = title || name || result.name;
   const appDescription = description || result.description;
 
+  const isMigrated = Array.isArray(blocklet.migratedFrom) && blocklet.migratedFrom.length > 0;
+  const appPid = blocklet.appPid || appId;
+  const appPsk = isMigrated ? blocklet.migratedFrom[0].appSk : appSk;
+
   /* 获取 did domain 方式:
    * 1. 先从 site 里读
    * 2. 如果没有，再拼接
@@ -299,16 +305,9 @@ const getAppSystemEnvironments = (blocklet, nodeInfo) => {
   if (didDomainAlias) {
     appUrl = prettyURL(didDomainAlias.value, true);
   } else {
-    appUrl = `https://${getDidDomainForBlocklet({
-      blockletAppDid: appId,
-      didDomain: nodeInfo.didDomain,
-    })}`;
+    appUrl = `https://${getDidDomainForBlocklet({ appPid, didDomain: nodeInfo.didDomain })}`;
   }
 
-  const isMigrated = Array.isArray(blocklet.migratedFrom) && blocklet.migratedFrom.length > 0;
-  const appPid = blocklet.appPid || appId;
-  const appPsk = isMigrated ? blocklet.migratedFrom[0].appSk : appSk;
-
   return {
     BLOCKLET_DID: did,
     BLOCKLET_APP_SK: appSk,
@@ -743,75 +742,78 @@ const reloadProcess = (processId) =>
     });
   });
 
-const parseChildren = (children, parentMeta = {}, { dynamic } = {}) => {
-  const configs = Array.isArray(parentMeta) ? parentMeta : getComponentConfig(parentMeta) || [];
-
-  children.forEach((x) => {
-    if (dynamic !== undefined) {
-      x.dynamic = !!dynamic;
-    }
-  });
-
-  mergeMeta(configs, children);
-  return children;
-};
-
 /**
- * this function has side effect on children
+ * this function has side effect to component (will set component.children: Array<staticComponent> )
+ * this function has side effect to dynamicComponents (will push dynamicComponent in dynamicComponents)
+ *
+ * @param {Component} component
+ * @param {{
+ *   ancestors: Array<{meta}>
+ *   dynamicComponents: Array<{Component}>
+ * }} context
+ * @returns {{
+ *   dynamicComponents: Array<Component>,
+ *   staticComponents: Array<Component>,
+ * }}
  */
-const parseChildrenFromMeta = async (src, context = {}) => {
-  const { dynamic, ancestors = [] } = context;
+const parseComponents = async (component, context = {}) => {
+  const { ancestors = [], dynamicComponents = [] } = context;
   if (ancestors.length > 40) {
     throw new Error('The depth of component should not exceed 40');
   }
 
-  const configs = Array.isArray(src) ? src : getComponentConfig(src) || [];
+  const configs = getComponentConfig(component.meta) || [];
 
   if (!configs || !configs.length) {
-    return [];
+    return {
+      staticComponents: [],
+      dynamicComponents,
+    };
   }
 
-  const children = [];
+  const staticComponents = [];
 
+  // FIXME @linchen 改成并行获取
   for (const config of configs) {
-    const mountPoint = config.mountPoint || config.mountPoints[0].root.prefix;
-    if (!mountPoint) {
-      throw new Error(`MountPoint does not found in child ${config.name}`);
+    const isStatic = !!config.static;
+
+    if (isStatic) {
+      if (!config.name) {
+        throw new Error(`Name does not found in child ${config.name}`);
+      }
+
+      if (!config.mountPoint) {
+        throw new Error(`MountPoint does not found in child ${config.name}`);
+      }
     }
 
     const urls = getSourceUrlsFromConfig(config);
 
-    let m;
+    let rawMeta;
     try {
-      m = await getBlockletMetaFromUrls(urls, { logger });
-    } catch {
-      throw new Error(`Failed get component meta: ${config.title || config.name}`);
+      rawMeta = await getBlockletMetaFromUrls(urls, { logger });
+    } catch (error) {
+      throw new Error(
+        `Failed get component meta. Component: ${rawMeta.title || rawMeta.did}, reason: ${error.message}`
+      );
     }
 
-    validateBlockletMeta(m, { ensureDist: true });
-
-    if (!isComponentBlocklet(m)) {
-      throw new Error(`The blocklet cannot be a component: ${m.title}`);
+    if (rawMeta.group === BlockletGroup.gateway) {
+      throw new Error(`Cannot add gateway component ${rawMeta.title || rawMeta.did}`);
     }
 
-    const webInterface = findWebInterface(m);
-    if (!webInterface) {
-      throw new Error(`Web interface does not found in child ${config.name}`);
+    validateBlockletMeta(rawMeta, { ensureDist: true });
+
+    if (!isComponentBlocklet(rawMeta)) {
+      throw new Error(`The blocklet cannot be a component: ${rawMeta.title}`);
     }
 
-    // validate mountPoint
-    const rule = webInterface.prefix;
-    if (rule !== BLOCKLET_DYNAMIC_PATH_PREFIX) {
-      const fullMountPoint = path.join(
-        ancestors.map((x) => x.mountPoint || ''),
-        mountPoint
-      );
-      if (normalizePathPrefix(rule) !== normalizePathPrefix(fullMountPoint)) {
-        throw new Error(`Prefix does not match in child ${config.name}. expected: ${rule}, resolved: ${mountPoint}`);
-      }
+    const webInterface = findWebInterface(rawMeta);
+    if (!webInterface) {
+      throw new Error(`Web interface does not found in component ${rawMeta.title || rawMeta.name}`);
     }
 
-    const meta = ensureMeta(m, { name: config.name });
+    const meta = ensureMeta(rawMeta, { name: isStatic ? config.name : null });
 
     // check circular dependencies
     if (ancestors.map((x) => x.meta?.bundleDid).indexOf(meta.bundleDid) > -1) {
@@ -822,28 +824,44 @@ const parseChildrenFromMeta = async (src, context = {}) => {
       meta.title = config.title;
       meta.title = await titleSchema.validateAsync(config.title);
     }
+
     if (config.description) {
       meta.description = await descriptionSchema.validateAsync(config.description);
     }
 
+    const mountPoint = isStatic ? config.mountPoint : config.mountPoint || `/${meta.did}`;
+
     const child = {
       mountPoint,
       meta,
-      bundleSource: config.source || { url: config.resolved },
+      bundleSource: config.source,
+      dependencies: [],
     };
 
-    child.children = await parseChildrenFromMeta(meta, {
-      ...context,
-      ancestors: [...ancestors, { meta, mountPoint }],
-      dynamic: false,
-    });
+    if (isStatic) {
+      staticComponents.push(child);
+    } else {
+      dynamicComponents.push(child);
+      component.dependencies = component.dependencies || [];
+      component.dependencies.push({
+        did: child.meta.bundleDid,
+        required: !!config.required,
+        version: config.source.version || 'latest',
+      });
+    }
 
-    children.push(child);
+    await parseComponents(child, {
+      ancestors: [...ancestors, { meta }],
+      dynamicComponents,
+    });
   }
 
-  parseChildren(children, configs, { dynamic });
+  component.children = staticComponents;
 
-  return children;
+  return {
+    staticComponents,
+    dynamicComponents,
+  };
 };
 
 const validateBlocklet = (blocklet) =>
@@ -1166,43 +1184,6 @@ const mergeMeta = (source, childrenMeta = []) => {
   });
 };
 
-const fixAndVerifyMetaFromStore = (meta) => {
-  // strip unknown properties
-  // rename property alias
-
-  const sanitized = validateMeta(meta, { ensureDist: false, schemaOptions: { noDefaults: true, stripUnknown: true } });
-
-  // rollback meta renamed by validateMeta
-
-  if (meta.children) {
-    sanitized.children = meta.children;
-    delete sanitized.components;
-  }
-
-  if (meta.navigation) {
-    meta.navigation.forEach((nav, index) => {
-      if (nav.child) {
-        sanitized.navigation[index].child = nav.child;
-        delete sanitized.navigation[index].component;
-      }
-    });
-  }
-
-  // verify
-
-  try {
-    const result = verifyMultiSig(sanitized);
-    if (!result) {
-      throw new Error('invalid signature from developer or store');
-    }
-  } catch (err) {
-    throw new Error(`Invalid blocklet meta: ${err.message}`);
-  }
-
-  // this step comes last because it has side effects: the meta is changed
-  return fixAndValidateService(meta);
-};
-
 const getUpdateMetaList = (oldBlocklet = {}, newBlocklet = {}) => {
   const oldMap = {};
   forEachChildSync(oldBlocklet, (b, { id }) => {
@@ -1238,7 +1219,7 @@ const getTypeFromInstallParams = (params) => {
   }
 
   if (params.file) {
-    return BLOCKLET_INSTALL_TYPE.UPLOAD;
+    throw new Error('install from upload is not supported');
   }
 
   if (params.did) {
@@ -1263,13 +1244,6 @@ const checkDuplicateComponents = (components = []) => {
         .join(', ')}`
     );
   }
-
-  const duplicateMountPoints = components.filter(
-    (item, index) => components.findIndex((x) => isPathPrefixEqual(x.mountPoint, item.mountPoint)) !== index
-  );
-  if (duplicateMountPoints.length) {
-    throw new Error(`mount point must be unique: ${duplicateMountPoints.map((x) => x.mountPoint).join(', ')}`);
-  }
 };
 
 const getDiffFiles = async (inputFiles, sourceDir) => {
@@ -1327,32 +1301,30 @@ const needBlockletDownload = (blocklet, oldBlocklet) => {
   return get(oldBlocklet, 'meta.dist.integrity') !== get(blocklet, 'meta.dist.integrity');
 };
 
-const findAvailableDid = (meta, siblings) => {
-  const reg = /-(\d+)$/;
-  const match = reg.exec(meta.name);
-
-  const newName = match ? meta.name.replace(reg, `-${Number(match[1]) + 1}`) : `${meta.name}-1`;
-  const newDid = toBlockletDid(newName);
-  const newMeta = { name: newName, did: newDid };
-
-  if (!(siblings || []).some((x) => x.did === newMeta.did)) {
-    return newMeta;
+const isDidMatchName = (did, name) => {
+  if (isValidDid(did) && name === did) {
+    return true;
   }
 
-  return findAvailableDid(newMeta, siblings);
+  return toBlockletDid(name) === did;
 };
 
+/**
+ * set bundleDid and bundleMeta in meta
+ * update name and did to server index
+ * in app structure 2.0, application's bundleDid, bundleName, meta, did will be same
+ */
 const ensureMeta = (meta, { name, did } = {}) => {
-  if (name && did && toBlockletDid(name) !== did) {
-    throw new Error('name does not match with did');
+  if (name && did && !isDidMatchName(did, name)) {
+    throw new Error(`name does not match with did: ${name}, ${did}`);
   }
 
   const newMeta = {
     ...meta,
   };
 
-  if (!newMeta.did || !newMeta.name || toBlockletDid(newMeta.name) !== newMeta.did) {
-    throw new Error('name does not match with did in meta');
+  if (!newMeta.did || !newMeta.name || !isDidMatchName(newMeta.did, newMeta.name)) {
+    throw new Error(`name does not match with did in meta: ${newMeta.name}, ${newMeta.did}`);
   }
 
   if (!meta.bundleDid) {
@@ -1740,7 +1712,10 @@ const checkDuplicateAppSk = async ({ sk, did, states }) => {
 
 const checkDuplicateMountPoint = (blocklet, mountPoint) => {
   const err = new Error(`cannot add duplicate mount point, ${mountPoint || '/'} already exist`);
-  if (normalizePathPrefix(blocklet.mountPoint) === normalizePathPrefix(mountPoint)) {
+  if (
+    blocklet.meta?.group !== BlockletGroup.gateway &&
+    normalizePathPrefix(blocklet.mountPoint) === normalizePathPrefix(mountPoint)
+  ) {
     throw err;
   }
 
@@ -1777,12 +1752,79 @@ const validateInServerless = ({ blockletMeta }) => {
   }
 };
 
+const checkStructVersion = (blocklet) => {
+  if (blocklet.structVersion !== APP_STRUCT_VERSION) {
+    throw new Error('You should migrate the application first');
+  }
+};
+
+const isVersionCompatible = (actualVersion, expectedRange) =>
+  !expectedRange || expectedRange === 'latest' || semver.satisfies(actualVersion, expectedRange);
+
+const checkVersionCompatibility = (components) => {
+  for (const component of components) {
+    // eslint-disable-next-line no-loop-func
+    forEachBlockletSync(component, (x) => {
+      const dependencies = x.dependencies || [];
+      dependencies.forEach((dep) => {
+        const { did, version: expectedRange } = dep;
+        const exist = components.find((y) => y.meta.did === did);
+        if (exist && !isVersionCompatible(exist.meta.version, expectedRange)) {
+          throw new Error(
+            `Check version compatible failed: ${component.meta.title || component.meta.did} expects ${
+              exist.meta.title || exist.meta.did
+            }'s version to be ${expectedRange}, but actual is ${exist.meta.version}`
+          );
+        }
+      });
+    });
+  }
+};
+
+const filterDuplicateComponents = (components = [], currents = []) => {
+  const arr = [];
+
+  components.forEach((component) => {
+    if (currents.some((x) => x.meta.did === component.meta.did)) {
+      return;
+    }
+
+    const index = arr.findIndex((x) => x.meta.did === component.meta.did);
+    if (index > -1) {
+      const exist = arr[index];
+
+      // 选择最小版本:
+      // 如果 com1 和 com2 都依赖某个 component, com1 声明依赖版本 1.0.0, 实际获取版本 1.0.0; com2 声明依赖版本 latest(不限), 实际获取版本 2.0.0 -> 则应该取 1.0.0
+      if (semver.lt(component.meta.version, exist.meta.version)) {
+        arr.splice(index, 1, component);
+      }
+    } else {
+      arr.push(component);
+    }
+  });
+
+  return arr;
+};
+
+const validateBlockletMeta = (meta, opts = {}) => {
+  fixAndValidateService(meta);
+  return validateMeta(meta, { ensureName: true, skipValidateDidName: true, schemaOptions: { ...opts } });
+};
+
+const getBlockletKnownAs = (blocklet) => {
+  const alsoKnownAs = [blocklet.appDid];
+  if (Array.isArray(blocklet.migratedFrom)) {
+    blocklet.migratedFrom.filter((x) => x.appDid !== blocklet.appPid).forEach((x) => alsoKnownAs.push(x.appDid));
+  }
+
+  return alsoKnownAs.filter(Boolean).map(toDid);
+};
+
 module.exports = {
   consumeServerlessNFT,
   forEachBlocklet,
   getBlockletMetaFromUrl: (url) => getBlockletMetaFromUrl(url, { logger }),
-  parseChildrenFromMeta,
-  parseChildren,
+  parseComponents,
   getComponentDirs,
   getAppSystemEnvironments,
   getAppOverwrittenEnvironments,
@@ -1807,15 +1849,14 @@ module.exports = {
   getDiskInfo,
   getRuntimeInfo,
   mergeMeta,
-  fixAndVerifyMetaFromStore,
   getUpdateMetaList,
   getTypeFromInstallParams,
   findWebInterface,
   checkDuplicateComponents,
+  filterDuplicateComponents,
   getDiffFiles,
   getBundleDir,
   needBlockletDownload,
-  findAvailableDid,
   ensureMeta,
   getBlocklet,
   ensureEnvDefault,
@@ -1829,4 +1870,8 @@ module.exports = {
   checkDuplicateMountPoint,
   validateStore,
   validateInServerless,
+  checkStructVersion,
+  checkVersionCompatibility,
+  validateBlockletMeta,
+  getBlockletKnownAs,
 };

package/lib/util/get-domain-for-blocklet.js

@@ -1,22 +1,13 @@
-const { DEFAULT_IP_DOMAIN_SUFFIX } = require('@abtnode/constant');
+const { DEFAULT_IP_DOMAIN_SUFFIX, SLOT_FOR_IP_DNS_SITE } = require('@abtnode/constant');
 const { encode: encodeBase32 } = require('@abtnode/util/lib/base32');
 const formatName = require('@abtnode/util/lib/format-name');
 
-const SLOT_FOR_IP_DNS_SITE = '888-888-888-888';
-
-const hiddenInterfaceNames = ['public', 'publicUrl'];
-
-const getIpDnsDomainForBlocklet = (blocklet, blockletInterface) => {
-  const nameSuffix = blocklet.meta.did.slice(-3).toLowerCase();
-  const iName = hiddenInterfaceNames.includes(blockletInterface.name) ? '' : blockletInterface.name.toLowerCase();
-
-  return `${formatName(blocklet.meta.name)}-${nameSuffix}${
-    iName ? '-' : ''
-  }${iName}-${SLOT_FOR_IP_DNS_SITE}.${DEFAULT_IP_DOMAIN_SUFFIX}`;
+const getIpDnsDomainForBlocklet = (blocklet) => {
+  return `${encodeBase32(blocklet.meta.did)}-${SLOT_FOR_IP_DNS_SITE}.${DEFAULT_IP_DOMAIN_SUFFIX}`;
 };
 
-const getDidDomainForBlocklet = ({ blockletAppDid, didDomain }) => {
-  return `${encodeBase32(blockletAppDid)}.${didDomain}`;
+const getDidDomainForBlocklet = ({ appPid, didDomain }) => {
+  return `${encodeBase32(appPid)}.${didDomain}`;
 };
 
 module.exports = { getIpDnsDomainForBlocklet, getDidDomainForBlocklet, formatName };

package/lib/util/get-meta-from-url.js

@@ -0,0 +1,33 @@
+const { isFreeBlocklet } = require('@blocklet/meta/lib/util');
+
+const logger = require('@abtnode/logger')('getMetaFromUrl');
+
+const { getBlockletMetaFromUrl } = require('./blocklet');
+const { getStoreMeta, parseSourceUrl } = require('./store');
+const { getFactoryState } = require('./chain');
+
+const getMetaFromUrl = async ({ url, checkPrice = false }) => {
+  const meta = await getBlockletMetaFromUrl(url);
+  let isFree = isFreeBlocklet(meta);
+
+  if (checkPrice && !isFree && meta.nftFactory) {
+    try {
+      const registryMeta = await getStoreMeta(new URL(url).origin);
+
+      if (registryMeta.chainHost) {
+        const state = await getFactoryState(registryMeta.chainHost, meta.nftFactory);
+        if (state) {
+          isFree = false;
+        }
+      }
+    } catch (error) {
+      logger.warn('failed when checking if the blocklet is free', { did: meta.did, error });
+    }
+  }
+
+  const { inStore, registryUrl } = await parseSourceUrl(url);
+
+  return { meta, isFree, inStore, registryUrl };
+};
+
+module.exports = getMetaFromUrl;

package/lib/util/index.js

@@ -16,7 +16,6 @@ const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
 const axios = require('@abtnode/util/lib/axios');
 const { encode: encodeBase32 } = require('@abtnode/util/lib/base32');
 const parseBlockletMeta = require('@blocklet/meta/lib/parse');
-const { validateMeta, fixAndValidateService } = require('@blocklet/meta/lib/validate');
 const { BlockletStatus } = require('@blocklet/constant');
 const { replaceSlotToIp } = require('@blocklet/meta/lib/util');
 const {
@@ -493,10 +492,6 @@ const lib = {
   getDataDirs,
   getBaseUrls,
   getBlockletMeta: parseBlockletMeta,
-  validateBlockletMeta: (meta, opts = {}) => {
-    fixAndValidateService(meta);
-    return validateMeta(meta, opts);
-  },
   expandBundle,
   findInterfaceByName,
   findInterfacePortByName,

package/lib/util/store.js

@@ -3,14 +3,47 @@ const pick = require('lodash/pick');
 const isBase64 = require('is-base64');
 
 const { BLOCKLET_STORE_API_PREFIX, BLOCKLET_STORE_META_PATH } = require('@abtnode/constant');
+const { validateMeta, fixAndValidateService } = require('@blocklet/meta/lib/validate');
+const verifyMultiSig = require('@blocklet/meta/lib/verify-multi-sig');
 
 const { name } = require('../../package.json');
 const logger = require('@abtnode/logger')(`${name}:util:registry`); // eslint-disable-line
 
 const request = require('./request');
-const { fixAndVerifyMetaFromStore } = require('./blocklet');
 
-const validateRegistryURL = async (registry) => {
+const fixAndVerifyMetaFromStore = (meta) => {
+  const sanitized = validateMeta(meta, { ensureDist: false, schemaOptions: { noDefaults: true, stripUnknown: true } });
+
+  if (meta.children) {
+    sanitized.children = meta.children;
+    delete sanitized.components;
+  }
+
+  if (meta.navigation) {
+    meta.navigation.forEach((nav, index) => {
+      if (nav.child) {
+        sanitized.navigation[index].child = nav.child;
+        delete sanitized.navigation[index].component;
+      }
+    });
+  }
+
+  // verify
+
+  try {
+    const result = verifyMultiSig(sanitized);
+    if (!result) {
+      throw new Error('invalid signature from developer or store');
+    }
+  } catch (err) {
+    throw new Error(`Invalid blocklet meta: ${err.message}`);
+  }
+
+  // this step comes last because it has side effects: the meta is changed
+  return fixAndValidateService(meta);
+};
+
+const validateStoreUrl = async (registry) => {
   const url = joinURL(registry, BLOCKLET_STORE_API_PREFIX, `/blocklets.json?__t__=${Date.now()}`);
   try {
     const res = await request.get(url);
@@ -26,7 +59,7 @@ const validateRegistryURL = async (registry) => {
   }
 };
 
-const getRegistryMeta = async (registry) => {
+const getStoreMeta = async (registry) => {
   try {
     const url = joinURL(registry, BLOCKLET_STORE_META_PATH, `?__t__=${Date.now()}`);
     const { data } = await request.get(url);
@@ -66,7 +99,7 @@ const parseSourceUrl = async (url) => {
   const match = pathname.match(/^\/api\/blocklets\/(\w*)\/blocklet\.json/);
   if (match) {
     try {
-      const m = await getRegistryMeta(origin);
+      const m = await getStoreMeta(origin);
       if (m && m.id) {
         return {
           inStore: true,
@@ -108,6 +141,9 @@ const resolveTarballURL = async ({ did, tarball = '', storeUrl = '' }) => {
   return joinURL(storeUrl, 'api', 'blocklets', did, tarball);
 };
 
+const getBlockletMetaUrl = ({ did, storeUrl }) =>
+  joinURL(storeUrl, BLOCKLET_STORE_API_PREFIX, `/blocklets/${did}/blocklet.json`);
+
 const getBlockletMeta = async ({ did, storeUrl }) => {
   const url = joinURL(storeUrl, BLOCKLET_STORE_API_PREFIX, `/blocklets/${did}/blocklet.json?__t__=${Date.now()}`);
 
@@ -133,9 +169,11 @@ const getBlockletMeta = async ({ did, storeUrl }) => {
 };
 
 module.exports = {
-  validateRegistryURL,
-  getRegistryMeta,
+  validateStoreUrl,
+  getStoreMeta,
   parseSourceUrl,
   getBlockletMeta,
   resolveTarballURL,
+  getBlockletMetaUrl,
+  fixAndVerifyMetaFromStore,
 };

package/lib/webhook/sender/wallet/index.js

@@ -35,6 +35,9 @@ class WalletSender extends BaseSender {
 
       await sendToUser(adminUsers, message, sender, process.env.ABT_NODE_SERVICE_PORT);
     } catch (error) {
+      delete error.request;
+      delete error.response;
+      delete error.config;
       logger.error('failed to push notification to wallet', { error });
     }
   }