@abtnode/core 1.16.11-beta-0ae58a71 → 1.16.11-beta-f74663ac

package/lib/util/blocklet.js

@@ -3,10 +3,8 @@
 const fs = require('fs-extra');
 const path = require('path');
 const dayjs = require('dayjs');
-const joinURL = require('url-join');
 const shelljs = require('shelljs');
 const os = require('os');
-const pRetry = require('p-retry');
 const tar = require('tar');
 const get = require('lodash/get');
 const uniq = require('lodash/uniq');
@@ -19,19 +17,16 @@ 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 { chainInfo: chainInfoSchema } = require('@arcblock/did-auth/lib/schema');
 
 const { fromSecretKey } = require('@ocap/wallet');
-const { toHex, toBase58, isHex, toDid, toAddress } = require('@ocap/util');
+const { toHex, 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');
 const sleep = require('@abtnode/util/lib/sleep');
 const getPm2ProcessInfo = require('@abtnode/util/lib/get-pm2-process-info');
 const killProcessOccupiedPorts = require('@abtnode/util/lib/kill-process-occupied-ports');
-const getNodeWallet = require('@abtnode/util/lib/get-app-wallet');
 const { formatEnv } = require('@abtnode/util/lib/security');
 const ensureEndpointHealthy = require('@abtnode/util/lib/ensure-endpoint-healthy');
 const CustomError = require('@abtnode/util/lib/custom-error');
@@ -79,6 +74,7 @@ const {
   findWebInterface,
   forEachBlockletSync,
   forEachChildSync,
+  forEachComponentV2Sync,
   isComponentBlocklet,
   getSharedConfigObj,
   getComponentName,
@@ -86,6 +82,8 @@ const {
   getBlockletAppIdList,
   isBeforeInstalled,
   getChainInfo,
+  isInProgress,
+  isRunning,
 } = require('@blocklet/meta/lib/util');
 const toBlockletDid = require('@blocklet/meta/lib/did');
 const { titleSchema, descriptionSchema, logoSchema } = require('@blocklet/meta/lib/schema');
@@ -100,7 +98,7 @@ const { validate: validateEngine, get: getEngine } = require('../blocklet/manage
 
 const isRequirementsSatisfied = require('./requirement');
 const { getDidDomainForBlocklet } = require('./get-domain-for-blocklet');
-const { expandBundle, findInterfacePortByName, prettyURL, getNFTState, templateReplace } = require('./index');
+const { expandBundle, findInterfacePortByName, prettyURL, templateReplace } = require('./index');
 const externalIpUtil = require('./get-accessible-external-node-ip');
 const { getIpDnsDomainForBlocklet } = require('./get-domain-for-blocklet');
 const { replaceDomainSlot } = require('./index');
@@ -373,8 +371,9 @@ const getComponentSystemEnvironments = (blocklet) => {
   }
 
   return {
-    BLOCKLET_REAL_DID: blocklet.env.id,
+    BLOCKLET_REAL_DID: blocklet.env.id, // <appDid>/componentDid> e.g. xxxxx/xxxxx
     BLOCKLET_REAL_NAME: blocklet.env.name,
+    BLOCKLET_COMPONENT_DID: blocklet.meta.did, // component meta did e.g. xxxxxx
     BLOCKLET_DATA_DIR: blocklet.env.dataDir,
     BLOCKLET_LOG_DIR: blocklet.env.logsDir,
     BLOCKLET_CACHE_DIR: blocklet.env.cacheDir,
@@ -506,7 +505,15 @@ const getHealthyCheckTimeout = (blocklet, { checkHealthImmediately } = {}) => {
  */
 const startBlockletProcess = async (
   blocklet,
-  { preStart = noop, postStart = noopAsync, nodeEnvironments, nodeInfo, e2eMode, skippedProcessIds = [] } = {}
+  {
+    preStart = noop,
+    postStart = noopAsync,
+    nodeEnvironments,
+    nodeInfo,
+    e2eMode,
+    skippedProcessIds = [],
+    componentDids,
+  } = {}
 ) => {
   if (!blocklet) {
     throw new Error('blocklet should not be empty');
@@ -522,7 +529,12 @@ const startBlockletProcess = async (
       const { appMain, processId, appCwd, logsDir } = b.env;
 
       if (skippedProcessIds.includes(processId)) {
-        logger.info(`skip start process ${processId}`);
+        logger.info(`skip start skipped process ${processId}`);
+        return;
+      }
+
+      if (shouldSkipComponent(b.meta.did, componentDids)) {
+        logger.info(`skip start process not selected: ${b.meta.did}`, { processId });
         return;
       }
 
@@ -623,31 +635,15 @@ const startBlockletProcess = async (
  * Stop all precesses of a blocklet
  * @param {*} blocklet should contain env props
  */
-const stopBlockletProcess = async (blocklet, { preStop = noop, skippedProcessIds = [] } = {}) => {
-  await forEachBlocklet(
-    blocklet,
-    async (b, { ancestors }) => {
-      if (b.meta?.group === BlockletGroup.gateway) {
-        return;
-      }
-
-      if (skippedProcessIds.includes(b.env.processId)) {
-        logger.info(`skip stop process ${b.env.processId}`);
-        return;
-      }
-
-      await preStop(b, { ancestors });
-      await deleteProcess(b.env.processId);
-    },
-    { parallel: true }
-  );
+const stopBlockletProcess = (blocklet, { preStop = noop, skippedProcessIds = [], componentDids } = {}) => {
+  return deleteBlockletProcess(blocklet, { preDelete: preStop, skippedProcessIds, componentDids });
 };
 
 /**
  * Delete all precesses of a blocklet
  * @param {*} blocklet should contain env props
  */
-const deleteBlockletProcess = async (blocklet, { preDelete = noop, skippedProcessIds = [] } = {}) => {
+const deleteBlockletProcess = async (blocklet, { preDelete = noop, skippedProcessIds = [], componentDids } = {}) => {
   await forEachBlocklet(
     blocklet,
     async (b, { ancestors }) => {
@@ -657,7 +653,12 @@ const deleteBlockletProcess = async (blocklet, { preDelete = noop, skippedProces
       }
 
       if (skippedProcessIds.includes(b.env.processId)) {
-        logger.info(`skip delete process ${b.env.processId}`);
+        logger.info(`skip delete skipped process ${b.env.processId}`);
+        return;
+      }
+
+      if (shouldSkipComponent(b.meta?.did, componentDids)) {
+        logger.info(`skip delete process not selected: ${b.meta.did}`, { processId: b.env.processId });
         return;
       }
 
@@ -672,52 +673,25 @@ const deleteBlockletProcess = async (blocklet, { preDelete = noop, skippedProces
  * Reload all precesses of a blocklet
  * @param {*} blocklet should contain env props
  */
-const reloadBlockletProcess = async (blocklet) =>
+const reloadBlockletProcess = (blocklet, { componentDids } = {}) =>
   forEachBlocklet(
     blocklet,
     async (b) => {
       if (b.meta.group === BlockletGroup.gateway) {
         return;
       }
+
+      if (shouldSkipComponent(b.meta.did, componentDids)) {
+        logger.info(`skip reload process not selected: ${b.meta.did}`, { processId: b.env.processId });
+        return;
+      }
+
       logger.info('reload process', { processId: b.env.processId });
       await reloadProcess(b.env.processId);
     },
     { parallel: false }
   );
 
-const getBlockletStatusFromProcess = async (blocklet) => {
-  const tasks = [];
-  await forEachBlocklet(blocklet, (b) => {
-    if (b.meta.group !== BlockletGroup.gateway) {
-      tasks.push(getProcessState(b.env.processId));
-    }
-  });
-
-  const list = await Promise.all(tasks);
-
-  if (!list.length) {
-    return blocklet.status;
-  }
-
-  return getRootBlockletStatus(list);
-};
-
-/**
- * @param {Array<BlockletStatus>} statusList
- */
-const getRootBlockletStatus = (statusList = []) => {
-  const noRunningStatus = statusList.find((x) => x !== BlockletStatus.running);
-  if (noRunningStatus) {
-    if (statusList.some((x) => x === BlockletStatus.error)) {
-      return BlockletStatus.error;
-    }
-
-    return noRunningStatus;
-  }
-
-  return BlockletStatus.running;
-};
-
 /**
  * @param {*} processId
  * @returns {BlockletStatus}
@@ -740,7 +714,7 @@ const getProcessInfo = (processId, { throwOnNotExist = true } = {}) =>
 
 const deleteProcess = (processId) =>
   new Promise((resolve, reject) => {
-    pm2.delete(processId, async (err) => {
+    pm2.delete(processId, (err) => {
       if (isUsefulError(err)) {
         logger.error('blocklet process delete failed', { error: err });
         return reject(err);
@@ -751,7 +725,7 @@ const deleteProcess = (processId) =>
 
 const reloadProcess = (processId) =>
   new Promise((resolve, reject) => {
-    pm2.reload(processId, async (err) => {
+    pm2.reload(processId, (err) => {
       if (err) {
         if (isUsefulError(err)) {
           logger.error('blocklet reload failed', { error: err });
@@ -885,7 +859,7 @@ const parseComponents = async (component, context = {}) => {
 };
 
 const validateBlocklet = (blocklet) =>
-  forEachBlocklet(blocklet, async (b) => {
+  forEachBlocklet(blocklet, (b) => {
     isRequirementsSatisfied(b.meta.requirements);
     validateEngine(getBlockletEngineNameByPlatform(b.meta));
   });
@@ -905,19 +879,28 @@ const validateBlockletChainInfo = (blocklet) => {
   return chainInfo;
 };
 
-const checkBlockletProcessHealthy = async (blocklet, { minConsecutiveTime, timeout } = {}) => {
+const checkBlockletProcessHealthy = async (blocklet, { minConsecutiveTime, timeout, componentDids } = {}) => {
   await forEachBlocklet(
     blocklet,
     async (b) => {
-      if (b.meta.group !== BlockletGroup.gateway) {
-        await _checkProcessHealthy(b, { minConsecutiveTime, timeout });
+      if (b.meta.group === BlockletGroup.gateway) {
+        return;
       }
+
+      if (shouldSkipComponent(b.meta.did, componentDids)) {
+        logger.info('skip check component healthy not selected', { id: b.env.id, processId: b.env.processId });
+        return;
+      }
+
+      const logToTerminal = [blocklet.mode, b.mode].includes(BLOCKLET_MODES.DEVELOPMENT);
+
+      await _checkProcessHealthy(b, { minConsecutiveTime, timeout, logToTerminal });
     },
     { parallel: true }
   );
 };
 
-const _checkProcessHealthy = async (blocklet, { minConsecutiveTime, timeout }) => {
+const _checkProcessHealthy = async (blocklet, { minConsecutiveTime, timeout, logToTerminal }) => {
   const { meta, ports, env } = blocklet;
   const { name } = meta;
   const { processId } = env;
@@ -953,6 +936,14 @@ const _checkProcessHealthy = async (blocklet, { minConsecutiveTime, timeout }) =
     }
 
     const port = findInterfacePortByName({ meta, ports }, webInterface.name);
+    if (logToTerminal) {
+      // eslint-disable-next-line no-console
+      console.log(
+        `Checking endpoint healthy for ${meta.title}, port: ${port}, minConsecutiveTime: ${
+          minConsecutiveTime / 1000
+        }s, timeout: ${timeout / 1000}s`
+      );
+    }
     try {
       await ensureEndpointHealthy({
         port,
@@ -1538,51 +1529,6 @@ const getBlockletURLForLauncher = async ({ blocklet, nodeInfo }) => {
   const didDomain = getDidDomainForBlocklet({ appPid: blocklet.appPid, didDomain: nodeInfo.didDomain });
   return `https://${didDomain}`;
 };
-
-const consumeServerlessNFT = async ({ nftId, nodeInfo, blocklet }) => {
-  try {
-    const state = await getNFTState(blocklet.controller.chainHost, nftId);
-    if (!state) {
-      throw new Error(`get nft state failed, chainHost: ${blocklet.controller.chainHost}, nftId: ${nftId}`);
-    }
-
-    const appURL = await getBlockletURLForLauncher({ blocklet, nodeInfo });
-
-    logger.info('app url when consuming nft', { appURL, nftId });
-
-    const body = { nftId, appURL };
-
-    const { launcherUrl } = state.data.value;
-
-    const wallet = getNodeWallet(nodeInfo.sk);
-    const func = async () => {
-      const { data } = await axios.post(joinURL(launcherUrl, '/api/serverless/consume'), body, {
-        headers: {
-          'x-sig': toBase58(wallet.sign(stableStringify(body))),
-        },
-      });
-
-      return data;
-    };
-
-    const delay = 10 * 1000;
-    const result = await pRetry(func, {
-      retries: 3,
-      minTimeout: delay,
-      maxTimeout: delay,
-      onFailedAttempt: (error) => {
-        logger.error(`attempt consume nft ${nftId} failed`, { error });
-      },
-    });
-
-    logger.info('consume serverless nft success', { nftId, hash: result.hash });
-  } catch (error) {
-    logger.error('consume serverless nft failed', { nftId, error });
-
-    throw new Error(`consume nft ${nftId} failed`);
-  }
-};
-
 const createDataArchive = (dataDir, fileName) => {
   const zipPath = path.join(os.tmpdir(), fileName);
   if (fs.existsSync(zipPath)) {
@@ -1952,13 +1898,77 @@ const getBlockletDidDomainList = (blocklet, nodeInfo) => {
   return domainAliases;
 };
 
+const getBlockletStatus = (blocklet) => {
+  const fallbackStatus = BlockletStatus.stopped;
+
+  if (!blocklet) {
+    return fallbackStatus;
+  }
+
+  if (!blocklet.children?.length) {
+    if (blocklet.meta?.group === BlockletGroup.gateway) {
+      return blocklet.status;
+    }
+
+    if (blocklet.status === BlockletStatus.added) {
+      return BlockletStatus.added;
+    }
+
+    // for backward compatibility
+    if (!blocklet.structVersion) {
+      return blocklet.status;
+    }
+
+    return fallbackStatus;
+  }
+
+  let inProgressStatus;
+  let runningStatus;
+  let status;
+
+  forEachComponentV2Sync(blocklet, (component) => {
+    if (component.meta?.group === BlockletGroup.gateway) {
+      return;
+    }
+
+    if (isInProgress(component.status)) {
+      if (!inProgressStatus) {
+        inProgressStatus = component.status;
+      }
+      return;
+    }
+
+    if (isRunning(component.status)) {
+      runningStatus = component.status;
+      return;
+    }
+
+    status = component.status;
+  });
+
+  return inProgressStatus || runningStatus || status;
+};
+
+const shouldSkipComponent = (componentDid, whiteList) => {
+  if (!whiteList || !Array.isArray(whiteList)) {
+    return false;
+  }
+
+  const arr = whiteList.filter(Boolean);
+
+  if (!arr.length) {
+    return false;
+  }
+
+  return !arr.includes(componentDid);
+};
+
 const exceedRedemptionPeriod = (expirationDate) => {
   return dayjs().diff(dayjs(expirationDate), 'day') > EXPIRED_BLOCKLET_DATA_RETENTION_DAYS;
 };
 
 module.exports = {
   updateBlockletFallbackLogo,
-  consumeServerlessNFT,
   forEachBlocklet,
   getBlockletMetaFromUrl: (url) => getBlockletMetaFromUrl(url, { logger }),
   parseComponents,
@@ -1975,7 +1985,6 @@ module.exports = {
   stopBlockletProcess,
   deleteBlockletProcess,
   reloadBlockletProcess,
-  getBlockletStatusFromProcess,
   checkBlockletProcessHealthy,
   getHealthyCheckTimeout,
   getProcessInfo,
@@ -2014,6 +2023,9 @@ module.exports = {
   getFixedBundleSource,
   ensureAppLogo,
   getBlockletDidDomainList,
+  getProcessState,
+  getBlockletStatus,
+  shouldSkipComponent,
   getBlockletURLForLauncher,
   exceedRedemptionPeriod,
 };

package/lib/util/launcher.js

@@ -0,0 +1,238 @@
+const path = require('path');
+const fs = require('fs-extra');
+const joinUrl = require('url-join');
+const pick = require('lodash/pick');
+const joinURL = require('url-join');
+const { parseUserAvatar, extractUserAvatar, getAvatarFile, getAvatarByUrl } = require('@abtnode/util/lib/user');
+const { Hasher } = require('@ocap/mcrypto');
+const { getDisplayName } = require('@blocklet/meta/lib/util');
+const getBlockletInfo = require('@blocklet/meta/lib/info');
+
+const { getLauncherUser, getLauncherSession: getLauncherSessionRaw, doRequest } = require('@abtnode/auth/lib/launcher');
+const { createAuthToken, getPassportStatusEndpoint } = require('@abtnode/auth/lib/auth');
+const { createPassportVC, createPassport, createUserPassport } = require('@abtnode/auth/lib/passport');
+
+const { BlockletStatus } = require('@blocklet/constant');
+const {
+  WELLKNOWN_SERVICE_PATH_PREFIX,
+  NODE_DATA_DIR_NAME,
+  USER_AVATAR_URL_PREFIX,
+  ROLES,
+} = require('@abtnode/constant');
+
+const logger = require('@abtnode/logger')('@abtnode/core:util:launcher');
+
+const { getNFTState } = require('./index');
+const { getBlockletURLForLauncher } = require('./blocklet');
+const states = require('../states');
+
+const consumeServerlessNFT = async ({ nftId, blocklet }) => {
+  try {
+    const state = await getNFTState(blocklet.controller.chainHost, nftId);
+    if (!state) {
+      throw new Error(`Get nft state failed, chainHost: ${blocklet.controller.chainHost}, nftId: ${nftId}`);
+    }
+
+    const nodeInfo = await states.node.read();
+    const appURL = await getBlockletURLForLauncher({ blocklet, nodeInfo });
+    logger.info('Consuming serverless nft params', { appURL, nftId });
+
+    const { launcherUrl } = state.data.value;
+    const result = await doRequest(nodeInfo.sk, {
+      launcherUrl,
+      pathname: '/api/serverless/consume',
+      payload: { nftId, appURL },
+      method: 'post',
+    });
+
+    logger.info('Consume serverless nft success', { nftId, hash: result.hash });
+  } catch (error) {
+    logger.error('Consume serverless nft failed', { nftId, error });
+    throw new Error(`consume nft ${nftId} failed`);
+  }
+};
+
+const consumeLauncherSession = async ({ params, blocklet }) => {
+  try {
+    const info = await states.node.read();
+    const { appUrl, name } = getBlockletInfo(blocklet, info.sk);
+    const result = await doRequest(info.sk, {
+      launcherUrl: params.launcherUrl,
+      pathname: `/api/launches/${params.launcherSessionId}/installed`,
+      payload: { appDid: blocklet.appPid, appUrl, appName: name, ownerDid: params.ownerDid },
+      method: 'post',
+    });
+
+    logger.info('Consume launcher session success', { params, result });
+  } catch (error) {
+    logger.error('Consume launcher session failed', { params, error });
+    throw new Error(`Consume launcher session ${params.launcherSessionId} failed`);
+  }
+};
+
+const setupAppOwner = async (node, sessionId) => {
+  const session = await node.getSession({ id: sessionId });
+  if (!session) {
+    throw new Error(`Blocklet setup session not found in server: ${sessionId}`);
+  }
+
+  const { appDid, userDid, ownerDid, ownerPk, lastLoginIp, context, locale, launcherUrl, launcherSessionId } = session;
+  const [info, blocklet] = await Promise.all([states.node.read(), states.blocklet.getBlocklet(appDid)]);
+  if (!blocklet) {
+    throw new Error(`Blocklet not found in server: ${appDid}`);
+  }
+  if (blocklet.status !== BlockletStatus.installed) {
+    throw new Error(`Blocklet status not expected: ${appDid}`);
+  }
+
+  const { wallet } = getBlockletInfo(blocklet, info.sk);
+  const appUrl = blocklet.environments.find((x) => x.key === 'BLOCKLET_APP_URL').value;
+  const dataDir = blocklet.environments.find((x) => x.key === 'BLOCKLET_DATA_DIR').value;
+  const serverDataDir = path.join(node.dataDirs.data, NODE_DATA_DIR_NAME);
+
+  let user;
+  let appOwnerProfile;
+  // get user from launcher or server
+  if (launcherUrl && launcherSessionId) {
+    user = await getLauncherUser(info.sk, { launcherUrl, launcherSessionId });
+    if (!user) {
+      throw new Error(`Owner user not found from launcher: ${launcherUrl}`);
+    }
+    appOwnerProfile = pick(user, ['fullName', 'email', 'avatar']);
+    const avatarBase64 = await getAvatarByUrl(joinURL(launcherUrl, user.avatar));
+    appOwnerProfile.avatar = await extractUserAvatar(avatarBase64, { dataDir });
+    logger.info('Create owner from launcher for blocklet', { appDid, ownerDid, ownerPk, sessionId, appOwnerProfile });
+  } else {
+    user = await node.getUser({ teamDid: info.did, user: { did: userDid } });
+    if (!user) {
+      throw new Error(`Owner user not found in server: ${userDid}`);
+    }
+    appOwnerProfile = pick(user, ['fullName', 'email', 'avatar']);
+    if (user.avatar && user.avatar.startsWith(USER_AVATAR_URL_PREFIX)) {
+      const filename = user.avatar.split('/').pop();
+      const srcFile = getAvatarFile(serverDataDir, filename);
+      const destFile = getAvatarFile(dataDir, filename);
+      fs.mkdirpSync(path.dirname(destFile));
+      fs.copyFileSync(srcFile, destFile);
+    } else {
+      appOwnerProfile.avatar = extractUserAvatar(user.avatar, { dataDir });
+    }
+    logger.info('Create owner from session for blocklet', { appDid, ownerDid, ownerPk, sessionId, appOwnerProfile });
+  }
+
+  // create and send owner passport
+  const role = ROLES.OWNER;
+  const vc = createPassportVC({
+    issuerName: getDisplayName(blocklet),
+    issuerWallet: wallet,
+    ownerDid,
+    passport: await createPassport({
+      name: role,
+      node,
+      teamDid: appDid,
+      locale,
+      endpoint: appUrl,
+    }),
+    endpoint: getPassportStatusEndpoint({
+      baseUrl: joinUrl(appUrl, WELLKNOWN_SERVICE_PATH_PREFIX),
+      userDid: ownerDid,
+      teamDid: appDid,
+    }),
+    ownerProfile: { ...appOwnerProfile, avatar: await parseUserAvatar(user.avatar, { dataDir: serverDataDir }) },
+    preferredColor: 'default',
+    expirationDate: undefined,
+  });
+
+  // create app owner passport
+  const passport = createUserPassport(vc, { role });
+
+  // add app owner to database
+  const doc = await node.loginUser({
+    teamDid: appDid,
+    user: {
+      ...appOwnerProfile,
+      did: ownerDid,
+      pk: ownerPk,
+      passport,
+      locale,
+      lastLoginIp,
+      connectedAccount: {
+        provider: 'wallet',
+        did: ownerDid,
+        pk: ownerPk,
+      },
+    },
+  });
+  await node.createAuditLog(
+    {
+      action: 'addUser',
+      args: { teamDid: appDid, userDid: ownerDid, reason: 'launch blocklet' },
+      context: { ...context, user: doc },
+      result: doc,
+    },
+    node
+  );
+  logger.info('Create owner for blocklet', { appDid, ownerDid, sessionId });
+
+  // create owner login token that can be used to login on blocklet site
+  const appSecret = Hasher.SHA3.hash256(Buffer.concat([wallet.secretKey, wallet.address].map(Buffer.from)));
+  const setupToken = createAuthToken({
+    did: ownerDid,
+    passport,
+    role,
+    secret: appSecret,
+    expiresIn: '7d',
+  });
+
+  await node.setBlockletOwner({ did: appDid, owner: { did: ownerDid, pk: ownerPk } });
+  await node.endSession({ id: sessionId });
+  logger.info('Complete install for blocklet', { appDid, ownerDid, sessionId });
+
+  return {
+    session,
+    blocklet,
+    setupToken,
+    passport: vc,
+  };
+};
+
+const getLauncherSession = async ({ launcherUrl, launcherSessionId, external = true }) => {
+  const info = await states.node.read();
+  const result = await getLauncherSessionRaw(info.sk, { launcherUrl, launcherSessionId });
+
+  // strip sensitive data if call from external
+  if (external && result.launcherSession) {
+    result.launcherSession = pick(result.launcherSession, ['_id', 'status']);
+  }
+
+  return result;
+};
+
+// Check local first, then remote, FIXME: @wangshijun should we check on chain nft?
+const isLauncherSessionConsumed = async (params) => {
+  let consumed = await states.blockletExtras.isLauncherSessionConsumed(params.launcherSessionId);
+  logger.info('Launcher session consumed at local?', { params, consumed });
+  if (consumed) {
+    return true;
+  }
+
+  const { error, launcherSession } = await getLauncherSession(params);
+  if (error) {
+    throw new Error(error);
+  }
+  if (!launcherSession) {
+    throw new Error('Launcher session not found');
+  }
+
+  consumed = launcherSession.status > 40;
+  logger.info('Launcher session consumed at remote?', { params, consumed });
+  return consumed;
+};
+
+module.exports = {
+  consumeServerlessNFT,
+  consumeLauncherSession,
+  setupAppOwner,
+  getLauncherSession,
+  isLauncherSessionConsumed,
+};