@abtnode/blocklet-services 1.16.5 → 1.16.6-beta-4562aa60

package/api/services/auth/connect/receive-transfer-app-owner.js

@@ -0,0 +1,392 @@
+const { get } = require('lodash');
+const { toHex } = require('@ocap/util');
+const pRetry = require('p-retry');
+const { messages, getApplicationInfo, getPassportStatusEndpoint, getUser } = require('@abtnode/auth/lib/auth');
+const { getKeyPairClaim, getAuthPrincipalForTransferAppOwnerShip } = require('@abtnode/auth/lib/server');
+const sleep = require('@abtnode/util/lib/sleep');
+const { getChainClient } = require('@abtnode/util/lib/get-chain-client');
+const formatContext = require('@abtnode/util/lib/format-context');
+const { extractUserAvatar } = require('@abtnode/util/lib/user-avatar');
+const { ensureAccountOnMainChain } = require('@abtnode/util/lib/ensure-account-on-main-chain');
+const {
+  createPassport,
+  createPassportVC,
+  createUserPassport,
+  getRoleFromLocalPassport,
+} = require('@abtnode/auth/lib/passport');
+const getBlockletWallet = require('@blocklet/meta/lib/wallet');
+const { getBlockletChainInfo, isInProgress } = require('@blocklet/meta/lib/util');
+const { ROLES } = require('@abtnode/constant');
+const logger = require('@abtnode/logger')('blocklet-service:transfer-blocklet-owner');
+
+const { mergeUserData } = require('../../oauth');
+
+const migrateAppOnChain = async (blocklet, oldSk, newSk) => {
+  if (process.env.NODE_ENV === 'test') {
+    return;
+  }
+
+  logger.info('Preparing for on-chain migration', { did: blocklet.meta.did });
+  if (!oldSk) {
+    // should not be here
+    logger.error('on-chain migration aborted because oldSk is empty', { did: blocklet.meta.did });
+    return;
+  }
+
+  if (!newSk) {
+    // should not be here
+    logger.error('on-chain migration aborted because newSk is empty', { did: blocklet.meta.did });
+    return;
+  }
+
+  // ensure account changed
+  const type = blocklet.configObj?.BLOCKLET_WALLET_TYPE;
+  const oldWallet = getBlockletWallet(oldSk, undefined, type);
+  const newWallet = getBlockletWallet(newSk, undefined, type);
+  if (oldWallet.address === newWallet.address) {
+    // should not be here
+    logger.info('on-chain migration aborted because newSk same with oldSk', { did: blocklet.meta.did });
+    await ensureAccountOnMainChain(newWallet, blocklet.meta.title);
+    return;
+  }
+
+  // ensure chain host
+  const chainHost = getBlockletChainInfo(blocklet).host;
+  if (!chainHost || chainHost === 'none') {
+    logger.info('on-chain migration aborted because CHAIN_HOST is empty', { did: blocklet.meta.did });
+    await ensureAccountOnMainChain(newWallet, blocklet.meta.title);
+    return;
+  }
+
+  // migrate on chain
+  logger.info('on-chain migration for chain ', { did: blocklet.meta.did, host: chainHost });
+  const client = getChainClient(chainHost);
+  const oldResult = await client.getAccountState({ address: oldWallet.address });
+  const newResult = await client.getAccountState({ address: newWallet.address });
+
+  if (oldResult.state && !newResult.state) {
+    logger.info('on-chain migration for wallets', { oldAddress: oldWallet.address, newAddress: newWallet.address });
+
+    // migrate old account to new account
+    const tx = await client.signAccountMigrateTx({
+      tx: {
+        itx: {
+          address: newWallet.address,
+          pk: newWallet.publicKey,
+        },
+      },
+      wallet: oldWallet,
+    });
+    const hash = await client.sendAccountMigrateTx({ tx, wallet: oldWallet });
+    logger.info('on-chain migration done', { did: blocklet.meta.did, hash });
+  } else {
+    if (!oldResult.state) {
+      logger.info('on-chain migration aborted because oldSk not declared on chain', { did: blocklet.meta.did });
+    }
+
+    if (newResult.state) {
+      logger.info('on-chain migration aborted because newSk declared on chain', { did: blocklet.meta.did });
+    }
+  }
+
+  // should not throw error because signAccountMigrateTx is already happened
+  try {
+    await ensureAccountOnMainChain(newWallet, blocklet.meta.title);
+  } catch (error) {
+    logger.error('ensureAccountOnMainChain failed', { error });
+  }
+};
+
+module.exports = function createRoutes(node, _, createSessionToken) {
+  const getBlocklet = async (did) => {
+    const blocklet = await node.getBlocklet({ did, attachConfig: false });
+    if (!blocklet) {
+      throw new Error(`application not found: ${did}`);
+    }
+    return blocklet;
+  };
+
+  return {
+    action: 'receive-transfer-app-owner',
+    authPrincipal: false,
+    claims: [
+      {
+        authPrincipal: getAuthPrincipalForTransferAppOwnerShip(node),
+      },
+      {
+        keyPair: async (opts) => {
+          const {
+            extraParams: { appDid, transferId, locale },
+          } = opts;
+
+          const transfer = await node.checkTransferAppOwnerSession({ appDid, transferId });
+
+          if (transfer.appDid !== appDid) {
+            throw new Error(`Invalid appDid. Expect: ${transfer.appDid}, Actual: ${appDid}`);
+          }
+
+          const blocklet = await getBlocklet(appDid);
+
+          if (isInProgress(blocklet.status)) {
+            throw new Error(messages.appIsInProgress[locale]);
+          }
+
+          return getKeyPairClaim(node, { title: blocklet.meta.title, declare: false })(opts);
+        },
+        profile: async ({ extraParams: { locale = 'en' } }) => {
+          return {
+            fields: ['fullName', 'email', 'avatar'],
+            description: messages.requestProfile[locale],
+          };
+        },
+      },
+    ],
+    onAuth: async ({ userDid, userPk, claims, req, updateSession, extraParams, baseUrl }) => {
+      logger.info('transferAppOwnerHandler', extraParams);
+
+      // prepare data
+
+      const { locale = 'en', appDid, transferId } = extraParams;
+
+      if (!transferId) {
+        throw new Error('missing transferId in extraParams');
+      }
+
+      if (!appDid) {
+        throw new Error(messages.missingBlockletDid[locale]);
+      }
+
+      const profile = claims.find((x) => x.type === 'profile');
+      if (!profile) {
+        throw new Error('app keyPair must be provided');
+      }
+
+      const keyPair = claims.find((x) => x.type === 'keyPair');
+      if (!keyPair) {
+        throw new Error(messages.missingKeyPair[locale]);
+      }
+
+      const newSk = toHex(keyPair.secret);
+      if (!newSk) {
+        throw new Error(`keyPair.secret is empty: ${appDid}`);
+      }
+
+      const blocklet = await node.getBlocklet({ did: appDid, attachRuntimeInfo: false });
+      if (!blocklet) {
+        throw new Error(messages.invalidBlocklet[locale]);
+      }
+
+      if (blocklet.appDid !== appDid) {
+        throw new Error(`Invalid appDid. Expect: ${blocklet.appDid}, Actual: ${appDid}`);
+      }
+
+      const oldSk = (blocklet.environments || []).find((x) => x.key === 'BLOCKLET_APP_SK').value;
+
+      const initialized = !!blocklet.settings?.initialized;
+      if (!initialized) {
+        throw new Error(messages.appNotInitialized[locale]);
+      }
+
+      const oldOwnerDid = blocklet.settings?.owner?.did;
+
+      const { appPid } = blocklet;
+
+      const transfer = await node.checkTransferAppOwnerSession({ appDid, transferId });
+
+      if (transfer.appDid !== appDid) {
+        throw new Error(`Invalid appDid. Expect: ${transfer.appDid}, Actual: ${appDid}`);
+      }
+
+      const {
+        name: issuerName,
+        wallet: issuerWallet,
+        passportColor,
+        dataDir,
+      } = await getApplicationInfo({ node, teamDid: appPid });
+
+      const statusEndpointBaseUrl = baseUrl;
+      const endpoint = baseUrl;
+
+      const vcParams = {
+        issuerName,
+        issuerWallet,
+        ownerDid: userDid,
+        passport: await createPassport({
+          name: ROLES.OWNER,
+          node,
+          teamDid: appPid,
+          locale,
+          endpoint,
+        }),
+        endpoint: getPassportStatusEndpoint({
+          baseUrl: statusEndpointBaseUrl,
+          userDid,
+          teamDid: appPid,
+        }),
+        types: [],
+        ownerProfile: profile,
+        preferredColor: passportColor,
+      };
+
+      const vc = createPassportVC(vcParams);
+
+      const role = getRoleFromLocalPassport(get(vc, 'credentialSubject.passport'));
+      const passport = createUserPassport(vc, { role });
+
+      const user = await getUser(node, appPid, userDid);
+
+      // update state
+
+      await node.updateBlockletOwner({ did: appPid, owner: { did: userDid, pk: userPk } });
+
+      const avatar = await extractUserAvatar(get(profile, 'avatar'), {
+        dataDir,
+      });
+
+      const now = new Date().toISOString();
+
+      if (user) {
+        const doc = await node.updateUser({
+          teamDid: appPid,
+          user: {
+            ...mergeUserData(user, {
+              avatar,
+              locale,
+              lastLoginIp: get(req, 'headers[x-real-ip]') || '',
+              lastUsedPassport: passport,
+              connectedAccount: { provider: 'wallet' },
+            }),
+            ...profile,
+            avatar,
+          },
+        });
+        await node.createAuditLog(
+          {
+            action: 'updateUser',
+            args: { teamDid: appPid, userDid, passport, reason: 'transfer ownership' },
+            context: formatContext(Object.assign(req, { user })),
+            result: doc,
+          },
+          node
+        );
+      } else {
+        const doc = await node.addUser({
+          teamDid: appPid,
+          user: {
+            ...profile,
+            avatar,
+            did: userDid,
+            pk: userPk,
+            approved: true,
+            locale,
+            passports: [passport],
+            firstLoginAt: now,
+            lastLoginAt: now,
+            lastLoginIp: get(req, 'headers[x-real-ip]') || '',
+            extraConfigs: {
+              sourceProvider: 'wallet',
+              connectedAccounts: [
+                {
+                  provider: 'wallet',
+                  did: userDid,
+                  pk: userPk,
+                  lastLoginAt: now,
+                  firstLoginAt: now,
+                },
+              ],
+            },
+          },
+        });
+
+        await node.createAuditLog(
+          {
+            action: 'addUser',
+            args: { teamDid: appPid, userDid, passport, reason: 'transfer ownership' },
+            context: formatContext(Object.assign(req, { user: doc })),
+            result: doc,
+          },
+          node
+        );
+      }
+
+      // NOTICE: must NOT use appDid here if update BLOCKLET_APP_SK
+      await node.configBlocklet(
+        {
+          did: blocklet.appPid,
+          configs: [{ key: 'BLOCKLET_APP_SK', value: newSk, secure: true }],
+          skipHook: true,
+          skipDidDocument: true,
+        },
+        formatContext(Object.assign(req, { user: { did: userDid, fullName: 'Owner', role: 'owner' } }))
+      );
+
+      try {
+        if (oldOwnerDid && oldOwnerDid !== userDid) {
+          const oldOwner = await getUser(node, appPid, oldOwnerDid);
+          if (oldOwner) {
+            const filteredPassports = (oldOwner.passports || []).filter((p) => p.role !== ROLES.OWNER);
+            if (filteredPassports.length !== (oldOwner.passports || []).length) {
+              logger.info('update old owner passport', {
+                oldOwnerDid,
+                filteredPassports: filteredPassports.map((x) => x.id),
+              });
+              await node.updateUser({
+                teamDid: appPid,
+                user: {
+                  did: oldOwnerDid,
+                  pk: oldOwner.pk,
+                  passports: filteredPassports,
+                },
+              });
+            }
+          }
+        }
+      } catch (error) {
+        logger.error('remove old owner passport failed', { error });
+      }
+
+      try {
+        await node.closeTransferAppOwnerSession({
+          appPid: blocklet.appPid,
+          transferId,
+          status: 'success',
+        });
+      } catch (error) {
+        logger.error('closeTransferAppOwnerSession failed', { error });
+      }
+
+      // migrate on-chain account
+      pRetry(() => migrateAppOnChain(blocklet, oldSk, newSk), {
+        retries: 10,
+        onFailedAttempt: console.error,
+      }).catch((error) => {
+        logger.error('migrateAppOnChain failed', { error });
+      });
+
+      // restart blocklet (not use queue)
+      node
+        .stopBlocklet({ did: appPid })
+        .then(() => {
+          return node.startBlocklet({ did: appPid });
+        })
+        .catch((error) => {
+          logger.error('restart blocklet failed', { appPid, error });
+        });
+
+      await sleep(3000);
+      logger.info('transfer ownership success', { userDid });
+
+      // Generate new session token that client can save to localStorage
+      const sessionToken = await createSessionToken(userDid, { passport: vc, role });
+      await updateSession({ sessionToken }, true);
+      await updateSession({ passportId: vc?.id });
+      logger.info('invite.success', { userDid });
+
+      return {
+        disposition: 'attachment',
+        type: 'VerifiableCredential',
+        data: vc,
+      };
+    },
+  };
+};

