diff --git a/keyserver/src/creators/account-creator.js b/keyserver/src/creators/account-creator.js
index 34e480ba0..25c3425ce 100644
--- a/keyserver/src/creators/account-creator.js
+++ b/keyserver/src/creators/account-creator.js
@@ -1,325 +1,312 @@
 // @flow
 
 import { getRustAPI } from 'rust-node-addon';
 import bcrypt from 'twin-bcrypt';
 
 import ashoat from 'lib/facts/ashoat.js';
 import bots from 'lib/facts/bots.js';
 import genesis from 'lib/facts/genesis.js';
 import { policyTypes } from 'lib/facts/policies.js';
-import {
-  validUsernameRegex,
-  oldValidUsernameRegex,
-} from 'lib/shared/account-utils.js';
-import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
+import { validUsernameRegex } from 'lib/shared/account-utils.js';
 import type {
   RegisterResponse,
   RegisterRequest,
 } from 'lib/types/account-types.js';
 import type {
   ReservedUsernameMessage,
   SignedIdentityKeysBlob,
 } from 'lib/types/crypto-types.js';
 import type {
   PlatformDetails,
   DeviceTokenUpdateRequest,
 } from 'lib/types/device-types.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import type { SIWESocialProof } from 'lib/types/siwe-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import { reservedUsernamesSet } from 'lib/utils/reserved-users.js';
 import { isValidEthereumAddress } from 'lib/utils/siwe-utils.js';
 
 import createIDs from './id-creator.js';
 import createMessages from './message-creator.js';
 import { createOlmSession } from './olm-session-creator.js';
 import {
   createThread,
   createPrivateThread,
   privateThreadDescription,
 } from './thread-creator.js';
 import { dbQuery, SQL } from '../database/database.js';
 import { deleteCookie } from '../deleters/cookie-deleters.js';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
 import {
   fetchLoggedInUserInfo,
   fetchKnownUserInfos,
 } from '../fetchers/user-fetchers.js';
 import { verifyCalendarQueryThreadIDs } from '../responders/entry-responders.js';
 import { handleAsyncPromise } from '../responders/handlers.js';
 import { createNewUserCookie, setNewSession } from '../session/cookies.js';
 import { createScriptViewer } from '../session/scripts.js';
 import type { Viewer } from '../session/viewer.js';
 import { fetchOlmAccount } from '../updaters/olm-account-updater.js';
 import { updateThread } from '../updaters/thread-updaters.js';
 import { viewerAcknowledgmentUpdater } from '../updaters/viewer-acknowledgment-updater.js';
 
 const { commbot } = bots;
 
 const ashoatMessages = [
   'welcome to Comm!',
   'as you inevitably discover bugs, have feature requests, or design ' +
     'suggestions, feel free to message them to me in the app.',
 ];
 
 const privateMessages = [privateThreadDescription];
 
 async function createAccount(
   viewer: Viewer,
   request: RegisterRequest,
 ): Promise<RegisterResponse> {
   if (request.password.trim() === '') {
     throw new ServerError('empty_password');
   }
-  const usernameRegex = hasMinCodeVersion(viewer.platformDetails, {
-    native: 69,
-  })
-    ? validUsernameRegex
-    : oldValidUsernameRegex;
-  if (request.username.search(usernameRegex) === -1) {
+  if (request.username.search(validUsernameRegex) === -1) {
     throw new ServerError('invalid_username');
   }
 
   const usernameQuery = SQL`
     SELECT COUNT(id) AS count
     FROM users
     WHERE LCASE(username) = LCASE(${request.username})
   `;
   const promises = [dbQuery(usernameQuery)];
   const {
     calendarQuery,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
   } = request;
   if (calendarQuery) {
     promises.push(verifyCalendarQueryThreadIDs(calendarQuery));
   }
 
   const [[usernameResult]] = await Promise.all(promises);
   if (
     reservedUsernamesSet.has(request.username.toLowerCase()) ||
     isValidEthereumAddress(request.username.toLowerCase())
   ) {
-    if (hasMinCodeVersion(viewer.platformDetails, { native: 120 })) {
-      throw new ServerError('username_reserved');
-    } else {
-      throw new ServerError('username_taken');
-    }
+    throw new ServerError('username_reserved');
   }
   if (usernameResult[0].count !== 0) {
     throw new ServerError('username_taken');
   }
 
   const hash = bcrypt.hashSync(request.password);
   const time = Date.now();
   const deviceToken = request.deviceTokenUpdateRequest
     ? request.deviceTokenUpdateRequest.deviceToken
     : viewer.deviceToken;
   const [id] = await createIDs('users', 1);
   const newUserRow = [id, request.username, hash, time];
   const newUserQuery = SQL`
     INSERT INTO users(id, username, hash, creation_time)
     VALUES ${[newUserRow]}
   `;
 
   const [userViewerData] = await Promise.all([
     createNewUserCookie(id, {
       platformDetails: request.platformDetails,
       deviceToken,
       signedIdentityKeysBlob,
     }),
     deleteCookie(viewer.cookieID),
     dbQuery(newUserQuery),
   ]);
   viewer.setNewCookie(userViewerData);
 
   if (calendarQuery) {
     await setNewSession(viewer, calendarQuery, 0);
   }
 
   const olmSessionPromise = (async () => {
     if (userViewerData.cookieID && initialNotificationsEncryptedMessage) {
       await createOlmSession(
         initialNotificationsEncryptedMessage,
         'notifications',
         userViewerData.cookieID,
       );
     }
   })();
 
   await Promise.all([
     updateThread(
       createScriptViewer(ashoat.id),
       {
         threadID: genesis.id,
         changes: { newMemberIDs: [id] },
       },
       { forceAddMembers: true, silenceMessages: true, ignorePermissions: true },
     ),
     viewerAcknowledgmentUpdater(viewer, policyTypes.tosAndPrivacyPolicy),
     olmSessionPromise,
   ]);
 
   const [privateThreadResult, ashoatThreadResult] = await Promise.all([
     createPrivateThread(viewer),
     createThread(
       viewer,
       {
         type: threadTypes.PERSONAL,
         initialMemberIDs: [ashoat.id],
       },
       { forceAddMembers: true },
     ),
   ]);
   const ashoatThreadID = ashoatThreadResult.newThreadID;
   const privateThreadID = privateThreadResult.newThreadID;
 
   let messageTime = Date.now();
   const ashoatMessageDatas = ashoatMessages.map(message => ({
     type: messageTypes.TEXT,
     threadID: ashoatThreadID,
     creatorID: ashoat.id,
     time: messageTime++,
     text: message,
   }));
   const privateMessageDatas = privateMessages.map(message => ({
     type: messageTypes.TEXT,
     threadID: privateThreadID,
     creatorID: commbot.userID,
     time: messageTime++,
     text: message,
   }));
   const messageDatas = [...ashoatMessageDatas, ...privateMessageDatas];
   const [messageInfos, threadsResult, userInfos, currentUserInfo] =
     await Promise.all([
       createMessages(viewer, messageDatas),
       fetchThreadInfos(viewer),
       fetchKnownUserInfos(viewer),
       fetchLoggedInUserInfo(viewer),
     ]);
   const rawMessageInfos = [
     ...ashoatThreadResult.newMessageInfos,
     ...privateThreadResult.newMessageInfos,
     ...messageInfos,
   ];
 
   const issuedAt = new Date().toISOString();
   const payload: $ReadOnlyArray<string> = [request.username];
   const reservedUsernameMessage: ReservedUsernameMessage = {
     statement: 'Add the following usernames to reserved list',
     payload,
     issuedAt,
   };
   const stringifiedMessage = JSON.stringify(reservedUsernameMessage);
 
   handleAsyncPromise(
     (async () => {
       const rustAPI = await getRustAPI();
       const accountInfo = await fetchOlmAccount('content');
       const signature = accountInfo.account.sign(stringifiedMessage);
       await rustAPI.addReservedUsernames(stringifiedMessage, signature);
     })(),
   );
 
   return {
     id,
     rawMessageInfos,
     currentUserInfo,
     cookieChange: {
       threadInfos: threadsResult.threadInfos,
       userInfos: values(userInfos),
     },
   };
 }
 
 export type ProcessSIWEAccountCreationRequest = {
   +address: string,
   +calendarQuery: CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +platformDetails: PlatformDetails,
   +socialProof: SIWESocialProof,
   +signedIdentityKeysBlob?: ?SignedIdentityKeysBlob,
 };
 // Note: `processSIWEAccountCreation(...)` assumes that the validity of
 //       `ProcessSIWEAccountCreationRequest` was checked at call site.
 async function processSIWEAccountCreation(
   viewer: Viewer,
   request: ProcessSIWEAccountCreationRequest,
 ): Promise<string> {
   const { calendarQuery, signedIdentityKeysBlob } = request;
   await verifyCalendarQueryThreadIDs(calendarQuery);
 
   const time = Date.now();
   const deviceToken = request.deviceTokenUpdateRequest
     ? request.deviceTokenUpdateRequest.deviceToken
     : viewer.deviceToken;
   const [id] = await createIDs('users', 1);
   const newUserRow = [id, request.address, request.address, time];
   const newUserQuery = SQL`
     INSERT INTO users(id, username, ethereum_address, creation_time)
     VALUES ${[newUserRow]}
   `;
   const [userViewerData] = await Promise.all([
     createNewUserCookie(id, {
       platformDetails: request.platformDetails,
       deviceToken,
       socialProof: request.socialProof,
       signedIdentityKeysBlob,
     }),
     deleteCookie(viewer.cookieID),
     dbQuery(newUserQuery),
   ]);
   viewer.setNewCookie(userViewerData);
 
   await setNewSession(viewer, calendarQuery, 0);
 
   await Promise.all([
     updateThread(
       createScriptViewer(ashoat.id),
       {
         threadID: genesis.id,
         changes: { newMemberIDs: [id] },
       },
       { forceAddMembers: true, silenceMessages: true, ignorePermissions: true },
     ),
     viewerAcknowledgmentUpdater(viewer, policyTypes.tosAndPrivacyPolicy),
   ]);
 
   const [privateThreadResult, ashoatThreadResult] = await Promise.all([
     createPrivateThread(viewer),
     createThread(
       viewer,
       {
         type: threadTypes.PERSONAL,
         initialMemberIDs: [ashoat.id],
       },
       { forceAddMembers: true },
     ),
   ]);
   const ashoatThreadID = ashoatThreadResult.newThreadID;
   const privateThreadID = privateThreadResult.newThreadID;
 
   let messageTime = Date.now();
   const ashoatMessageDatas = ashoatMessages.map(message => ({
     type: messageTypes.TEXT,
     threadID: ashoatThreadID,
     creatorID: ashoat.id,
     time: messageTime++,
     text: message,
   }));
   const privateMessageDatas = privateMessages.map(message => ({
     type: messageTypes.TEXT,
     threadID: privateThreadID,
     creatorID: commbot.userID,
     time: messageTime++,
     text: message,
   }));
   const messageDatas = [...ashoatMessageDatas, ...privateMessageDatas];
   await Promise.all([createMessages(viewer, messageDatas)]);
   return id;
 }
 
 export { createAccount, processSIWEAccountCreation };
diff --git a/keyserver/src/creators/thread-creator.js b/keyserver/src/creators/thread-creator.js
index e61d29d85..22a828e64 100644
--- a/keyserver/src/creators/thread-creator.js
+++ b/keyserver/src/creators/thread-creator.js
@@ -1,512 +1,508 @@
 // @flow
 
 import invariant from 'invariant';
 
 import bots from 'lib/facts/bots.js';
 import genesis from 'lib/facts/genesis.js';
 import { getRolePermissionBlobs } from 'lib/permissions/thread-permissions.js';
 import {
   generatePendingThreadColor,
   generateRandomColor,
 } from 'lib/shared/color-utils.js';
 import { getThreadTypeParentRequirement } from 'lib/shared/thread-utils.js';
-import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
 import type { Shape } from 'lib/types/core.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import {
   threadTypes,
   threadTypeIsCommunityRoot,
 } from 'lib/types/thread-types-enum.js';
 import {
   type ServerNewThreadRequest,
   type NewThreadResponse,
 } from 'lib/types/thread-types.js';
 import type { UserInfos } from 'lib/types/user-types.js';
 import { pushAll } from 'lib/utils/array.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import { firstLine } from 'lib/utils/string-utils.js';
 
 import createIDs from './id-creator.js';
 import createMessages from './message-creator.js';
 import { createInitialRolesForNewThread } from './role-creator.js';
 import type { UpdatesForCurrentSession } from './update-creator.js';
 import { dbQuery, SQL } from '../database/database.js';
 import {
   fetchLatestEditMessageContentByID,
   fetchMessageInfoByID,
 } from '../fetchers/message-fetchers.js';
 import {
   determineThreadAncestry,
   personalThreadQuery,
 } from '../fetchers/thread-fetchers.js';
 import {
   checkThreadPermission,
   validateCandidateMembers,
 } from '../fetchers/thread-permission-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   changeRole,
   recalculateThreadPermissions,
   commitMembershipChangeset,
   getChangesetCommitResultForExistingThread,
 } from '../updaters/thread-permission-updaters.js';
 import { joinThread } from '../updaters/thread-updaters.js';
 import RelationshipChangeset from '../utils/relationship-changeset.js';
 
 const { commbot } = bots;
 
 const privateThreadDescription: string =
   'This is your private chat, ' +
   'where you can set reminders and jot notes in private!';
 
 type CreateThreadOptions = Shape<{
   +forceAddMembers: boolean,
   +updatesForCurrentSession: UpdatesForCurrentSession,
   +silentlyFailMembers: boolean,
 }>;
 
 // If forceAddMembers is set, we will allow the viewer to add random users who
 // they aren't friends with. We will only fail if the viewer is trying to add
 // somebody who they have blocked or has blocked them. On the other hand, if
 // forceAddMembers is not set, we will fail if the viewer tries to add somebody
 // who they aren't friends with and doesn't have a membership row with a
 // nonnegative role for the parent thread.
 async function createThread(
   viewer: Viewer,
   request: ServerNewThreadRequest,
   options?: CreateThreadOptions,
 ): Promise<NewThreadResponse> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const forceAddMembers = options?.forceAddMembers ?? false;
   const updatesForCurrentSession =
     options?.updatesForCurrentSession ?? 'return';
   const silentlyFailMembers = options?.silentlyFailMembers ?? false;
 
   const threadType = request.type;
   const shouldCreateRelationships =
     forceAddMembers || threadType === threadTypes.PERSONAL;
   let parentThreadID = request.parentThreadID ? request.parentThreadID : null;
   const initialMemberIDsFromRequest =
     request.initialMemberIDs && request.initialMemberIDs.length > 0
       ? [...new Set(request.initialMemberIDs)]
       : null;
   const ghostMemberIDsFromRequest =
     request.ghostMemberIDs && request.ghostMemberIDs.length > 0
       ? [...new Set(request.ghostMemberIDs)]
       : null;
 
   const sourceMessageID = request.sourceMessageID
     ? request.sourceMessageID
     : null;
   invariant(
     threadType !== threadTypes.SIDEBAR || sourceMessageID,
     'sourceMessageID should be set for sidebar',
   );
 
   const parentRequirement = getThreadTypeParentRequirement(threadType);
   if (
     (parentRequirement === 'required' && !parentThreadID) ||
     (parentRequirement === 'disabled' && parentThreadID)
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   if (
     threadType === threadTypes.PERSONAL &&
     request.initialMemberIDs?.length !== 1
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   const requestParentThreadID = parentThreadID;
   const confirmParentPermissionPromise = (async () => {
     if (!requestParentThreadID) {
       return;
     }
     const hasParentPermission = await checkThreadPermission(
       viewer,
       requestParentThreadID,
       threadType === threadTypes.SIDEBAR
         ? threadPermissions.CREATE_SIDEBARS
         : threadPermissions.CREATE_SUBCHANNELS,
     );
     if (!hasParentPermission) {
       throw new ServerError('invalid_credentials');
     }
   })();
 
   // This is a temporary hack until we release actual E2E-encrypted local
   // conversations. For now we are hosting all root threads on Ashoat's
   // keyserver, so we set them to the have the Genesis community as their
   // parent thread.
   if (!parentThreadID && !threadTypeIsCommunityRoot(threadType)) {
     parentThreadID = genesis.id;
   }
 
   const determineThreadAncestryPromise = determineThreadAncestry(
     parentThreadID,
     threadType,
   );
 
   const validateMembersPromise = (async () => {
     const threadAncestry = await determineThreadAncestryPromise;
     const defaultRolePermissions = getRolePermissionBlobs(threadType).Members;
     const { initialMemberIDs, ghostMemberIDs } = await validateCandidateMembers(
       viewer,
       {
         initialMemberIDs: initialMemberIDsFromRequest,
         ghostMemberIDs: ghostMemberIDsFromRequest,
       },
       {
         threadType,
         parentThreadID,
         containingThreadID: threadAncestry.containingThreadID,
         defaultRolePermissions,
       },
       { requireRelationship: !shouldCreateRelationships },
     );
     if (
       !silentlyFailMembers &&
       (Number(initialMemberIDs?.length) <
         Number(initialMemberIDsFromRequest?.length) ||
         Number(ghostMemberIDs?.length) <
           Number(ghostMemberIDsFromRequest?.length))
     ) {
       throw new ServerError('invalid_credentials');
     }
     return { initialMemberIDs, ghostMemberIDs };
   })();
 
   const checkPromises = {};
   checkPromises.confirmParentPermission = confirmParentPermissionPromise;
   checkPromises.threadAncestry = determineThreadAncestryPromise;
   checkPromises.validateMembers = validateMembersPromise;
   if (sourceMessageID) {
     checkPromises.sourceMessage = fetchMessageInfoByID(viewer, sourceMessageID);
   }
   const {
     sourceMessage,
     threadAncestry,
     validateMembers: { initialMemberIDs, ghostMemberIDs },
   } = await promiseAll(checkPromises);
 
   if (
     sourceMessage &&
     (sourceMessage.type === messageTypes.REACTION ||
       sourceMessage.type === messageTypes.EDIT_MESSAGE)
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   let { id } = request;
   if (id === null || id === undefined) {
     const ids = await createIDs('threads', 1);
     id = ids[0];
   }
   const newRoles = await createInitialRolesForNewThread(id, threadType);
 
   const name = request.name ? firstLine(request.name) : null;
   const description = request.description ? request.description : null;
   let color = request.color
     ? request.color.toLowerCase()
     : generateRandomColor();
   if (threadType === threadTypes.PERSONAL) {
     color = generatePendingThreadColor([
       ...(request.initialMemberIDs ?? []),
       viewer.id,
     ]);
   }
 
   const time = Date.now();
 
   const row = [
     id,
     threadType,
     name,
     description,
     viewer.userID,
     time,
     color,
     parentThreadID,
     threadAncestry.containingThreadID,
     threadAncestry.community,
     threadAncestry.depth,
     newRoles.default.id,
     sourceMessageID,
   ];
 
   let existingThreadQuery = null;
   if (threadType === threadTypes.PERSONAL) {
     const otherMemberID = initialMemberIDs?.[0];
     invariant(
       otherMemberID,
       'Other member id should be set for a PERSONAL thread',
     );
     existingThreadQuery = personalThreadQuery(viewer.userID, otherMemberID);
   } else if (sourceMessageID) {
     existingThreadQuery = SQL`
       SELECT t.id
       FROM threads t
       WHERE t.source_message = ${sourceMessageID}
     `;
   }
 
   if (existingThreadQuery) {
     const query = SQL`
       INSERT INTO threads(id, type, name, description, creator, creation_time,
         color, parent_thread_id, containing_thread_id, community, depth,
         default_role, source_message)
       SELECT ${row}
       WHERE NOT EXISTS (`;
     query.append(existingThreadQuery).append(SQL`)`);
     const [result] = await dbQuery(query);
 
     if (result.affectedRows === 0) {
       const deleteRoles = SQL`
         DELETE FROM roles
         WHERE id IN (${newRoles.default.id}, ${newRoles.creator.id})
       `;
       const deleteIDs = SQL`
         DELETE FROM ids
         WHERE id IN (${id}, ${newRoles.default.id}, ${newRoles.creator.id})
       `;
       const [[existingThreadResult]] = await Promise.all([
         dbQuery(existingThreadQuery),
         dbQuery(deleteRoles),
         dbQuery(deleteIDs),
       ]);
       invariant(existingThreadResult.length > 0, 'thread should exist');
       const existingThreadID = existingThreadResult[0].id.toString();
 
-      let calendarQuery;
-      if (hasMinCodeVersion(viewer.platformDetails, { native: 87 })) {
-        invariant(request.calendarQuery, 'calendar query should exist');
-        calendarQuery = {
-          ...request.calendarQuery,
-          filters: [
-            ...request.calendarQuery.filters,
-            { type: 'threads', threadIDs: [existingThreadID] },
-          ],
-        };
-      }
+      invariant(request.calendarQuery, 'calendar query should exist');
+      const calendarQuery = {
+        ...request.calendarQuery,
+        filters: [
+          ...request.calendarQuery.filters,
+          { type: 'threads', threadIDs: [existingThreadID] },
+        ],
+      };
 
       let joinUpdateInfos = [];
       let userInfos: UserInfos = {};
       let newMessageInfos = [];
       if (threadType !== threadTypes.PERSONAL) {
         const joinThreadResult = await joinThread(viewer, {
           threadID: existingThreadID,
           calendarQuery,
         });
         joinUpdateInfos = joinThreadResult.updatesResult.newUpdates;
         userInfos = joinThreadResult.userInfos;
         newMessageInfos = joinThreadResult.rawMessageInfos;
       }
 
       const { viewerUpdates: newUpdates, userInfos: changesetUserInfos } =
         await getChangesetCommitResultForExistingThread(
           viewer,
           existingThreadID,
           joinUpdateInfos,
           { calendarQuery, updatesForCurrentSession },
         );
       userInfos = { ...userInfos, ...changesetUserInfos };
 
       return {
         newThreadID: existingThreadID,
         updatesResult: {
           newUpdates,
         },
         userInfos,
         newMessageInfos,
       };
     }
   } else {
     const query = SQL`
       INSERT INTO threads(id, type, name, description, creator, creation_time,
         color, parent_thread_id, containing_thread_id, community, depth,
         default_role, source_message)
       VALUES ${[row]}
     `;
     await dbQuery(query);
   }
 
   let initialMemberPromise;
   if (initialMemberIDs) {
     initialMemberPromise = changeRole(id, initialMemberIDs, null, {
       setNewMembersToUnread: true,
     });
   }
   let ghostMemberPromise;
   if (ghostMemberIDs) {
     ghostMemberPromise = changeRole(id, ghostMemberIDs, -1);
   }
 
   const [
     creatorChangeset,
     initialMembersChangeset,
     ghostMembersChangeset,
     recalculatePermissionsChangeset,
   ] = await Promise.all([
     changeRole(id, [viewer.userID], newRoles.creator.id),
     initialMemberPromise,
     ghostMemberPromise,
     recalculateThreadPermissions(id),
   ]);
 
   const {
     membershipRows: creatorMembershipRows,
     relationshipChangeset: creatorRelationshipChangeset,
   } = creatorChangeset;
 
   const {
     membershipRows: recalculateMembershipRows,
     relationshipChangeset: recalculateRelationshipChangeset,
   } = recalculatePermissionsChangeset;
 
   const membershipRows = [
     ...creatorMembershipRows,
     ...recalculateMembershipRows,
   ];
   const relationshipChangeset = new RelationshipChangeset();
   relationshipChangeset.addAll(creatorRelationshipChangeset);
   relationshipChangeset.addAll(recalculateRelationshipChangeset);
 
   if (initialMembersChangeset) {
     const {
       membershipRows: initialMembersMembershipRows,
       relationshipChangeset: initialMembersRelationshipChangeset,
     } = initialMembersChangeset;
     pushAll(membershipRows, initialMembersMembershipRows);
     relationshipChangeset.addAll(initialMembersRelationshipChangeset);
   }
   if (ghostMembersChangeset) {
     const {
       membershipRows: ghostMembersMembershipRows,
       relationshipChangeset: ghostMembersRelationshipChangeset,
     } = ghostMembersChangeset;
     pushAll(membershipRows, ghostMembersMembershipRows);
     relationshipChangeset.addAll(ghostMembersRelationshipChangeset);
   }
 
   const changeset = { membershipRows, relationshipChangeset };
   const { viewerUpdates, userInfos } = await commitMembershipChangeset(
     viewer,
     changeset,
     {
       updatesForCurrentSession,
     },
   );
 
   const initialMemberAndCreatorIDs = initialMemberIDs
     ? [...initialMemberIDs, viewer.userID]
     : [viewer.userID];
   const messageDatas = [];
   if (threadType !== threadTypes.SIDEBAR) {
     messageDatas.push({
       type: messageTypes.CREATE_THREAD,
       threadID: id,
       creatorID: viewer.userID,
       time,
       initialThreadState: {
         type: threadType,
         name,
         parentThreadID,
         color,
         memberIDs: initialMemberAndCreatorIDs,
       },
     });
   } else {
     invariant(parentThreadID, 'parentThreadID should be set for sidebar');
     if (!sourceMessage || sourceMessage.type === messageTypes.SIDEBAR_SOURCE) {
       throw new ServerError('invalid_parameters');
     }
 
     let editedSourceMessage = sourceMessage;
     if (sourceMessageID && sourceMessage.type === messageTypes.TEXT) {
       const editMessageContent = await fetchLatestEditMessageContentByID(
         sourceMessageID,
       );
       if (editMessageContent) {
         editedSourceMessage = {
           ...sourceMessage,
           text: editMessageContent.text,
         };
       }
     }
 
     messageDatas.push(
       {
         type: messageTypes.SIDEBAR_SOURCE,
         threadID: id,
         creatorID: viewer.userID,
         time,
         sourceMessage: editedSourceMessage,
       },
       {
         type: messageTypes.CREATE_SIDEBAR,
         threadID: id,
         creatorID: viewer.userID,
         time,
         sourceMessageAuthorID: sourceMessage.creatorID,
         initialThreadState: {
           name,
           parentThreadID,
           color,
           memberIDs: initialMemberAndCreatorIDs,
         },
       },
     );
   }
 
   if (
     parentThreadID &&
     threadType !== threadTypes.SIDEBAR &&
     (parentThreadID !== genesis.id ||
       threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
       threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD)
   ) {
     messageDatas.push({
       type: messageTypes.CREATE_SUB_THREAD,
       threadID: parentThreadID,
       creatorID: viewer.userID,
       time,
       childThreadID: id,
     });
   }
   const newMessageInfos = await createMessages(
     viewer,
     messageDatas,
     updatesForCurrentSession,
   );
 
   return {
     newThreadID: id,
     updatesResult: {
       newUpdates: viewerUpdates,
     },
     userInfos,
     newMessageInfos,
   };
 }
 
 function createPrivateThread(viewer: Viewer): Promise<NewThreadResponse> {
   return createThread(
     viewer,
     {
       type: threadTypes.PRIVATE,
       description: privateThreadDescription,
       ghostMemberIDs: [commbot.userID],
     },
     {
       forceAddMembers: true,
     },
   );
 }
 
 export { createThread, createPrivateThread, privateThreadDescription };
diff --git a/keyserver/src/fetchers/user-fetchers.js b/keyserver/src/fetchers/user-fetchers.js
index 2baec084a..e182e9710 100644
--- a/keyserver/src/fetchers/user-fetchers.js
+++ b/keyserver/src/fetchers/user-fetchers.js
@@ -1,446 +1,435 @@
 // @flow
 
 import invariant from 'invariant';
 
-import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
+import {
+  hasMinCodeVersion,
+  FUTURE_CODE_VERSION,
+} from 'lib/shared/version-utils.js';
 import type { AvatarDBContent, ClientAvatar } from 'lib/types/avatar-types.js';
 import {
   undirectedStatus,
   directedStatus,
   userRelationshipStatus,
 } from 'lib/types/relationship-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { communityThreadTypes } from 'lib/types/thread-types-enum.js';
 import type {
   UserInfos,
   CurrentUserInfo,
   OldCurrentUserInfo,
   LoggedInUserInfo,
   OldLoggedInUserInfo,
   GlobalUserInfo,
 } from 'lib/types/user-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 
 import { getUploadURL } from './upload-fetchers.js';
 import { dbQuery, SQL } from '../database/database.js';
 import type { Viewer } from '../session/viewer.js';
 
 async function fetchUserInfos(
   userIDs: $ReadOnlyArray<string>,
 ): Promise<{ [id: string]: GlobalUserInfo }> {
   if (userIDs.length <= 0) {
     return {};
   }
 
   const query = SQL`
     SELECT u.id, u.username, u.avatar,
       up.id AS upload_id, up.secret AS upload_secret
     FROM users u
     LEFT JOIN uploads up
       ON up.container = u.id
     WHERE u.id IN (${userIDs})
   `;
   const [result] = await dbQuery(query);
 
   const userInfos = {};
   for (const row of result) {
     const id = row.id.toString();
     const avatar: ?AvatarDBContent = row.avatar ? JSON.parse(row.avatar) : null;
 
     let clientAvatar: ?ClientAvatar;
     if (avatar && avatar.type !== 'image') {
       clientAvatar = avatar;
     } else if (
       avatar &&
       avatar.type === 'image' &&
       row.upload_id &&
       row.upload_secret
     ) {
       const uploadID = row.upload_id.toString();
       invariant(
         uploadID === avatar.uploadID,
         'uploadID of upload should match uploadID of image avatar',
       );
       clientAvatar = {
         type: 'image',
         uri: getUploadURL(uploadID, row.upload_secret),
       };
     }
 
     userInfos[id] = clientAvatar
       ? {
           id,
           username: row.username,
           avatar: clientAvatar,
         }
       : {
           id,
           username: row.username,
         };
   }
 
   for (const userID of userIDs) {
     if (!userInfos[userID]) {
       userInfos[userID] = {
         id: userID,
         username: null,
       };
     }
   }
 
   return userInfos;
 }
 
 async function fetchKnownUserInfos(
   viewer: Viewer,
   userIDs?: $ReadOnlyArray<string>,
 ): Promise<UserInfos> {
   if (!viewer.loggedIn) {
     return {};
   }
   if (userIDs && userIDs.length === 0) {
     return {};
   }
 
   const query = SQL`
     SELECT ru.user1, ru.user2, u.username, u.avatar, ru.status AS undirected_status,
       rd1.status AS user1_directed_status, rd2.status AS user2_directed_status,
       up1.id AS user1_upload_id, up1.secret AS user1_upload_secret,
       up2.id AS user2_upload_id, up2.secret AS user2_upload_secret
     FROM relationships_undirected ru
     LEFT JOIN relationships_directed rd1
       ON rd1.user1 = ru.user1 AND rd1.user2 = ru.user2
     LEFT JOIN relationships_directed rd2
       ON rd2.user1 = ru.user2 AND rd2.user2 = ru.user1
     LEFT JOIN users u
       ON u.id != ${viewer.userID} AND (u.id = ru.user1 OR u.id = ru.user2)
     LEFT JOIN uploads up1
       ON up1.container != ${viewer.userID} AND up1.container = ru.user1
     LEFT JOIN uploads up2
       ON up2.container != ${viewer.userID} AND up2.container = ru.user2
   `;
   if (userIDs) {
     query.append(SQL`
       WHERE (ru.user1 = ${viewer.userID} AND ru.user2 IN (${userIDs})) OR
         (ru.user1 IN (${userIDs}) AND ru.user2 = ${viewer.userID})
     `);
   } else {
     query.append(SQL`
       WHERE ru.user1 = ${viewer.userID} OR ru.user2 = ${viewer.userID}
     `);
   }
   query.append(SQL`
     UNION SELECT u.id AS user1, NULL AS user2, u.username, u.avatar,
       CAST(NULL AS UNSIGNED) AS undirected_status,
       CAST(NULL AS UNSIGNED) AS user1_directed_status,
       CAST(NULL AS UNSIGNED) AS user2_directed_status,
       up.id AS user1_upload_id, up.secret AS user1_upload_secret,
       NULL AS user2_upload_id, NULL AS user2_upload_secret
     FROM users u
     LEFT JOIN uploads up
       ON up.container = u.id
     WHERE u.id = ${viewer.userID}
   `);
   const [result] = await dbQuery(query);
 
   const userInfos = {};
   for (const row of result) {
     const user1 = row.user1.toString();
     const user2 = row.user2 ? row.user2.toString() : null;
     const id = user1 === viewer.userID && user2 ? user2 : user1;
 
     const avatar: ?AvatarDBContent = row.avatar ? JSON.parse(row.avatar) : null;
 
     let clientAvatar: ?ClientAvatar;
     if (avatar && avatar.type !== 'image') {
       clientAvatar = avatar;
     } else if (
       avatar &&
       avatar.type === 'image' &&
       row.user1_upload_id &&
       row.user1_upload_secret
     ) {
       const uploadID = row.user1_upload_id.toString();
       invariant(
         uploadID === avatar.uploadID,
         'uploadID of upload should match uploadID of image avatar',
       );
       clientAvatar = {
         type: 'image',
         uri: getUploadURL(uploadID, row.user1_upload_secret),
       };
     } else if (
       avatar &&
       avatar.type === 'image' &&
       row.user2_upload_id &&
       row.user2_upload_secret
     ) {
       const uploadID = row.user2_upload_id.toString();
       invariant(
         uploadID === avatar.uploadID,
         'uploadID of upload should match uploadID of image avatar',
       );
       clientAvatar = {
         type: 'image',
         uri: getUploadURL(uploadID, row.user2_upload_secret),
       };
     }
 
     const userInfo = clientAvatar
       ? {
           id,
           username: row.username,
           avatar: clientAvatar,
         }
       : {
           id,
           username: row.username,
         };
 
     if (!user2) {
       userInfos[id] = userInfo;
       continue;
     }
 
     let viewerDirectedStatus;
     let targetDirectedStatus;
     if (user1 === viewer.userID) {
       viewerDirectedStatus = row.user1_directed_status;
       targetDirectedStatus = row.user2_directed_status;
     } else {
       viewerDirectedStatus = row.user2_directed_status;
       targetDirectedStatus = row.user1_directed_status;
     }
 
     const viewerBlockedTarget = viewerDirectedStatus === directedStatus.BLOCKED;
     const targetBlockedViewer = targetDirectedStatus === directedStatus.BLOCKED;
     const friendshipExists = row.undirected_status === undirectedStatus.FRIEND;
     const viewerRequestedTargetFriendship =
       viewerDirectedStatus === directedStatus.PENDING_FRIEND;
     const targetRequestedViewerFriendship =
       targetDirectedStatus === directedStatus.PENDING_FRIEND;
 
     let relationshipStatus;
     if (viewerBlockedTarget && targetBlockedViewer) {
       relationshipStatus = userRelationshipStatus.BOTH_BLOCKED;
     } else if (targetBlockedViewer) {
       relationshipStatus = userRelationshipStatus.BLOCKED_VIEWER;
     } else if (viewerBlockedTarget) {
       relationshipStatus = userRelationshipStatus.BLOCKED_BY_VIEWER;
     } else if (friendshipExists) {
       relationshipStatus = userRelationshipStatus.FRIEND;
     } else if (targetRequestedViewerFriendship) {
       relationshipStatus = userRelationshipStatus.REQUEST_RECEIVED;
     } else if (viewerRequestedTargetFriendship) {
       relationshipStatus = userRelationshipStatus.REQUEST_SENT;
     }
 
     userInfos[id] = userInfo;
     if (relationshipStatus) {
       userInfos[id].relationshipStatus = relationshipStatus;
     }
 
     if (relationshipStatus && !row.username) {
       console.warn(
         `user ${viewer.userID} has ${relationshipStatus} relationship with ` +
           `anonymous user ${id}`,
       );
     }
   }
 
   return userInfos;
 }
 
 async function verifyUserIDs(
   userIDs: $ReadOnlyArray<string>,
 ): Promise<string[]> {
   if (userIDs.length === 0) {
     return [];
   }
   const query = SQL`SELECT id FROM users WHERE id IN (${userIDs})`;
   const [result] = await dbQuery(query);
   return result.map(row => row.id.toString());
 }
 
 async function verifyUserOrCookieIDs(
   ids: $ReadOnlyArray<string>,
 ): Promise<string[]> {
   if (ids.length === 0) {
     return [];
   }
   const query = SQL`
     SELECT id FROM users WHERE id IN (${ids})
     UNION SELECT id FROM cookies WHERE id IN (${ids})
   `;
   const [result] = await dbQuery(query);
   return result.map(row => row.id.toString());
 }
 
 async function fetchCurrentUserInfo(
   viewer: Viewer,
 ): Promise<OldCurrentUserInfo | CurrentUserInfo> {
   if (!viewer.loggedIn) {
     return ({ id: viewer.cookieID, anonymous: true }: CurrentUserInfo);
   }
   const currentUserInfo = await fetchLoggedInUserInfo(viewer);
   return currentUserInfo;
 }
 
 async function fetchLoggedInUserInfo(
   viewer: Viewer,
 ): Promise<OldLoggedInUserInfo | LoggedInUserInfo> {
   const userQuery = SQL`
     SELECT u.id, u.username, u.avatar,
       up.id AS upload_id, up.secret AS upload_secret
     FROM users u
     LEFT JOIN uploads up
       ON up.container = u.id
     WHERE u.id = ${viewer.userID}
   `;
 
   const settingsQuery = SQL`
     SELECT name, data
     FROM settings
     WHERE user = ${viewer.userID}
   `;
 
   const [[userResult], [settingsResult]] = await Promise.all([
     dbQuery(userQuery),
     dbQuery(settingsQuery),
   ]);
 
   const [userRow] = userResult;
-
-  const stillExpectsEmailFields = !hasMinCodeVersion(viewer.platformDetails, {
-    native: 87,
-  });
-
   if (!userRow) {
     throw new ServerError('unknown_error');
   }
 
   const id = userRow.id.toString();
   const { username, upload_id, upload_secret } = userRow;
 
-  if (stillExpectsEmailFields) {
-    return {
-      id,
-      username,
-      email: 'removed from DB',
-      emailVerified: true,
-    };
-  }
-
   let loggedInUserInfo: LoggedInUserInfo = {
     id,
     username,
   };
 
   const avatar: ?AvatarDBContent = userRow.avatar
     ? JSON.parse(userRow.avatar)
     : null;
 
   let clientAvatar: ?ClientAvatar;
   if (avatar && avatar.type !== 'image') {
     clientAvatar = avatar;
   } else if (avatar && avatar.type === 'image' && upload_id && upload_secret) {
     const uploadID = upload_id.toString();
     invariant(
       uploadID === avatar.uploadID,
       'uploadID of upload should match uploadID of image avatar',
     );
     clientAvatar = {
       type: 'image',
       uri: getUploadURL(uploadID, upload_secret),
     };
   }
 
   if (avatar) {
     loggedInUserInfo = { ...loggedInUserInfo, avatar: clientAvatar };
   }
 
   const featureGateSettings = !hasMinCodeVersion(viewer.platformDetails, {
-    native: 1000,
+    native: FUTURE_CODE_VERSION,
   });
 
   if (featureGateSettings) {
     return loggedInUserInfo;
   }
 
   const settings = settingsResult.reduce((prev, curr) => {
     prev[curr.name] = curr.data;
     return prev;
   }, {});
   loggedInUserInfo = { ...loggedInUserInfo, settings };
 
   return loggedInUserInfo;
 }
 
 async function fetchAllUserIDs(): Promise<string[]> {
   const query = SQL`SELECT id FROM users`;
   const [result] = await dbQuery(query);
   return result.map(row => row.id.toString());
 }
 
 async function fetchUsername(id: string): Promise<?string> {
   const query = SQL`SELECT username FROM users WHERE id = ${id}`;
   const [result] = await dbQuery(query);
   if (result.length === 0) {
     return null;
   }
   const row = result[0];
   return row.username;
 }
 
 async function fetchAllUsernames(): Promise<string[]> {
   const query = SQL`SELECT username FROM users`;
   const [result] = await dbQuery(query);
   return result.map(row => row.username);
 }
 
 async function fetchKeyserverAdminID(): Promise<?string> {
   const changeRoleExtractString = `$.${threadPermissions.CHANGE_ROLE}`;
   const query = SQL`
     SELECT m.user FROM memberships m
     INNER JOIN roles r ON m.role = r.id
     INNER JOIN threads t ON r.thread = t.id
     WHERE r.name = "Admins" AND 
       t.type IN (${communityThreadTypes}) AND 
       JSON_EXTRACT(r.permissions, ${changeRoleExtractString}) IS TRUE
   `;
   const [result] = await dbQuery(query);
   if (result.length === 0) {
     return null;
   }
   if (result.length > 1) {
     console.warn('more than one community admin found');
   }
 
   return result[0].user;
 }
 
 async function fetchUserIDForEthereumAddress(
   address: string,
 ): Promise<?string> {
   const query = SQL`
     SELECT id
     FROM users
     WHERE LCASE(ethereum_address) = LCASE(${address})
   `;
   const [result] = await dbQuery(query);
   return result.length === 0 ? null : result[0].id.toString();
 }
 
 export {
   fetchUserInfos,
   fetchLoggedInUserInfo,
   verifyUserIDs,
   verifyUserOrCookieIDs,
   fetchCurrentUserInfo,
   fetchAllUserIDs,
   fetchUsername,
   fetchAllUsernames,
   fetchKnownUserInfos,
   fetchKeyserverAdminID,
   fetchUserIDForEthereumAddress,
 };