@abtnode/blocklet-services 1.16.31-beta-52250475 → 1.16.31-beta-a0cc72cf

package/api/libs/connect/session.js

@@ -331,422 +331,391 @@ module.exports = {
       return claims;
     },
 
-    onApprove:
-      /**
-       * @description
-       * @param {{
-       *  node: import('@abtnode/core').TNode,
-       *  claims: any[],
-       * }} {
-       *         node,
-       *         request,
-       *         locale,
-       *         challenge,
-       *         userDid,
-       *         userPk,
-       *         claims,
-       *         baseUrl,
-       *         createSessionToken,
-       *         componentId,
-       *         action,
-       *         visitorId,
-       *       }
-       * @return {*}
-       */
-      async ({
-        node,
-        request,
-        locale,
-        challenge,
-        userDid,
-        userPk,
-        claims,
-        baseUrl,
-        createSessionToken,
-        componentId,
-        action,
-        visitorId,
-      }) => {
-        /** @type {import('@abtnode/client').BlockletState} */
-        const blocklet = await request.getBlocklet();
-        const blockletInfo = await request.getBlockletInfo();
-        const { wallet, secret, name, passportColor, did: teamDid } = blockletInfo;
-        const sourceAppPid = getSourceAppPid(request);
-
-        // Check user approved
-        const currentUser = await getUserWithinFederated(
-          { sourceAppPid, teamDid, userDid, userPk },
-          { node, blocklet }
-        );
-        if (currentUser && !currentUser.approved) {
-          throw new Error(messages.notAllowedAppUser[locale]);
-        }
+    onApprove: async ({
+      node,
+      request,
+      locale,
+      challenge,
+      userDid,
+      userPk,
+      claims,
+      baseUrl,
+      createSessionToken,
+      componentId,
+      action,
+      visitorId,
+      inviter,
+    }) => {
+      /** @type {import('@abtnode/client').BlockletState} */
+      const blocklet = await request.getBlocklet();
+      const blockletInfo = await request.getBlockletInfo();
+      const { wallet, secret, name, passportColor, did: teamDid } = blockletInfo;
+      const sourceAppPid = getSourceAppPid(request);
 
-        const realDid = currentUser?.did || userDid;
-        const realPk = currentUser?.pk || userPk;
+      // Check user approved
+      const currentUser = await getUserWithinFederated({ sourceAppPid, teamDid, userDid, userPk }, { node, blocklet });
+      if (currentUser && !currentUser.approved) {
+        throw new Error(messages.notAllowedAppUser[locale]);
+      }
 
-        // Get auth config
-        const authConfig = (await request.getServiceConfig(NODE_SERVICES.AUTH, { componentId })) || {};
+      const realDid = currentUser?.did || userDid;
+      const realPk = currentUser?.pk || userPk;
 
-        let vc;
-        let nftState;
-        let invitedUserOnly = false;
-        let defaultRole = ROLES.GUEST;
-        let defaultTtl = 0;
-        let defaultTtlPolicy = 'never';
-        let issuePassport = false;
+      // Get auth config
+      const authConfig = (await request.getServiceConfig(NODE_SERVICES.AUTH, { componentId })) || {};
 
-        const provider = getLoginProvider(request);
-        const masterSite = getFederatedMaster(blocklet);
+      let vc;
+      let nftState;
+      let invitedUserOnly = false;
+      let defaultRole = ROLES.GUEST;
+      let defaultTtl = 0;
+      let defaultTtlPolicy = 'never';
+      let issuePassport = false;
 
-        // Get passport vc
-        if (action === 'login') {
-          vc = await getPassportVc({
-            blocklet,
-            claims,
-            challenge,
-            locale,
-            sourceAppPid,
-          });
-          [invitedUserOnly, defaultRole, issuePassport] = await isInvitedUserOnly(authConfig, node, teamDid);
-          if (invitedUserOnly && !vc) {
-            throw new Error(messages.missingCredentialClaim[locale]);
-          }
-        } else if (action === 'exchangePassport') {
-          const claim = claims.find((x) => x.type === 'asset');
-          const isConnected = await node.isConnectedAccount({ teamDid, did: claim.asset });
-          if (isConnected) {
-            throw new Error(messages.nftAlreadyUsed[locale]);
-          }
+      const provider = getLoginProvider(request);
+      const masterSite = getFederatedMaster(blocklet);
 
-          nftState = await verifyNFT({ claims, challenge, locale, chainHost: MAIN_CHAIN_ENDPOINT });
-          const matchFactory = blocklet.trustedFactories.find((x) => x.factoryAddress === nftState.parent);
-          if (!matchFactory) {
-            throw new Error(messages.invalidNftParent[locale]);
-          }
+      // Get passport vc
+      if (action === 'login') {
+        vc = await getPassportVc({
+          blocklet,
+          claims,
+          challenge,
+          locale,
+          sourceAppPid,
+        });
+        [invitedUserOnly, defaultRole, issuePassport] = await isInvitedUserOnly(authConfig, node, teamDid);
+        if (invitedUserOnly && !vc) {
+          throw new Error(messages.missingCredentialClaim[locale]);
+        }
+      } else if (action === 'exchangePassport') {
+        const claim = claims.find((x) => x.type === 'asset');
+        const isConnected = await node.isConnectedAccount({ teamDid, did: claim.asset });
+        if (isConnected) {
+          throw new Error(messages.nftAlreadyUsed[locale]);
+        }
 
-          defaultRole = matchFactory.passport.role;
-          defaultTtl = matchFactory.passport.ttl;
-          defaultTtlPolicy = matchFactory.passport.ttlPolicy;
-          issuePassport = true;
+        nftState = await verifyNFT({ claims, challenge, locale, chainHost: MAIN_CHAIN_ENDPOINT });
+        const matchFactory = blocklet.trustedFactories.find((x) => x.factoryAddress === nftState.parent);
+        if (!matchFactory) {
+          throw new Error(messages.invalidNftParent[locale]);
         }
 
-        if (issuePassport) {
-          let expirationDate;
-          if (nftState && defaultTtl) {
-            if (defaultTtlPolicy === 'mint') {
-              expirationDate = +new Date(nftState.context.genesisTime) + defaultTtl;
-            }
-            if (defaultTtlPolicy === 'exchange') {
-              expirationDate = +new Date() + defaultTtl;
-            }
-          }
+        defaultRole = matchFactory.passport.role;
+        defaultTtl = matchFactory.passport.ttl;
+        defaultTtlPolicy = matchFactory.passport.ttlPolicy;
+        issuePassport = true;
+      }
 
-          logger.info(`issue passport to user at the ${action} workflow`, {
-            role: defaultRole,
-            expire: expirationDate,
-            policy: defaultTtlPolicy,
-            ttl: defaultTtl,
-          });
+      if (issuePassport) {
+        let expirationDate;
+        if (nftState && defaultTtl) {
+          if (defaultTtlPolicy === 'mint') {
+            expirationDate = +new Date(nftState.context.genesisTime) + defaultTtl;
+          }
+          if (defaultTtlPolicy === 'exchange') {
+            expirationDate = +new Date() + defaultTtl;
+          }
+        }
 
-          const profile = claims.find((x) => x.type === 'profile');
+        logger.info(`issue passport to user at the ${action} workflow`, {
+          role: defaultRole,
+          expire: expirationDate,
+          policy: defaultTtlPolicy,
+          ttl: defaultTtl,
+        });
 
-          vc = createPassportVC({
-            issuerName: name,
-            issuerWallet: wallet,
-            issuerAvatarUrl: getAppAvatarUrl(baseUrl),
-            ownerDid: realDid,
-            passport: await createPassport({
-              name: defaultRole,
-              node,
-              teamDid,
-              locale,
-              endpoint: baseUrl,
-            }),
-            endpoint: getPassportStatusEndpoint({
-              baseUrl: joinURL(baseUrl, WELLKNOWN_SERVICE_PATH_PREFIX),
-              userDid: realDid,
-              teamDid,
-            }),
-            ownerProfile: profile,
-            preferredColor: passportColor,
-            expirationDate: expirationDate ? new Date(expirationDate).toISOString() : undefined,
-          });
-        }
+        const profile = claims.find((x) => x.type === 'profile');
 
-        // Get user passport from vc
-        let passport = vc ? createUserPassport(vc) : null;
-        if (currentUser && passport && isUserPassportRevoked(currentUser, passport)) {
-          throw new Error(messages.passportRevoked[locale](passport.title, name));
-        }
+        vc = createPassportVC({
+          issuerName: name,
+          issuerWallet: wallet,
+          issuerAvatarUrl: getAppAvatarUrl(baseUrl),
+          ownerDid: realDid,
+          passport: await createPassport({
+            name: defaultRole,
+            node,
+            teamDid,
+            locale,
+            endpoint: baseUrl,
+          }),
+          endpoint: getPassportStatusEndpoint({
+            baseUrl: joinURL(baseUrl, WELLKNOWN_SERVICE_PATH_PREFIX),
+            userDid: realDid,
+            teamDid,
+          }),
+          ownerProfile: profile,
+          preferredColor: passportColor,
+          expirationDate: expirationDate ? new Date(expirationDate).toISOString() : undefined,
+        });
+      }
 
-        // Get role
-        const role = await getRoleFromVC({ vc, node, locale, blocklet, teamDid, sourceAppPid });
-        await validateRole({ role, authConfig, locale, node, teamDid });
+      // Get user passport from vc
+      let passport = vc ? createUserPassport(vc) : null;
+      if (currentUser && passport && isUserPassportRevoked(currentUser, passport)) {
+        throw new Error(messages.passportRevoked[locale](passport.title, name));
+      }
 
-        checkAppOwner({ role, blocklet, userDid, locale });
+      // Get role
+      const role = await getRoleFromVC({ vc, node, locale, blocklet, teamDid, sourceAppPid });
+      await validateRole({ role, authConfig, locale, node, teamDid });
 
-        // Recreate passport with correct role
-        passport = vc ? createUserPassport(vc, { role }) : null;
+      checkAppOwner({ role, blocklet, userDid, locale });
 
-        const now = new Date().toISOString();
-        const connectedNft = nftState
-          ? {
-              provider: LOGIN_PROVIDER.NFT,
-              did: nftState.address,
-              owner: nftState.owner,
-              firstLoginAt: now,
-              lastLoginAt: now,
-            }
-          : null;
+      // Recreate passport with correct role
+      passport = vc ? createUserPassport(vc, { role }) : null;
 
-        let fullName = currentUser?.fullName;
-        // Update profile
-        const passportForLog = passport || { name: 'Guest', role: 'guest' };
+      const now = new Date().toISOString();
+      const connectedNft = nftState
+        ? {
+            provider: LOGIN_PROVIDER.NFT,
+            did: nftState.address,
+            owner: nftState.owner,
+            firstLoginAt: now,
+            lastLoginAt: now,
+          }
+        : null;
 
-        const connectAccount = { provider, did: userDid, pk: userPk };
+      let fullName = currentUser?.fullName;
+      // Update profile
+      const passportForLog = passport || { name: 'Guest', role: 'guest' };
 
-        let updatedUser;
-        const profile = claims.find((x) => x.type === 'profile');
+      const connectAccount = { provider, did: userDid, pk: userPk };
 
-        if (profile) {
-          profile.url = profile?.url || '';
-        }
+      let updatedUser;
+      const profile = claims.find((x) => x.type === 'profile');
 
-        if (currentUser) {
-          updatedUser = await node.loginUser({
-            teamDid,
-            user: {
-              did: currentUser.did,
-              pk: currentUser.pk,
-              locale,
-              passport,
-              sourceAppPid,
-              lastLoginIp: getRequestIP(request),
-              connectedAccount: [connectAccount, connectedNft],
-              ...profile,
-              avatar: await extractUserAvatar(get(profile, 'avatar'), {
-                dataDir: blocklet.env.dataDir,
-              }),
-            },
-          });
-          await node.createAuditLog(
-            {
-              action,
-              args: { teamDid, userDid: realDid, passport: passportForLog, provider, sourceAppPid },
-              context: formatContext(Object.assign(request, { user: updatedUser })),
-              result: updatedUser,
-            },
-            node
-          );
-        } else {
-          // Create user
-          fullName = profile.fullName;
+      if (profile) {
+        profile.url = profile?.url || '';
+      }
 
-          updatedUser = await node.loginUser({
-            teamDid,
-            user: {
-              ...profile,
-              avatar: await extractUserAvatar(get(profile, 'avatar'), {
-                dataDir: blocklet.env.dataDir,
-              }),
-              did: realDid,
-              pk: realPk,
-              locale,
-              passport,
-              sourceAppPid,
-              lastLoginIp: getRequestIP(request),
-              connectedAccount: [connectAccount, connectedNft],
-            },
-          });
-          await node.createAuditLog(
-            {
-              action: 'addUser',
-              args: {
-                teamDid,
-                userDid: realDid,
-                sourceAppPid,
-                provider,
-                reason: `first login as ${passportForLog.role}`,
-              },
-              context: formatContext(Object.assign(request, { user: updatedUser })),
-              result: updatedUser,
-            },
-            node
-          );
-        }
-        const lastLoginIp = getRequestIP(request);
-        const walletDeviceMessageToken = request.get('wallet-device-message-token');
-        const walletDeviceId = request.get('wallet-device-id');
-        const ua = request.get('user-agent');
-        // request.context.store.connectedWallet
-        const walletOS = request.context.didwallet.os;
-
-        const userSessionDoc = await node.upsertUserSession({
+      if (currentUser) {
+        updatedUser = await node.loginUser({
           teamDid,
-          visitorId,
-          userDid: realDid,
-          appPid: teamDid,
-          passportId: passport?.id,
-          status: 'online',
-          ua,
-          lastLoginIp,
-          extra: {
-            walletOS,
-            walletDeviceMessageToken,
-            walletDeviceId,
+          user: {
+            did: currentUser.did,
+            pk: currentUser.pk,
+            locale,
+            passport,
+            sourceAppPid,
+            lastLoginIp: getRequestIP(request),
+            connectedAccount: [connectAccount, connectedNft],
+            ...profile,
+            avatar: await extractUserAvatar(get(profile, 'avatar'), {
+              dataDir: blocklet.env.dataDir,
+            }),
           },
         });
-
-        if (shouldSyncFederated(sourceAppPid, blocklet)) {
+        await node.createAuditLog(
+          {
+            action,
+            args: { teamDid, userDid: realDid, passport: passportForLog, provider, sourceAppPid },
+            context: formatContext(Object.assign(request, { user: updatedUser })),
+            result: updatedUser,
+          },
           node
-            .syncFederated({
-              did: teamDid,
-              data: {
-                users: [
-                  {
-                    did: updatedUser.did,
-                    pk: updatedUser.pk,
-                    fullName: updatedUser.fullName,
-                    email: updatedUser.email || '',
-                    avatar: getUserAvatarUrl(updatedUser.avatar, blocklet),
-                    connectedAccount: [connectAccount, connectedNft],
-                    action: 'connectAccount',
-                    sourceAppPid: sourceAppPid || masterSite.appPid,
-                  },
-                ],
-              },
-            })
-            .then(() => {
-              node.syncUserSession({
-                teamDid,
-                userDid: realDid,
-                visitorId: userSessionDoc.visitorId,
-                passportId: passport?.id,
-                targetAppPid: sourceAppPid,
-                ua,
-                lastLoginIp,
-                extra: {
-                  walletOS,
-                  walletDeviceMessageToken,
-                  walletDeviceId,
-                },
-              });
-            });
-        }
-
-        // Generate new session token that client can save to localStorage
-        const createToken = createTokenFn(createSessionToken);
-        const sessionConfig = blocklet.settings?.session || {};
+        );
+      } else {
+        // Create user
+        fullName = profile.fullName;
 
-        const { sessionToken, refreshToken } = createToken(
-          realDid,
-          {
-            secret,
+        updatedUser = await node.loginUser({
+          teamDid,
+          user: {
+            ...profile,
+            avatar: await extractUserAvatar(get(profile, 'avatar'), {
+              dataDir: blocklet.env.dataDir,
+            }),
+            did: realDid,
+            pk: realPk,
+            locale,
             passport,
-            role,
-            fullName,
-            // NOTE: token 中存储当前的 login provider
-            provider,
-            walletOS,
+            sourceAppPid,
+            lastLoginIp: getRequestIP(request),
+            connectedAccount: [connectAccount, connectedNft],
+            inviter,
+          },
+        });
+        await node.createAuditLog(
+          {
+            action: 'addUser',
+            args: {
+              teamDid,
+              userDid: realDid,
+              sourceAppPid,
+              provider,
+              reason: `first login as ${passportForLog.role}`,
+            },
+            context: formatContext(Object.assign(request, { user: updatedUser })),
+            result: updatedUser,
           },
-          { ...sessionConfig, didConnectVersion: getDidConnectVersion(request) }
+          node
         );
-        logger.info(`${action}.success`, { userDid: realDid, role });
-
-        if (
-          // if user provides owner passport AND app does not have owner, set this user to owner
-          (vc && role === ROLES.OWNER && !blocklet.settings?.owner) ||
-          // if the user will receive a owner passport AND app does not have owner, set this user to owner
-          (issuePassport && defaultRole === ROLES.OWNER && !blocklet.settings?.owner)
-        ) {
-          logger.info('Bind owner for blocklet', { teamDid, userDid: realDid });
-          await node.setBlockletInitialized({ did: teamDid, owner: { did: realDid, pk: realPk } });
-        }
+      }
+      const lastLoginIp = getRequestIP(request);
+      const walletDeviceMessageToken = request.get('wallet-device-message-token');
+      const walletDeviceId = request.get('wallet-device-id');
+      const ua = request.get('user-agent');
+      // request.context.store.connectedWallet
+      const walletOS = request.context.didwallet.os;
+
+      const userSessionDoc = await node.upsertUserSession({
+        teamDid,
+        visitorId,
+        userDid: realDid,
+        appPid: teamDid,
+        passportId: passport?.id,
+        status: 'online',
+        ua,
+        lastLoginIp,
+        extra: {
+          walletOS,
+          walletDeviceMessageToken,
+          walletDeviceId,
+        },
+      });
 
-        // @note: 当第一个用户将要成为 owner 的时候,也是需要绑定 DID Space 的,所以延后执行在此时设置 DID Spaces
-        const shouldConnectSpace = claims.some(
-          (x) => x?.meta?.purpose === 'DidSpace' && ['asset', 'verifiableCredential'].includes(x.type)
-        );
-        if (action === 'login' && shouldConnectSpace) {
-          const didSpaceInfo = await getDidSpacesInfoByClaims({ claims });
-
-          const appUrl = getAppUrl(blocklet);
-          const { data } = await silentAuthorizationInConnect(didSpaceInfo, {
-            appInfo: {
-              appDid: blocklet.appDid,
-              appName: getAppName(blocklet),
-              appDescription: getAppDescription(blocklet),
-              appUrl,
-              scopes: DID_SPACES.AUTHORIZE.DEFAULT_SCOPE,
-              referrer: joinURL(appUrl, '/.well-known/service/connect'),
-              metadata: {
-                did: blocklet.meta.did,
-              },
-            },
-            verifyNFTParams: {
-              claims,
-              challenge,
-              locale,
+      if (shouldSyncFederated(sourceAppPid, blocklet)) {
+        node
+          .syncFederated({
+            did: teamDid,
+            data: {
+              users: [
+                {
+                  did: updatedUser.did,
+                  pk: updatedUser.pk,
+                  fullName: updatedUser.fullName,
+                  email: updatedUser.email || '',
+                  avatar: getUserAvatarUrl(updatedUser.avatar, blocklet),
+                  connectedAccount: [connectAccount, connectedNft],
+                  action: 'connectAccount',
+                  sourceAppPid: sourceAppPid || masterSite.appPid,
+                  inviter: updatedUser.inviter,
+                  generation: updatedUser.generation,
+                },
+              ],
             },
+          })
+          .then(() => {
+            node.syncUserSession({
+              teamDid,
+              userDid: realDid,
+              visitorId: userSessionDoc.visitorId,
+              passportId: passport?.id,
+              targetAppPid: sourceAppPid,
+              ua,
+              lastLoginIp,
+              extra: {
+                walletOS,
+                walletDeviceMessageToken,
+                walletDeviceId,
+              },
+            });
           });
+      }
 
-          /**
-           * @type {Omit<import('@abtnode/client').SpaceGatewayInput, 'protected'>}
-           */
-          const spaceGateway = {
-            did: data.did,
-            name: data.name,
-            endpoint: data.endpoint,
-            url: didSpaceInfo.didSpacesCoreUrl,
-          };
+      // Generate new session token that client can save to localStorage
+      const createToken = createTokenFn(createSessionToken);
+      const sessionConfig = blocklet.settings?.session || {};
 
-          const user = await node.getUser({
-            teamDid,
-            user: {
-              did: userDid,
-            },
-            options: {
-              enableConnectedAccount: true,
-            },
-          });
+      const { sessionToken, refreshToken } = createToken(
+        realDid,
+        {
+          secret,
+          passport,
+          role,
+          fullName,
+          // NOTE: token 中存储当前的 login provider
+          provider,
+          walletOS,
+        },
+        { ...sessionConfig, didConnectVersion: getDidConnectVersion(request) }
+      );
+      logger.info(`${action}.success`, { userDid: realDid, role });
+
+      if (
+        // if user provides owner passport AND app does not have owner, set this user to owner
+        (vc && role === ROLES.OWNER && !blocklet.settings?.owner) ||
+        // if the user will receive a owner passport AND app does not have owner, set this user to owner
+        (issuePassport && defaultRole === ROLES.OWNER && !blocklet.settings?.owner)
+      ) {
+        logger.info('Bind owner for blocklet', { teamDid, userDid: realDid });
+        await node.setBlockletInitialized({ did: teamDid, owner: { did: realDid, pk: realPk } });
+      }
 
-          await node.updateUser({
-            teamDid,
-            user: {
-              did: user.did,
-              didSpace: {
-                ...user?.didSpace,
-                ...spaceGateway,
-              },
+      // @note: 当第一个用户将要成为 owner 的时候,也是需要绑定 DID Space 的,所以延后执行在此时设置 DID Spaces
+      const shouldConnectSpace = claims.some(
+        (x) => x?.meta?.purpose === 'DidSpace' && ['asset', 'verifiableCredential'].includes(x.type)
+      );
+      if (action === 'login' && shouldConnectSpace) {
+        const didSpaceInfo = await getDidSpacesInfoByClaims({ claims });
+
+        const appUrl = getAppUrl(blocklet);
+        const { data } = await silentAuthorizationInConnect(didSpaceInfo, {
+          appInfo: {
+            appDid: blocklet.appDid,
+            appName: getAppName(blocklet),
+            appDescription: getAppDescription(blocklet),
+            appUrl,
+            scopes: DID_SPACES.AUTHORIZE.DEFAULT_SCOPE,
+            referrer: joinURL(appUrl, '/.well-known/service/connect'),
+            metadata: {
+              did: blocklet.meta.did,
             },
-          });
-        }
+          },
+          verifyNFTParams: {
+            claims,
+            challenge,
+            locale,
+          },
+        });
 
-        // @NOTE: 异步地刷新 profile
-        Profile.refresh({
-          node,
-          blocklet,
+        /**
+         * @type {Omit<import('@abtnode/client').SpaceGatewayInput, 'protected'>}
+         */
+        const spaceGateway = {
+          did: data.did,
+          name: data.name,
+          endpoint: data.endpoint,
+          url: didSpaceInfo.didSpacesCoreUrl,
+        };
+
+        const user = await node.getUser({
           teamDid,
-          userDid,
-        }).catch((error) => console.warn(error));
+          user: {
+            did: userDid,
+          },
+          options: {
+            enableConnectedAccount: true,
+          },
+        });
 
-        // issue passport for the first login user in a invite-only team
-        if (issuePassport) {
-          return {
-            disposition: 'attachment',
-            type: 'VerifiableCredential',
-            data: vc,
-            sessionToken,
-            refreshToken,
-            visitorId: userSessionDoc.visitorId,
-            nextWorkflowData: {
-              userDid: realDid,
+        await node.updateUser({
+          teamDid,
+          user: {
+            did: user.did,
+            didSpace: {
+              ...user?.didSpace,
+              ...spaceGateway,
             },
-          };
-        }
+          },
+        });
+      }
+
+      // @NOTE: 异步地刷新 profile
+      Profile.refresh({
+        node,
+        blocklet,
+        teamDid,
+        userDid,
+      }).catch((error) => console.warn(error));
 
+      // issue passport for the first login user in a invite-only team
+      if (issuePassport) {
         return {
+          disposition: 'attachment',
+          type: 'VerifiableCredential',
+          data: vc,
           sessionToken,
           refreshToken,
           visitorId: userSessionDoc.visitorId,
@@ -754,7 +723,17 @@ module.exports = {
             userDid: realDid,
           },
         };
-      },
+      }
+
+      return {
+        sessionToken,
+        refreshToken,
+        visitorId: userSessionDoc.visitorId,
+        nextWorkflowData: {
+          userDid: realDid,
+        },
+      };
+    },
   },
 
   switchProfile: {
@@ -846,7 +825,17 @@ module.exports = {
         node
       );
 
-      const syncUserData = pick(doc, ['did', 'pk', 'fullName', 'avatar', 'email', 'phone', 'url']);
+      const syncUserData = pick(doc, [
+        'did',
+        'pk',
+        'fullName',
+        'avatar',
+        'email',
+        'phone',
+        'url',
+        'inviter',
+        'generation',
+      ]);
       if (syncUserData.avatar) {
         syncUserData.avatar = getUserAvatarUrl(syncUserData.avatar, blocklet);
       }
@@ -1172,6 +1161,8 @@ module.exports = {
         email: bindUser?.email,
         fullName: bindUser?.fullName,
         avatar: bindUser?.avatar,
+        inviter: bindUser?.inviter,
+        generation: bindUser?.generation,
       });
       const currentTime = new Date().toISOString();