package/api/services/auth/connect/transfer-app-owner.js

@@ -0,0 +1,30 @@
+const { getAppDidOwnerClaims } = require('@abtnode/auth/lib/server');
+const logger = require('@abtnode/logger')('blocklet-service:transfer-blocklet-owner');
+
+module.exports = function createRoutes(node) {
+  const getBlocklet = async (did) => {
+    const blocklet = await node.getBlocklet({ did, attachConfig: false });
+    if (!blocklet) {
+      throw new Error(`application not found: ${did}`);
+    }
+    return blocklet;
+  };
+
+  return {
+    action: 'transfer-app-owner',
+    authPrincipal: false,
+    claims: getAppDidOwnerClaims(),
+    onAuth: async ({ userDid: appDid, updateSession }) => {
+      const blocklet = await getBlocklet(appDid);
+      if (blocklet.appDid !== appDid) {
+        throw new Error(`Invalid appDid. Expect: ${blocklet.appDid}, Actual: ${appDid}`);
+      }
+
+      const result = await node.createTransferAppOwnerSession({ appDid });
+
+      logger.info('create transfer app owner', result);
+
+      await updateSession({ result });
+    },
+  };
+};

package/api/services/auth/index.js

@@ -26,6 +26,7 @@ const createLoginRoutes = require('./connect/login');
 const createBindWallerRoutes = require('./connect/bind-wallet');
 const createInviteRoutes = require('./connect/invite');
 const createIssuePassportAuth = require('./connect/issue-passport');
+const createExchangePassportAuth = require('./connect/exchange-passport');
 const createLostPassportListAuth = require('./connect/lost-passport-list');
 const createLostPassportIssueAuth = require('./connect/lost-passport-issue');
 const createPreSetupAuth = require('./connect/pre-setup');
@@ -35,6 +36,8 @@ const createSwitchPassportAuth = require('./connect/switch-passport');
 const createRotateKeyPairAuth = require('./connect/rotate-key-pair');
 const createFuelAuth = require('./connect/fuel');
 const createMigrateToStructV2Routes = require('./connect/migrate-app-to-struct-v2');
+const createTransferAppOwnerRoutes = require('./connect/transfer-app-owner');
+const createReceiveTransferAppOwnerRoutes = require('./connect/receive-transfer-app-owner');
 const createSessionRoutes = require('./session');
 const createPassportRoutes = require('./passport');
 const { getRedirectUrl } = require('../../util');
@@ -169,6 +172,7 @@ const init = ({ node, options }) => {
       handler.attach(Object.assign({ app }, createBindWallerRoutes(node, authenticator, createSessionToken)));
       handler.attach(Object.assign({ app }, createInviteRoutes(node, authenticator, createSessionToken)));
       handler.attach(Object.assign({ app }, createIssuePassportAuth(node, authenticator, createSessionToken)));
+      handler.attach(Object.assign({ app }, createExchangePassportAuth(node, authenticator, createSessionToken)));
       handler.attach(Object.assign({ app }, createLostPassportListAuth(node, authenticator, createSessionToken)));
       handler.attach(Object.assign({ app }, createLostPassportIssueAuth(node, authenticator, createSessionToken)));
       handler.attach(Object.assign({ app }, createPreSetupAuth(node, authenticator, createSessionToken)));
@@ -178,6 +182,8 @@ const init = ({ node, options }) => {
       handler.attach(Object.assign({ app }, createRotateKeyPairAuth(node, authenticator, createSessionToken)));
       handler.attach(Object.assign({ app }, createFuelAuth(authenticator, createSessionToken)));
       handler.attach(Object.assign({ app }, createMigrateToStructV2Routes(node, options)));
+      handler.attach(Object.assign({ app }, createTransferAppOwnerRoutes(node, options)));
+      handler.attach(Object.assign({ app }, createReceiveTransferAppOwnerRoutes(node, options, createSessionToken)));
     });
   };
 

package/api/services/oauth/index.js

@@ -1,6 +1,6 @@
 const { upsertToPassports } = require('@abtnode/auth/lib/passport');
+const { getChainClient } = require('@abtnode/util/lib/get-chain-client');
 const cloneDeep = require('lodash/cloneDeep');
-const Client = require('@ocap/client');
 const { default: urlFriendly } = require('@blocklet/meta/lib/url-friendly');
 const { slugify } = require('transliteration');
 const { MAIN_CHAIN_ENDPOINT } = require('@abtnode/constant');
@@ -10,7 +10,7 @@ const { types } = require('@arcblock/did');
 const logger = require('@abtnode/logger')('blocklet-services:oauth');
 
 function mergeUserData(oldUser, updateData) {
-  const currentTime = new Date().toISOString();
+  const now = new Date().toISOString();
   const { extraConfigs = {} } = oldUser || {};
   const newUser = {
     did: oldUser.did,
@@ -19,14 +19,14 @@ function mergeUserData(oldUser, updateData) {
       oldUser.passports || [],
       updateData.lastUsedPassport && {
         ...updateData.lastUsedPassport,
-        lastLoginAt: currentTime,
+        lastLoginAt: now,
       }
     ),
     extraConfigs: {
       ...extraConfigs,
       connectedAccounts: updateConnectedAccount(extraConfigs.connectedAccounts || [], updateData.connectedAccount),
     },
-    lastLoginAt: currentTime,
+    lastLoginAt: now,
   };
   if (updateData.lastLoginIp) {
     newUser.lastLoginIp = updateData.lastLoginIp;
@@ -39,20 +39,23 @@ function mergeUserData(oldUser, updateData) {
 }
 
 function updateConnectedAccount(connectedAccounts = [], connectedAccount = {}) {
-  const currentTime = new Date().toISOString();
-  const copyAccounts = cloneDeep(connectedAccounts);
-  const findAccountIndex = copyAccounts.findIndex((item) => item.provider === connectedAccount.provider);
-  if (findAccountIndex > -1) {
-    copyAccounts[findAccountIndex] = {
-      ...connectedAccounts[findAccountIndex],
-      ...connectedAccount,
-      lastLoginAt: currentTime,
-    };
-  } else {
-    copyAccounts.push(connectedAccount);
-  }
+  const now = new Date().toISOString();
+  const updated = cloneDeep(connectedAccounts);
+  const updates = Array.isArray(connectedAccount) ? connectedAccount : [connectedAccount];
+  updates.forEach((x) => {
+    const findAccountIndex = updated.findIndex((item) => item.provider === x.provider && item.did === x.did);
+    if (findAccountIndex > -1) {
+      updated[findAccountIndex] = {
+        ...connectedAccounts[findAccountIndex],
+        ...x,
+        lastLoginAt: now,
+      };
+    } else {
+      updated.push(x);
+    }
+  });
 
-  return copyAccounts;
+  return updated;
 }
 
 async function getRawUser(teamDid, userDid, { getUser, getUsers }) {
@@ -75,7 +78,7 @@ async function getRawUser(teamDid, userDid, { getUser, getUsers }) {
 }
 
 async function declareAccountByChain({ chainHost, wallet, moniker }) {
-  const chainClient = new Client(chainHost);
+  const chainClient = getChainClient(chainHost);
   const { address } = wallet;
   const { state } = await chainClient.getAccountState({ address }, { ignoreFields: ['context'] });
   if (state) {
@@ -103,13 +106,15 @@ async function declareAccount({ wallet, moniker, blocklet }) {
   if (chainHost && chainHost !== 'none') {
     chainHostList.push(chainHost);
   }
-  const waitingList = chainHostList.map((item) => declareAccountByChain({ chainHost: item, wallet, moniker }));
+  const waitingList = [...new Set(chainHostList)].map((item) =>
+    declareAccountByChain({ chainHost: item, wallet, moniker })
+  );
   await Promise.all(waitingList);
 }
 
 async function migrateAccountByChain({ chainHost, user, wallet }) {
   try {
-    const client = new Client(chainHost);
+    const client = getChainClient(chainHost);
     const tx = await client.signAccountMigrateTx({
       tx: {
         itx: {
@@ -120,10 +125,10 @@ async function migrateAccountByChain({ chainHost, user, wallet }) {
       wallet,
     });
     const hash = await client.sendAccountMigrateTx({ tx, wallet });
-    logger.info('migration account done', { did: user.did, hash });
+    logger.info('migration account done', { chain: chainHost, did: user.did, hash });
     return hash;
   } catch (error) {
-    logger.error('migration account failed', { did: user.did, error });
+    logger.error('migration account failed', { chain: chainHost, did: user.did, error });
     return undefined;
   }
 }
@@ -134,7 +139,9 @@ async function migrateAccount({ wallet, blocklet, user }) {
   if (chainHost && chainHost !== 'none') {
     chainHostList.push(chainHost);
   }
-  const waitingList = chainHostList.map((item) => migrateAccountByChain({ chainHost: item, wallet, user }));
+  const waitingList = [...new Set(chainHostList)].map((item) =>
+    migrateAccountByChain({ chainHost: item, wallet, user })
+  );
   await Promise.all(waitingList);
 }
 

package/api/socket/channel/app.js

@@ -4,7 +4,7 @@ const { CHANNEL_TYPE, parseChannel, getAppPublicChannel } = require('@blocklet/m
 const { validateNotification } = require('@blocklet/sdk/lib/validators/notification');
 const { NODE_MODES } = require('@abtnode/constant');
 
-const { ensureSender, parseNotification, broadcast, EVENTS } = require('../util');
+const { ensureSenderApp, parseNotification, broadcast, EVENTS } = require('../util');
 
 /**
  *
@@ -54,7 +54,7 @@ const sendToAppChannel = async ({
 
   // parse sender
 
-  const appInfo = await ensureSender({ sender, node, nodeInfo });
+  const appInfo = await ensureSenderApp({ sender, node, nodeInfo });
 
   if (![appInfo.wallet.address, appInfo.permanentWallet.address].includes(channelInfo.appDid)) {
     throw new Error('Cannot sent message to channel of other app');

package/api/socket/channel/did.js

@@ -8,7 +8,7 @@ const { getWalletDidFromUser } = require('@blocklet/sdk/lib/did');
 
 // eslint-disable-next-line global-require
 const logger = require('@abtnode/logger')(`${require('../../../package.json').name}:notification`);
-const { ensureSender, parseNotification, broadcast, EVENTS } = require('../util');
+const { ensureSenderApp, parseNotification, broadcast, EVENTS } = require('../util');
 const states = require('../../state');
 
 /**
@@ -52,7 +52,7 @@ const sendToDid = async ({ sender, receiver: rawDid, notification, options, node
 
   // parse sender
 
-  const senderInfo = await ensureSender({ sender, node, nodeInfo });
+  const senderInfo = await ensureSenderApp({ sender, node, nodeInfo });
 
   // parse notification
 

package/api/socket/channel/relay.js

@@ -1,5 +1,5 @@
 const { CHANNEL_TYPE, parseChannel, getRelayChannel } = require('@blocklet/meta/lib/channel');
-const { ensureSender, broadcast, EVENTS } = require('../util');
+const { ensureSenderApp, broadcast, EVENTS } = require('../util');
 
 // Only an application can send message to a relay channel
 // But multiple clients can subscribe to the same relay channel
@@ -12,7 +12,7 @@ const sendToRelay = async ({ sender, channel, event = EVENTS.MESSAGE, data, node
   const nodeInfo = await node.getNodeInfo();
 
   // Sender is appDid of application
-  const appInfo = await ensureSender({ sender, node, nodeInfo });
+  const appInfo = await ensureSenderApp({ sender, node, nodeInfo });
 
   if (![appInfo.wallet.address, appInfo.permanentWallet.address].includes(channelInfo.appDid)) {
     throw new Error('Cannot sent message to relay channel of other app');

package/api/socket/util.js

@@ -47,7 +47,7 @@ const broadcast = (...args) => {
   });
 };
 
-const ensureSender = async ({ sender, node, nodeInfo }) => {
+const ensureSenderApp = async ({ sender, node, nodeInfo }) => {
   let appInfo;
   try {
     appInfo = await getApplicationInfo({ node, nodeInfo, teamDid: sender.appDid });
@@ -77,7 +77,7 @@ const EVENTS = {
 module.exports = {
   parseNotification,
   broadcast,
-  ensureSender,
+  ensureSenderApp,
   getTokenInfo,
   EVENTS,
 };