diff --git a/keyserver/src/creators/update-creator.js b/keyserver/src/creators/update-creator.js
index 0e68d2549..67129fe44 100644
--- a/keyserver/src/creators/update-creator.js
+++ b/keyserver/src/creators/update-creator.js
@@ -1,807 +1,803 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { nonThreadCalendarFilters } from 'lib/selectors/calendar-filter-selectors.js';
 import {
   keyForUpdateData,
   keyForUpdateInfo,
   rawUpdateInfoFromUpdateData,
 } from 'lib/shared/update-utils.js';
 import {
   type RawEntryInfos,
   type FetchEntryInfosBase,
   type CalendarQuery,
   defaultCalendarQuery,
 } from 'lib/types/entry-types.js';
 import {
   defaultNumberPerThread,
   type FetchMessageInfosResult,
   type MessageSelectionCriteria,
 } from 'lib/types/message-types.js';
 import {
   type UpdateTarget,
   redisMessageTypes,
   type NewUpdatesRedisMessage,
 } from 'lib/types/redis-types.js';
 import type { RawThreadInfo } from 'lib/types/thread-types.js';
 import { updateTypes } from 'lib/types/update-types-enum.js';
 import {
   type ServerUpdateInfo,
   type UpdateData,
   type RawUpdateInfo,
   type CreateUpdatesResult,
 } from 'lib/types/update-types.js';
-import type {
-  UserInfos,
-  LoggedInUserInfo,
-  OldLoggedInUserInfo,
-} from 'lib/types/user-types.js';
+import type { UserInfos, LoggedInUserInfo } from 'lib/types/user-types.js';
 import { promiseAll } from 'lib/utils/promises.js';
 
 import createIDs from './id-creator.js';
 import { dbQuery, SQL, mergeAndConditions } from '../database/database.js';
 import type { SQLStatementType } from '../database/types.js';
 import { deleteUpdatesByConditions } from '../deleters/update-deleters.js';
 import {
   fetchEntryInfos,
   fetchEntryInfosByID,
 } from '../fetchers/entry-fetchers.js';
 import { fetchMessageInfos } from '../fetchers/message-fetchers.js';
 import {
   fetchThreadInfos,
   type FetchThreadInfosResult,
 } from '../fetchers/thread-fetchers.js';
 import {
   fetchKnownUserInfos,
   fetchCurrentUserInfo,
 } from '../fetchers/user-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import { channelNameForUpdateTarget, publisher } from '../socket/redis.js';
 
 export type UpdatesForCurrentSession =
   // This is the default if no Viewer is passed, or if an isSocket Viewer is
   // passed in. We will broadcast to all valid sessions via Redis and return
   // nothing to the caller, relying on the current session's Redis listener to
   // pick up the updates and deliver them asynchronously.
   | 'broadcast'
   // This is the default if a non-isSocket Viewer is passed in. We avoid
   // broadcasting the update to the current session, and instead return the
   // update to the caller, who will handle delivering it to the client.
   | 'return'
   // This means we ignore any updates destined for the current session.
   // Presumably the caller knows what they are doing and has a different way of
   // communicating the relevant information to the client.
   | 'ignore';
 
 type DeleteCondition = {
   +userID: string,
   +target: ?string,
   +types: 'all_types' | $ReadOnlySet<number>,
 };
 
 export type ViewerInfo =
   | {
       viewer: Viewer,
       calendarQuery?: ?CalendarQuery,
       updatesForCurrentSession?: UpdatesForCurrentSession,
     }
   | {
       viewer: Viewer,
       calendarQuery: ?CalendarQuery,
       updatesForCurrentSession?: UpdatesForCurrentSession,
       threadInfos: { +[id: string]: RawThreadInfo },
     };
 const defaultUpdateCreationResult = { viewerUpdates: [], userInfos: {} };
 const sortFunction = (
   a: UpdateData | ServerUpdateInfo,
   b: UpdateData | ServerUpdateInfo,
 ) => a.time - b.time;
 const deleteUpdatesBatchSize = 500;
 
 // Creates rows in the updates table based on the inputed updateDatas. Returns
 // UpdateInfos pertaining to the provided viewerInfo, as well as related
 // UserInfos. If no viewerInfo is provided, no UpdateInfos will be returned. And
 // the update row won't have an updater column, meaning no session will be
 // excluded from the update.
 async function createUpdates(
   updateDatas: $ReadOnlyArray<UpdateData>,
   passedViewerInfo?: ?ViewerInfo,
 ): Promise<CreateUpdatesResult> {
   if (updateDatas.length === 0) {
     return defaultUpdateCreationResult;
   }
 
   // viewer.session will throw for a script Viewer
   let viewerInfo = passedViewerInfo;
   if (
     viewerInfo &&
     (viewerInfo.viewer.isScriptViewer || !viewerInfo.viewer.loggedIn)
   ) {
     viewerInfo = null;
   }
 
   const sortedUpdateDatas = [...updateDatas].sort(sortFunction);
 
   const filteredUpdateDatas: UpdateData[] = [];
   const keyedUpdateDatas: Map<string, UpdateData[]> = new Map();
   for (const updateData of sortedUpdateDatas) {
     const key = keyForUpdateData(updateData);
     if (!key) {
       filteredUpdateDatas.push(updateData);
       continue;
     }
     const conditionKey = `${updateData.userID}|${key}`;
 
     const deleteCondition = getDeleteCondition(updateData);
     invariant(
       deleteCondition,
       `updateData of type ${updateData.type} has conditionKey ` +
         `${conditionKey} but no deleteCondition`,
     );
 
     const curUpdateDatas = keyedUpdateDatas.get(conditionKey);
     if (!curUpdateDatas) {
       keyedUpdateDatas.set(conditionKey, [updateData]);
       continue;
     }
 
     const filteredCurrent = curUpdateDatas.filter(curUpdateData =>
       filterOnDeleteCondition(curUpdateData, deleteCondition),
     );
     if (filteredCurrent.length === 0) {
       keyedUpdateDatas.set(conditionKey, [updateData]);
       continue;
     }
 
     const isNewUpdateDataFiltered = !filteredCurrent.every(curUpdateData => {
       const curDeleteCondition = getDeleteCondition(curUpdateData);
       invariant(
         curDeleteCondition,
         `updateData of type ${curUpdateData.type} is in keyedUpdateDatas ` +
           "but doesn't have a deleteCondition",
       );
       return filterOnDeleteCondition(updateData, curDeleteCondition);
     });
     if (!isNewUpdateDataFiltered) {
       filteredCurrent.push(updateData);
     }
     keyedUpdateDatas.set(conditionKey, filteredCurrent);
   }
 
   for (const keyUpdateDatas of keyedUpdateDatas.values()) {
     filteredUpdateDatas.push(...keyUpdateDatas);
   }
   const ids = await createIDs('updates', filteredUpdateDatas.length);
 
   let updatesForCurrentSession =
     viewerInfo && viewerInfo.updatesForCurrentSession;
   if (!updatesForCurrentSession && viewerInfo) {
     updatesForCurrentSession = viewerInfo.viewer.isSocket
       ? 'broadcast'
       : 'return';
   } else if (!updatesForCurrentSession) {
     updatesForCurrentSession = 'broadcast';
   }
   const dontBroadcastSession =
     updatesForCurrentSession !== 'broadcast' && viewerInfo
       ? viewerInfo.viewer.session
       : null;
 
   const publishInfos: Map<string, PublishInfo> = new Map();
   const viewerRawUpdateInfos: RawUpdateInfo[] = [];
   const insertRows: (?(number | string))[][] = [];
   const earliestTime: Map<string, number> = new Map();
   for (let i = 0; i < filteredUpdateDatas.length; i++) {
     const updateData = filteredUpdateDatas[i];
     let content;
     if (updateData.type === updateTypes.DELETE_ACCOUNT) {
       content = JSON.stringify({ deletedUserID: updateData.deletedUserID });
     } else if (updateData.type === updateTypes.UPDATE_THREAD) {
       content = JSON.stringify({ threadID: updateData.threadID });
     } else if (updateData.type === updateTypes.UPDATE_THREAD_READ_STATUS) {
       const { threadID, unread } = updateData;
       content = JSON.stringify({ threadID, unread });
     } else if (
       updateData.type === updateTypes.DELETE_THREAD ||
       updateData.type === updateTypes.JOIN_THREAD
     ) {
       const { threadID } = updateData;
       content = JSON.stringify({ threadID });
     } else if (updateData.type === updateTypes.BAD_DEVICE_TOKEN) {
       const { deviceToken } = updateData;
       content = JSON.stringify({ deviceToken });
     } else if (updateData.type === updateTypes.UPDATE_ENTRY) {
       const { entryID } = updateData;
       content = JSON.stringify({ entryID });
     } else if (updateData.type === updateTypes.UPDATE_CURRENT_USER) {
       // user column contains all the info we need to construct the UpdateInfo
       content = null;
     } else if (updateData.type === updateTypes.UPDATE_USER) {
       const { updatedUserID } = updateData;
       content = JSON.stringify({ updatedUserID });
     } else {
       invariant(false, `unrecognized updateType ${updateData.type}`);
     }
 
     const target = getTargetFromUpdateData(updateData);
     const rawUpdateInfo = rawUpdateInfoFromUpdateData(updateData, ids[i]);
 
     if (!target || !dontBroadcastSession || target !== dontBroadcastSession) {
       const updateTarget = target
         ? { userID: updateData.userID, sessionID: target }
         : { userID: updateData.userID };
       const channelName = channelNameForUpdateTarget(updateTarget);
       let publishInfo = publishInfos.get(channelName);
       if (!publishInfo) {
         publishInfo = { updateTarget, rawUpdateInfos: [] };
         publishInfos.set(channelName, publishInfo);
       }
       publishInfo.rawUpdateInfos.push(rawUpdateInfo);
     }
 
     if (
       updatesForCurrentSession === 'return' &&
       viewerInfo &&
       updateData.userID === viewerInfo.viewer.id &&
       (!target || target === viewerInfo.viewer.session)
     ) {
       viewerRawUpdateInfos.push(rawUpdateInfo);
     }
 
     if (viewerInfo && target && viewerInfo.viewer.session === target) {
       // In the case where this update is being created only for the current
       // session, there's no reason to insert a row into the updates table
       continue;
     }
 
     const key = keyForUpdateData(updateData);
     if (key) {
       const conditionKey = `${updateData.userID}|${key}`;
       const currentEarliestTime = earliestTime.get(conditionKey);
       if (!currentEarliestTime || updateData.time < currentEarliestTime) {
         earliestTime.set(conditionKey, updateData.time);
       }
     }
 
     const insertRow = [
       ids[i],
       updateData.userID,
       updateData.type,
       key,
       content,
       updateData.time,
       dontBroadcastSession,
       target,
     ];
     insertRows.push(insertRow);
   }
 
   type DeleteUpdatesConditions = {
     key: string,
     target?: string,
     types?: number[],
     time?: number,
   };
   const usersByConditions: Map<
     string,
     {
       conditions: DeleteUpdatesConditions,
       users: Set<string>,
     },
   > = new Map();
   for (const [conditionKey, keyUpdateDatas] of keyedUpdateDatas) {
     const deleteConditionByTarget: Map<?string, DeleteCondition> = new Map();
     for (const updateData of keyUpdateDatas) {
       const deleteCondition = getDeleteCondition(updateData);
       invariant(
         deleteCondition,
         `updateData of type ${updateData.type} is in keyedUpdateDatas but ` +
           "doesn't have a deleteCondition",
       );
       const { target, types } = deleteCondition;
 
       const existingDeleteCondition = deleteConditionByTarget.get(target);
       if (!existingDeleteCondition) {
         deleteConditionByTarget.set(target, deleteCondition);
         continue;
       }
 
       const existingTypes = existingDeleteCondition.types;
       if (existingTypes === 'all_types') {
         continue;
       } else if (types === 'all_types') {
         deleteConditionByTarget.set(target, deleteCondition);
         continue;
       }
 
       const mergedTypes = new Set([...types, ...existingTypes]);
       deleteConditionByTarget.set(target, {
         ...deleteCondition,
         types: mergedTypes,
       });
     }
 
     for (const deleteCondition of deleteConditionByTarget.values()) {
       const { userID, target, types } = deleteCondition;
       const key = conditionKey.split('|')[1];
       const conditions: DeleteUpdatesConditions = { key };
       if (target) {
         conditions.target = target;
       }
       if (types !== 'all_types') {
         invariant(types.size > 0, 'deleteCondition had empty types set');
         conditions.types = [...types];
       }
       const earliestTimeForCondition = earliestTime.get(conditionKey);
       if (earliestTimeForCondition) {
         conditions.time = earliestTimeForCondition;
       }
 
       const conditionsKey = JSON.stringify(conditions);
       if (!usersByConditions.has(conditionsKey)) {
         usersByConditions.set(conditionsKey, {
           conditions,
           users: new Set(),
         });
       }
       usersByConditions.get(conditionsKey)?.users.add(userID);
     }
   }
 
   const deleteSQLConditions: SQLStatementType[] = [];
   for (const { conditions, users } of usersByConditions.values()) {
     const sqlConditions = [
       SQL`u.user IN (${[...users]})`,
       SQL`u.key = ${conditions.key}`,
     ];
     if (conditions.target) {
       sqlConditions.push(SQL`u.target = ${conditions.target}`);
     }
     if (conditions.types) {
       sqlConditions.push(SQL`u.type IN (${conditions.types})`);
     }
     if (conditions.time) {
       sqlConditions.push(SQL`u.time < ${conditions.time}`);
     }
     deleteSQLConditions.push(mergeAndConditions(sqlConditions));
   }
 
   const promises = {};
 
   if (insertRows.length > 0) {
     const insertQuery = SQL`
       INSERT INTO updates(id, user, type, \`key\`,
         content, time, updater, target)
     `;
     insertQuery.append(SQL`VALUES ${insertRows}`);
     promises.insert = dbQuery(insertQuery);
   }
 
   if (publishInfos.size > 0) {
     promises.redis = redisPublish(publishInfos.values(), dontBroadcastSession);
   }
 
   if (deleteSQLConditions.length > 0) {
     promises.delete = (async () => {
       while (deleteSQLConditions.length > 0) {
         const batch = deleteSQLConditions.splice(0, deleteUpdatesBatchSize);
         await deleteUpdatesByConditions(batch);
       }
     })();
   }
 
   if (viewerRawUpdateInfos.length > 0) {
     invariant(viewerInfo, 'should be set');
     promises.updatesResult = fetchUpdateInfosWithRawUpdateInfos(
       viewerRawUpdateInfos,
       viewerInfo,
     );
   }
 
   const { updatesResult } = await promiseAll(promises);
   if (!updatesResult) {
     return defaultUpdateCreationResult;
   }
   const { updateInfos, userInfos } = updatesResult;
   return { viewerUpdates: updateInfos, userInfos };
 }
 
 export type FetchUpdatesResult = {
   +updateInfos: $ReadOnlyArray<ServerUpdateInfo>,
   +userInfos: UserInfos,
 };
 async function fetchUpdateInfosWithRawUpdateInfos(
   rawUpdateInfos: $ReadOnlyArray<RawUpdateInfo>,
   viewerInfo: ViewerInfo,
 ): Promise<FetchUpdatesResult> {
   const { viewer } = viewerInfo;
 
   const threadIDsNeedingFetch = new Set();
   const entryIDsNeedingFetch = new Set();
   let currentUserNeedsFetch = false;
   const threadIDsNeedingDetailedFetch = new Set(); // entries and messages
   for (const rawUpdateInfo of rawUpdateInfos) {
     if (
       !viewerInfo.threadInfos &&
       (rawUpdateInfo.type === updateTypes.UPDATE_THREAD ||
         rawUpdateInfo.type === updateTypes.JOIN_THREAD)
     ) {
       threadIDsNeedingFetch.add(rawUpdateInfo.threadID);
     }
     if (rawUpdateInfo.type === updateTypes.JOIN_THREAD) {
       threadIDsNeedingDetailedFetch.add(rawUpdateInfo.threadID);
     } else if (rawUpdateInfo.type === updateTypes.UPDATE_ENTRY) {
       entryIDsNeedingFetch.add(rawUpdateInfo.entryID);
     } else if (rawUpdateInfo.type === updateTypes.UPDATE_CURRENT_USER) {
       currentUserNeedsFetch = true;
     }
   }
 
   const promises = {};
 
   if (!viewerInfo.threadInfos && threadIDsNeedingFetch.size > 0) {
     promises.threadResult = fetchThreadInfos(viewer, {
       threadIDs: threadIDsNeedingFetch,
     });
   }
 
   let calendarQuery: ?CalendarQuery = viewerInfo.calendarQuery
     ? viewerInfo.calendarQuery
     : null;
   if (!calendarQuery && viewer.hasSessionInfo) {
     // This should only ever happen for "legacy" clients who call in without
     // providing this information. These clients wouldn't know how to deal with
     // the corresponding UpdateInfos anyways, so no reason to be worried.
     calendarQuery = viewer.calendarQuery;
   } else if (!calendarQuery) {
     calendarQuery = defaultCalendarQuery(viewer.platform, viewer.timeZone);
   }
   if (threadIDsNeedingDetailedFetch.size > 0) {
     const threadCursors: { [string]: ?string } = {};
     for (const threadID of threadIDsNeedingDetailedFetch) {
       threadCursors[threadID] = null;
     }
     const messageSelectionCriteria: MessageSelectionCriteria = {
       threadCursors,
     };
     promises.messageInfosResult = fetchMessageInfos(
       viewer,
       messageSelectionCriteria,
       defaultNumberPerThread,
     );
     const threadCalendarQuery = {
       ...calendarQuery,
       filters: [
         ...nonThreadCalendarFilters(calendarQuery.filters),
         { type: 'threads', threadIDs: [...threadIDsNeedingDetailedFetch] },
       ],
     };
     promises.calendarResult = fetchEntryInfos(viewer, [threadCalendarQuery]);
   }
 
   if (entryIDsNeedingFetch.size > 0) {
     promises.entryInfosResult = fetchEntryInfosByID(
       viewer,
       entryIDsNeedingFetch,
     );
   }
 
   if (currentUserNeedsFetch) {
     promises.currentUserInfoResult = (async () => {
       const currentUserInfo = await fetchCurrentUserInfo(viewer);
       invariant(currentUserInfo.anonymous === undefined, 'should be logged in');
       return currentUserInfo;
     })();
   }
 
   const {
     threadResult,
     messageInfosResult,
     calendarResult,
     entryInfosResult,
     currentUserInfoResult,
   } = await promiseAll(promises);
 
   let threadInfosResult;
   if (viewerInfo.threadInfos) {
     const { threadInfos } = viewerInfo;
     threadInfosResult = { threadInfos };
   } else if (threadResult) {
     threadInfosResult = threadResult;
   } else {
     threadInfosResult = { threadInfos: {} };
   }
 
   return await updateInfosFromRawUpdateInfos(viewer, rawUpdateInfos, {
     threadInfosResult,
     messageInfosResult,
     calendarResult,
     entryInfosResult,
     currentUserInfoResult,
   });
 }
 
 export type UpdateInfosRawData = {
   threadInfosResult: FetchThreadInfosResult,
   messageInfosResult: ?FetchMessageInfosResult,
   calendarResult: ?FetchEntryInfosBase,
   entryInfosResult: ?RawEntryInfos,
-  currentUserInfoResult: ?OldLoggedInUserInfo | LoggedInUserInfo,
+  currentUserInfoResult: LoggedInUserInfo,
 };
 async function updateInfosFromRawUpdateInfos(
   viewer: Viewer,
   rawUpdateInfos: $ReadOnlyArray<RawUpdateInfo>,
   rawData: UpdateInfosRawData,
 ): Promise<FetchUpdatesResult> {
   const {
     threadInfosResult,
     messageInfosResult,
     calendarResult,
     entryInfosResult,
     currentUserInfoResult,
   } = rawData;
   const updateInfos = [];
   const userIDsToFetch = new Set();
 
   const rawEntryInfosByThreadID = {};
   for (const entryInfo of calendarResult?.rawEntryInfos ?? []) {
     if (!rawEntryInfosByThreadID[entryInfo.threadID]) {
       rawEntryInfosByThreadID[entryInfo.threadID] = [];
     }
     rawEntryInfosByThreadID[entryInfo.threadID].push(entryInfo);
   }
 
   const rawMessageInfosByThreadID = {};
   for (const messageInfo of messageInfosResult?.rawMessageInfos ?? []) {
     if (!rawMessageInfosByThreadID[messageInfo.threadID]) {
       rawMessageInfosByThreadID[messageInfo.threadID] = [];
     }
     rawMessageInfosByThreadID[messageInfo.threadID].push(messageInfo);
   }
 
   for (const rawUpdateInfo of rawUpdateInfos) {
     if (rawUpdateInfo.type === updateTypes.DELETE_ACCOUNT) {
       updateInfos.push({
         type: updateTypes.DELETE_ACCOUNT,
         id: rawUpdateInfo.id,
         time: rawUpdateInfo.time,
         deletedUserID: rawUpdateInfo.deletedUserID,
       });
     } else if (rawUpdateInfo.type === updateTypes.UPDATE_THREAD) {
       const threadInfo = threadInfosResult.threadInfos[rawUpdateInfo.threadID];
       if (!threadInfo) {
         console.warn(
           "failed to hydrate updateTypes.UPDATE_THREAD because we couldn't " +
             `fetch RawThreadInfo for ${rawUpdateInfo.threadID}`,
         );
         continue;
       }
       updateInfos.push({
         type: updateTypes.UPDATE_THREAD,
         id: rawUpdateInfo.id,
         time: rawUpdateInfo.time,
         threadInfo,
       });
     } else if (rawUpdateInfo.type === updateTypes.UPDATE_THREAD_READ_STATUS) {
       updateInfos.push({
         type: updateTypes.UPDATE_THREAD_READ_STATUS,
         id: rawUpdateInfo.id,
         time: rawUpdateInfo.time,
         threadID: rawUpdateInfo.threadID,
         unread: rawUpdateInfo.unread,
       });
     } else if (rawUpdateInfo.type === updateTypes.DELETE_THREAD) {
       updateInfos.push({
         type: updateTypes.DELETE_THREAD,
         id: rawUpdateInfo.id,
         time: rawUpdateInfo.time,
         threadID: rawUpdateInfo.threadID,
       });
     } else if (rawUpdateInfo.type === updateTypes.JOIN_THREAD) {
       const threadInfo = threadInfosResult.threadInfos[rawUpdateInfo.threadID];
       if (!threadInfo) {
         console.warn(
           "failed to hydrate updateTypes.JOIN_THREAD because we couldn't " +
             `fetch RawThreadInfo for ${rawUpdateInfo.threadID}`,
         );
         continue;
       }
 
       invariant(calendarResult, 'should be set');
       const rawEntryInfos =
         rawEntryInfosByThreadID[rawUpdateInfo.threadID] ?? [];
       invariant(messageInfosResult, 'should be set');
       const rawMessageInfos =
         rawMessageInfosByThreadID[rawUpdateInfo.threadID] ?? [];
 
       updateInfos.push({
         type: updateTypes.JOIN_THREAD,
         id: rawUpdateInfo.id,
         time: rawUpdateInfo.time,
         threadInfo,
         rawMessageInfos,
         truncationStatus:
           messageInfosResult.truncationStatuses[rawUpdateInfo.threadID],
         rawEntryInfos,
       });
     } else if (rawUpdateInfo.type === updateTypes.BAD_DEVICE_TOKEN) {
       updateInfos.push({
         type: updateTypes.BAD_DEVICE_TOKEN,
         id: rawUpdateInfo.id,
         time: rawUpdateInfo.time,
         deviceToken: rawUpdateInfo.deviceToken,
       });
     } else if (rawUpdateInfo.type === updateTypes.UPDATE_ENTRY) {
       invariant(entryInfosResult, 'should be set');
       const entryInfo = entryInfosResult[rawUpdateInfo.entryID];
       if (!entryInfo) {
         console.warn(
           "failed to hydrate updateTypes.UPDATE_ENTRY because we couldn't " +
             `fetch RawEntryInfo for ${rawUpdateInfo.entryID}`,
         );
         continue;
       }
       updateInfos.push({
         type: updateTypes.UPDATE_ENTRY,
         id: rawUpdateInfo.id,
         time: rawUpdateInfo.time,
         entryInfo,
       });
     } else if (rawUpdateInfo.type === updateTypes.UPDATE_CURRENT_USER) {
       invariant(currentUserInfoResult, 'should be set');
       updateInfos.push({
         type: updateTypes.UPDATE_CURRENT_USER,
         id: rawUpdateInfo.id,
         time: rawUpdateInfo.time,
         currentUserInfo: currentUserInfoResult,
       });
     } else if (rawUpdateInfo.type === updateTypes.UPDATE_USER) {
       updateInfos.push({
         type: updateTypes.UPDATE_USER,
         id: rawUpdateInfo.id,
         time: rawUpdateInfo.time,
         updatedUserID: rawUpdateInfo.updatedUserID,
       });
       userIDsToFetch.add(rawUpdateInfo.updatedUserID);
     } else {
       invariant(false, `unrecognized updateType ${rawUpdateInfo.type}`);
     }
   }
 
   let userInfos = {};
   if (userIDsToFetch.size > 0) {
     userInfos = await fetchKnownUserInfos(viewer, [...userIDsToFetch]);
   }
 
   updateInfos.sort(sortFunction);
 
   // Now we'll attempt to merge UpdateInfos so that we only have one per key
   const updateForKey: Map<string, ServerUpdateInfo> = new Map();
   const mergedUpdates: ServerUpdateInfo[] = [];
   for (const updateInfo of updateInfos) {
     const key = keyForUpdateInfo(updateInfo);
     if (!key) {
       mergedUpdates.push(updateInfo);
       continue;
     } else if (
       updateInfo.type === updateTypes.DELETE_THREAD ||
       updateInfo.type === updateTypes.JOIN_THREAD ||
       updateInfo.type === updateTypes.DELETE_ACCOUNT
     ) {
       updateForKey.set(key, updateInfo);
       continue;
     }
     const currentUpdateInfo = updateForKey.get(key);
     if (!currentUpdateInfo) {
       updateForKey.set(key, updateInfo);
     } else if (
       updateInfo.type === updateTypes.UPDATE_THREAD &&
       currentUpdateInfo.type === updateTypes.UPDATE_THREAD_READ_STATUS
     ) {
       // UPDATE_THREAD trumps UPDATE_THREAD_READ_STATUS
       // Note that we keep the oldest UPDATE_THREAD
       updateForKey.set(key, updateInfo);
     } else if (
       updateInfo.type === updateTypes.UPDATE_THREAD_READ_STATUS &&
       currentUpdateInfo.type === updateTypes.UPDATE_THREAD_READ_STATUS
     ) {
       // If we only have UPDATE_THREAD_READ_STATUS, keep the most recent
       updateForKey.set(key, updateInfo);
     } else if (updateInfo.type === updateTypes.UPDATE_ENTRY) {
       updateForKey.set(key, updateInfo);
     } else if (updateInfo.type === updateTypes.UPDATE_CURRENT_USER) {
       updateForKey.set(key, updateInfo);
     }
   }
   for (const [, updateInfo] of updateForKey) {
     mergedUpdates.push(updateInfo);
   }
   mergedUpdates.sort(sortFunction);
 
   return { updateInfos: mergedUpdates, userInfos };
 }
 
 type PublishInfo = {
   updateTarget: UpdateTarget,
   rawUpdateInfos: RawUpdateInfo[],
 };
 async function redisPublish(
   publishInfos: Iterator<PublishInfo>,
   dontBroadcastSession: ?string,
 ): Promise<void> {
   for (const publishInfo of publishInfos) {
     const { updateTarget, rawUpdateInfos } = publishInfo;
     const redisMessage: NewUpdatesRedisMessage = {
       type: redisMessageTypes.NEW_UPDATES,
       updates: rawUpdateInfos,
     };
     if (!updateTarget.sessionID && dontBroadcastSession) {
       redisMessage.ignoreSession = dontBroadcastSession;
     }
     publisher.sendMessage(updateTarget, redisMessage);
   }
 }
 
 function getTargetFromUpdateData(updateData: UpdateData): ?string {
   if (updateData.targetSession) {
     return updateData.targetSession;
   } else if (updateData.targetCookie) {
     return updateData.targetCookie;
   } else {
     return null;
   }
 }
 
 function getDeleteCondition(updateData: UpdateData): ?DeleteCondition {
   let types;
   if (updateData.type === updateTypes.DELETE_ACCOUNT) {
     types = new Set([updateTypes.DELETE_ACCOUNT, updateTypes.UPDATE_USER]);
   } else if (updateData.type === updateTypes.UPDATE_THREAD) {
     types = new Set([
       updateTypes.UPDATE_THREAD,
       updateTypes.UPDATE_THREAD_READ_STATUS,
     ]);
   } else if (updateData.type === updateTypes.UPDATE_THREAD_READ_STATUS) {
     types = new Set([updateTypes.UPDATE_THREAD_READ_STATUS]);
   } else if (
     updateData.type === updateTypes.DELETE_THREAD ||
     updateData.type === updateTypes.JOIN_THREAD
   ) {
     types = 'all_types';
   } else if (updateData.type === updateTypes.UPDATE_ENTRY) {
     types = 'all_types';
   } else if (updateData.type === updateTypes.UPDATE_CURRENT_USER) {
     types = new Set([updateTypes.UPDATE_CURRENT_USER]);
   } else if (updateData.type === updateTypes.UPDATE_USER) {
     types = new Set([updateTypes.UPDATE_USER]);
   } else {
     return null;
   }
 
   const target = getTargetFromUpdateData(updateData);
   const { userID } = updateData;
   return { userID, target, types };
 }
 
 function filterOnDeleteCondition(
   updateData: UpdateData,
   deleteCondition: DeleteCondition,
 ): boolean {
   invariant(
     updateData.userID === deleteCondition.userID,
     `updateData of type ${updateData.type} being compared to wrong userID`,
   );
   if (deleteCondition.target) {
     const target = getTargetFromUpdateData(updateData);
     if (target !== deleteCondition.target) {
       return true;
     }
   }
   if (deleteCondition.types === 'all_types') {
     return false;
   }
   return !deleteCondition.types.has(updateData.type);
 }
 
 export { createUpdates, fetchUpdateInfosWithRawUpdateInfos };
diff --git a/keyserver/src/fetchers/user-fetchers.js b/keyserver/src/fetchers/user-fetchers.js
index e182e9710..437c33f28 100644
--- a/keyserver/src/fetchers/user-fetchers.js
+++ b/keyserver/src/fetchers/user-fetchers.js
@@ -1,435 +1,431 @@
 // @flow
 
 import invariant from 'invariant';
 
 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> {
+async function fetchCurrentUserInfo(viewer: Viewer): Promise<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> {
+): Promise<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;
   if (!userRow) {
     throw new ServerError('unknown_error');
   }
 
   const id = userRow.id.toString();
   const { username, upload_id, upload_secret } = userRow;
 
   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: 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,
 };
diff --git a/keyserver/src/responders/user-responders.js b/keyserver/src/responders/user-responders.js
index 5e9113cb0..96a2181af 100644
--- a/keyserver/src/responders/user-responders.js
+++ b/keyserver/src/responders/user-responders.js
@@ -1,782 +1,775 @@
 // @flow
 
 import type { Utility as OlmUtility } from '@commapp/olm';
 import invariant from 'invariant';
 import { ErrorTypes, SiweMessage } from 'siwe';
 import t, { type TInterface, type TUnion } from 'tcomb';
 import bcrypt from 'twin-bcrypt';
 
 import {
   baseLegalPolicies,
   policies,
   policyTypeValidator,
 } from 'lib/facts/policies.js';
 import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
 import type {
   ResetPasswordRequest,
   LogOutResponse,
   DeleteAccountRequest,
   RegisterResponse,
   RegisterRequest,
   LogInResponse,
   LogInRequest,
   UpdatePasswordRequest,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
   ClaimUsernameResponse,
 } from 'lib/types/account-types.js';
 import {
   userSettingsTypes,
   notificationTypeValues,
   logInActionSources,
 } from 'lib/types/account-types.js';
 import {
   type ClientAvatar,
   clientAvatarValidator,
   type UpdateUserAvatarResponse,
   type UpdateUserAvatarRequest,
 } from 'lib/types/avatar-types.js';
 import type {
   ReservedUsernameMessage,
   IdentityKeysBlob,
   SignedIdentityKeysBlob,
 } from 'lib/types/crypto-types.js';
 import {
   type CalendarQuery,
   rawEntryInfoValidator,
 } from 'lib/types/entry-types.js';
 import {
   defaultNumberPerThread,
   rawMessageInfoValidator,
   messageTruncationStatusesValidator,
 } from 'lib/types/message-types.js';
 import type {
   SIWEAuthRequest,
   SIWEMessage,
   SIWESocialProof,
 } from 'lib/types/siwe-types.js';
 import {
   type SubscriptionUpdateRequest,
   type SubscriptionUpdateResponse,
   threadSubscriptionValidator,
 } from 'lib/types/subscription-types.js';
 import { rawThreadInfoValidator } from 'lib/types/thread-types.js';
 import { createUpdatesResultValidator } from 'lib/types/update-types.js';
 import {
   type PasswordUpdate,
   loggedOutUserInfoValidator,
   loggedInUserInfoValidator,
-  oldLoggedInUserInfoValidator,
   userInfoValidator,
 } from 'lib/types/user-types.js';
 import {
   identityKeysBlobValidator,
   signedIdentityKeysBlobValidator,
 } from 'lib/utils/crypto-utils.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import {
   getPublicKeyFromSIWEStatement,
   isValidSIWEMessage,
   isValidSIWEStatementWithPublicKey,
   primaryIdentityPublicKeyRegex,
 } from 'lib/utils/siwe-utils.js';
 import {
   tShape,
   tPlatformDetails,
   tPassword,
   tEmail,
   tOldValidUsername,
   tRegex,
   tID,
 } from 'lib/utils/validation-utils.js';
 
 import {
   entryQueryInputValidator,
   newEntryQueryInputValidator,
   normalizeCalendarQuery,
   verifyCalendarQueryThreadIDs,
 } from './entry-responders.js';
 import {
   createAccount,
   processSIWEAccountCreation,
 } from '../creators/account-creator.js';
 import { createOlmSession } from '../creators/olm-session-creator.js';
 import { dbQuery, SQL } from '../database/database.js';
 import { deleteAccount } from '../deleters/account-deleters.js';
 import { deleteCookie } from '../deleters/cookie-deleters.js';
 import { checkAndInvalidateSIWENonceEntry } from '../deleters/siwe-nonce-deleters.js';
 import { fetchEntryInfos } from '../fetchers/entry-fetchers.js';
 import { fetchMessageInfos } from '../fetchers/message-fetchers.js';
 import { fetchNotAcknowledgedPolicies } from '../fetchers/policy-acknowledgment-fetchers.js';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
 import {
   fetchKnownUserInfos,
   fetchLoggedInUserInfo,
   fetchUserIDForEthereumAddress,
   fetchUsername,
 } from '../fetchers/user-fetchers.js';
 import {
   createNewAnonymousCookie,
   createNewUserCookie,
   setNewSession,
 } from '../session/cookies.js';
 import { verifyClientSupported } from '../session/version.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   accountUpdater,
   checkAndSendVerificationEmail,
   checkAndSendPasswordResetEmail,
   updatePassword,
   updateUserSettings,
   updateUserAvatar,
 } from '../updaters/account-updaters.js';
 import { fetchOlmAccount } from '../updaters/olm-account-updater.js';
 import { userSubscriptionUpdater } from '../updaters/user-subscription-updaters.js';
 import { viewerAcknowledgmentUpdater } from '../updaters/viewer-acknowledgment-updater.js';
 import { getOlmUtility } from '../utils/olm-utils.js';
 
 export const subscriptionUpdateRequestInputValidator: TInterface<SubscriptionUpdateRequest> =
   tShape<SubscriptionUpdateRequest>({
     threadID: tID,
     updatedFields: tShape({
       pushNotifs: t.maybe(t.Boolean),
       home: t.maybe(t.Boolean),
     }),
   });
 
 export const subscriptionUpdateResponseValidator: TInterface<SubscriptionUpdateResponse> =
   tShape<SubscriptionUpdateResponse>({
     threadSubscription: threadSubscriptionValidator,
   });
 
 async function userSubscriptionUpdateResponder(
   viewer: Viewer,
   request: SubscriptionUpdateRequest,
 ): Promise<SubscriptionUpdateResponse> {
   const threadSubscription = await userSubscriptionUpdater(viewer, request);
   return {
     threadSubscription,
   };
 }
 
 export const accountUpdateInputValidator: TInterface<PasswordUpdate> =
   tShape<PasswordUpdate>({
     updatedFields: tShape({
       email: t.maybe(tEmail),
       password: t.maybe(tPassword),
     }),
     currentPassword: tPassword,
   });
 
 async function passwordUpdateResponder(
   viewer: Viewer,
   request: PasswordUpdate,
 ): Promise<void> {
   await accountUpdater(viewer, request);
 }
 
 async function sendVerificationEmailResponder(viewer: Viewer): Promise<void> {
   if (!viewer.isSocket) {
     await verifyClientSupported(viewer, viewer.platformDetails);
   }
   await checkAndSendVerificationEmail(viewer);
 }
 
 export const resetPasswordRequestInputValidator: TInterface<ResetPasswordRequest> =
   tShape<ResetPasswordRequest>({
     usernameOrEmail: t.union([tEmail, tOldValidUsername]),
   });
 
 async function sendPasswordResetEmailResponder(
   viewer: Viewer,
   request: ResetPasswordRequest,
 ): Promise<void> {
   await checkAndSendPasswordResetEmail(request);
 }
 
 export const logOutResponseValidator: TInterface<LogOutResponse> =
   tShape<LogOutResponse>({
     currentUserInfo: loggedOutUserInfoValidator,
   });
 
 async function logOutResponder(viewer: Viewer): Promise<LogOutResponse> {
   if (!viewer.isSocket) {
     await verifyClientSupported(viewer, viewer.platformDetails);
   }
   if (viewer.loggedIn) {
     const [anonymousViewerData] = await Promise.all([
       createNewAnonymousCookie({
         platformDetails: viewer.platformDetails,
         deviceToken: viewer.deviceToken,
       }),
       deleteCookie(viewer.cookieID),
     ]);
     viewer.setNewCookie(anonymousViewerData);
   }
   return {
     currentUserInfo: {
       id: viewer.id,
       anonymous: true,
     },
   };
 }
 
 export const deleteAccountRequestInputValidator: TInterface<DeleteAccountRequest> =
   tShape<DeleteAccountRequest>({
     password: t.maybe(tPassword),
   });
 
 async function accountDeletionResponder(
   viewer: Viewer,
   request: DeleteAccountRequest,
 ): Promise<LogOutResponse> {
   const result = await deleteAccount(viewer, request);
   invariant(result, 'deleteAccount should return result if handed request');
   return result;
 }
 
 const deviceTokenUpdateRequestInputValidator = tShape({
   deviceType: t.maybe(t.enums.of(['ios', 'android'])),
   deviceToken: t.String,
 });
 
 export const registerRequestInputValidator: TInterface<RegisterRequest> =
   tShape<RegisterRequest>({
     username: t.String,
     email: t.maybe(tEmail),
     password: tPassword,
     calendarQuery: t.maybe(newEntryQueryInputValidator),
     deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
     platformDetails: tPlatformDetails,
     // We include `primaryIdentityPublicKey` to avoid breaking
     // old clients, but we no longer do anything with it.
     primaryIdentityPublicKey: t.maybe(tRegex(primaryIdentityPublicKeyRegex)),
     signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
     initialNotificationsEncryptedMessage: t.maybe(t.String),
   });
 
 export const registerResponseValidator: TInterface<RegisterResponse> =
   tShape<RegisterResponse>({
     id: t.String,
     rawMessageInfos: t.list(rawMessageInfoValidator),
-    currentUserInfo: t.union([
-      oldLoggedInUserInfoValidator,
-      loggedInUserInfoValidator,
-    ]),
+    currentUserInfo: loggedInUserInfoValidator,
     cookieChange: tShape({
       threadInfos: t.dict(tID, rawThreadInfoValidator),
       userInfos: t.list(userInfoValidator),
     }),
   });
 
 async function accountCreationResponder(
   viewer: Viewer,
   request: RegisterRequest,
 ): Promise<RegisterResponse> {
   const { signedIdentityKeysBlob } = request;
   if (signedIdentityKeysBlob) {
     const identityKeys: IdentityKeysBlob = JSON.parse(
       signedIdentityKeysBlob.payload,
     );
     if (!identityKeysBlobValidator.is(identityKeys)) {
       throw new ServerError('invalid_identity_keys_blob');
     }
 
     const olmUtil: OlmUtility = getOlmUtility();
     try {
       olmUtil.ed25519_verify(
         identityKeys.primaryIdentityPublicKeys.ed25519,
         signedIdentityKeysBlob.payload,
         signedIdentityKeysBlob.signature,
       );
     } catch (e) {
       throw new ServerError('invalid_signature');
     }
   }
   return await createAccount(viewer, request);
 }
 
 type ProcessSuccessfulLoginParams = {
   +viewer: Viewer,
   +input: any,
   +userID: string,
   +calendarQuery: ?CalendarQuery,
   +socialProof?: ?SIWESocialProof,
   +signedIdentityKeysBlob?: ?SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
 };
 
 async function processSuccessfulLogin(
   params: ProcessSuccessfulLoginParams,
 ): Promise<LogInResponse> {
   const {
     viewer,
     input,
     userID,
     calendarQuery,
     socialProof,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
   } = params;
 
   const request: LogInRequest = input;
   const newServerTime = Date.now();
   const deviceToken = request.deviceTokenUpdateRequest
     ? request.deviceTokenUpdateRequest.deviceToken
     : viewer.deviceToken;
   const [userViewerData, notAcknowledgedPolicies] = await Promise.all([
     createNewUserCookie(userID, {
       platformDetails: request.platformDetails,
       deviceToken,
       socialProof,
       signedIdentityKeysBlob,
     }),
     fetchNotAcknowledgedPolicies(userID, baseLegalPolicies),
     deleteCookie(viewer.cookieID),
   ]);
   viewer.setNewCookie(userViewerData);
 
   if (
     notAcknowledgedPolicies.length &&
     hasMinCodeVersion(viewer.platformDetails, { native: 181 })
   ) {
     const currentUserInfo = await fetchLoggedInUserInfo(viewer);
     return {
       notAcknowledgedPolicies,
       currentUserInfo: currentUserInfo,
       rawMessageInfos: [],
       truncationStatuses: {},
       userInfos: [],
       rawEntryInfos: [],
       serverTime: 0,
       cookieChange: {
         threadInfos: {},
         userInfos: [],
       },
     };
   }
 
   if (calendarQuery) {
     await setNewSession(viewer, calendarQuery, newServerTime);
   }
   const olmSessionPromise = (async () => {
     if (
       userViewerData.cookieID &&
       initialNotificationsEncryptedMessage &&
       signedIdentityKeysBlob
     ) {
       await createOlmSession(
         initialNotificationsEncryptedMessage,
         'notifications',
         userViewerData.cookieID,
       );
     }
   })();
 
   const threadCursors = {};
   for (const watchedThreadID of request.watchedIDs) {
     threadCursors[watchedThreadID] = null;
   }
   const messageSelectionCriteria = { threadCursors, joinedThreads: true };
 
   const [
     threadsResult,
     messagesResult,
     entriesResult,
     userInfos,
     currentUserInfo,
   ] = await Promise.all([
     fetchThreadInfos(viewer),
     fetchMessageInfos(viewer, messageSelectionCriteria, defaultNumberPerThread),
     calendarQuery ? fetchEntryInfos(viewer, [calendarQuery]) : undefined,
     fetchKnownUserInfos(viewer),
     fetchLoggedInUserInfo(viewer),
     olmSessionPromise,
   ]);
 
   const rawEntryInfos = entriesResult ? entriesResult.rawEntryInfos : null;
   const response: LogInResponse = {
     currentUserInfo,
     rawMessageInfos: messagesResult.rawMessageInfos,
     truncationStatuses: messagesResult.truncationStatuses,
     serverTime: newServerTime,
     userInfos: values(userInfos),
     cookieChange: {
       threadInfos: threadsResult.threadInfos,
       userInfos: [],
     },
   };
   if (rawEntryInfos) {
     return {
       ...response,
       rawEntryInfos,
     };
   }
   return response;
 }
 
 export const logInRequestInputValidator: TInterface<LogInRequest> =
   tShape<LogInRequest>({
     username: t.maybe(t.String),
     usernameOrEmail: t.maybe(t.union([tEmail, tOldValidUsername])),
     password: tPassword,
     watchedIDs: t.list(tID),
     calendarQuery: t.maybe(entryQueryInputValidator),
     deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
     platformDetails: tPlatformDetails,
     source: t.maybe(t.enums.of(values(logInActionSources))),
     // We include `primaryIdentityPublicKey` to avoid breaking
     // old clients, but we no longer do anything with it.
     primaryIdentityPublicKey: t.maybe(tRegex(primaryIdentityPublicKeyRegex)),
     signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
     initialNotificationsEncryptedMessage: t.maybe(t.String),
   });
 
 export const logInResponseValidator: TInterface<LogInResponse> =
   tShape<LogInResponse>({
-    currentUserInfo: t.union([
-      loggedInUserInfoValidator,
-      oldLoggedInUserInfoValidator,
-    ]),
+    currentUserInfo: loggedInUserInfoValidator,
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     userInfos: t.list(userInfoValidator),
     rawEntryInfos: t.maybe(t.list(rawEntryInfoValidator)),
     serverTime: t.Number,
     cookieChange: tShape({
       threadInfos: t.dict(tID, rawThreadInfoValidator),
       userInfos: t.list(userInfoValidator),
     }),
     notAcknowledgedPolicies: t.maybe(t.list(policyTypeValidator)),
   });
 
 async function logInResponder(
   viewer: Viewer,
   request: LogInRequest,
 ): Promise<LogInResponse> {
   let identityKeys: ?IdentityKeysBlob;
   const { signedIdentityKeysBlob, initialNotificationsEncryptedMessage } =
     request;
   if (signedIdentityKeysBlob) {
     identityKeys = JSON.parse(signedIdentityKeysBlob.payload);
 
     const olmUtil: OlmUtility = getOlmUtility();
     try {
       olmUtil.ed25519_verify(
         identityKeys.primaryIdentityPublicKeys.ed25519,
         signedIdentityKeysBlob.payload,
         signedIdentityKeysBlob.signature,
       );
     } catch (e) {
       throw new ServerError('invalid_signature');
     }
   }
 
   const calendarQuery = request.calendarQuery
     ? normalizeCalendarQuery(request.calendarQuery)
     : null;
   const promises = {};
   if (calendarQuery) {
     promises.verifyCalendarQueryThreadIDs =
       verifyCalendarQueryThreadIDs(calendarQuery);
   }
   const username = request.username ?? request.usernameOrEmail;
   if (!username) {
     if (hasMinCodeVersion(viewer.platformDetails, { native: 150 })) {
       throw new ServerError('invalid_credentials');
     } else {
       throw new ServerError('invalid_parameters');
     }
   }
   const userQuery = SQL`
     SELECT id, hash, username
     FROM users
     WHERE LCASE(username) = LCASE(${username})
   `;
   promises.userQuery = dbQuery(userQuery);
   const {
     userQuery: [userResult],
   } = await promiseAll(promises);
 
   if (userResult.length === 0) {
     if (hasMinCodeVersion(viewer.platformDetails, { native: 150 })) {
       throw new ServerError('invalid_credentials');
     } else {
       throw new ServerError('invalid_parameters');
     }
   }
 
   const userRow = userResult[0];
 
   if (!userRow.hash || !bcrypt.compareSync(request.password, userRow.hash)) {
     throw new ServerError('invalid_credentials');
   }
 
   const id = userRow.id.toString();
 
   return await processSuccessfulLogin({
     viewer,
     input: request,
     userID: id,
     calendarQuery,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
   });
 }
 
 export const siweAuthRequestInputValidator: TInterface<SIWEAuthRequest> =
   tShape<SIWEAuthRequest>({
     signature: t.String,
     message: t.String,
     calendarQuery: entryQueryInputValidator,
     deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
     platformDetails: tPlatformDetails,
     watchedIDs: t.list(tID),
     signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
     initialNotificationsEncryptedMessage: t.maybe(t.String),
     doNotRegister: t.maybe(t.Boolean),
   });
 
 async function siweAuthResponder(
   viewer: Viewer,
   request: SIWEAuthRequest,
 ): Promise<LogInResponse> {
   const {
     message,
     signature,
     deviceTokenUpdateRequest,
     platformDetails,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
     doNotRegister,
   } = request;
   const calendarQuery = normalizeCalendarQuery(request.calendarQuery);
 
   // 1. Ensure that `message` is a well formed Comm SIWE Auth message.
   const siweMessage: SIWEMessage = new SiweMessage(message);
   if (!isValidSIWEMessage(siweMessage)) {
     throw new ServerError('invalid_parameters');
   }
 
   // 2. Ensure that the `nonce` exists in the `siwe_nonces` table
   //    AND hasn't expired. If those conditions are met, delete the entry to
   //    ensure that the same `nonce` can't be re-used in a future request.
   const wasNonceCheckedAndInvalidated = await checkAndInvalidateSIWENonceEntry(
     siweMessage.nonce,
   );
   if (!wasNonceCheckedAndInvalidated) {
     throw new ServerError('invalid_parameters');
   }
 
   // 3. Validate SIWEMessage signature and handle possible errors.
   try {
     await siweMessage.validate(signature);
   } catch (error) {
     if (error === ErrorTypes.EXPIRED_MESSAGE) {
       // Thrown when the `expirationTime` is present and in the past.
       throw new ServerError('expired_message');
     } else if (error === ErrorTypes.INVALID_SIGNATURE) {
       // Thrown when the `validate()` function can't verify the message.
       throw new ServerError('invalid_signature');
     } else if (error === ErrorTypes.MALFORMED_SESSION) {
       // Thrown when some required field is missing.
       throw new ServerError('malformed_session');
     } else {
       throw new ServerError('unknown_error');
     }
   }
 
   // 4. Pull `primaryIdentityPublicKey` out from SIWEMessage `statement`.
   //    We expect it to be included for BOTH native and web clients.
   const { statement } = siweMessage;
   const primaryIdentityPublicKey =
     statement && isValidSIWEStatementWithPublicKey(statement)
       ? getPublicKeyFromSIWEStatement(statement)
       : null;
   if (!primaryIdentityPublicKey) {
     throw new ServerError('invalid_siwe_statement_public_key');
   }
 
   // 5. Verify `signedIdentityKeysBlob.payload` with included `signature`
   //    if `signedIdentityKeysBlob` was included in the `SIWEAuthRequest`.
   let identityKeys: ?IdentityKeysBlob;
   if (signedIdentityKeysBlob) {
     identityKeys = JSON.parse(signedIdentityKeysBlob.payload);
     if (!identityKeysBlobValidator.is(identityKeys)) {
       throw new ServerError('invalid_identity_keys_blob');
     }
 
     const olmUtil: OlmUtility = getOlmUtility();
     try {
       olmUtil.ed25519_verify(
         identityKeys.primaryIdentityPublicKeys.ed25519,
         signedIdentityKeysBlob.payload,
         signedIdentityKeysBlob.signature,
       );
     } catch (e) {
       throw new ServerError('invalid_signature');
     }
   }
 
   // 6. Ensure that `primaryIdentityPublicKeys.ed25519` matches SIWE
   //    statement `primaryIdentityPublicKey` if `identityKeys` exists.
   if (
     identityKeys &&
     identityKeys.primaryIdentityPublicKeys.ed25519 !== primaryIdentityPublicKey
   ) {
     throw new ServerError('primary_public_key_mismatch');
   }
 
   // 7. Construct `SIWESocialProof` object with the stringified
   //    SIWEMessage and the corresponding signature.
   const socialProof: SIWESocialProof = {
     siweMessage: siweMessage.toMessage(),
     siweMessageSignature: signature,
   };
 
   // 8. Create account with call to `processSIWEAccountCreation(...)`
   //    if address does not correspond to an existing user.
   let userID = await fetchUserIDForEthereumAddress(siweMessage.address);
   if (!userID && doNotRegister) {
     throw new ServerError('account_does_not_exist');
   } else if (!userID) {
     const siweAccountCreationRequest = {
       address: siweMessage.address,
       calendarQuery,
       deviceTokenUpdateRequest,
       platformDetails,
       socialProof,
     };
     userID = await processSIWEAccountCreation(
       viewer,
       siweAccountCreationRequest,
     );
   }
 
   // 9. Complete login with call to `processSuccessfulLogin(...)`.
   return await processSuccessfulLogin({
     viewer,
     input: request,
     userID,
     calendarQuery,
     socialProof,
     signedIdentityKeysBlob,
     initialNotificationsEncryptedMessage,
   });
 }
 
 export const updatePasswordRequestInputValidator: TInterface<UpdatePasswordRequest> =
   tShape<UpdatePasswordRequest>({
     code: t.String,
     password: tPassword,
     watchedIDs: t.list(tID),
     calendarQuery: t.maybe(entryQueryInputValidator),
     deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
     platformDetails: tPlatformDetails,
   });
 
 async function oldPasswordUpdateResponder(
   viewer: Viewer,
   request: UpdatePasswordRequest,
 ): Promise<LogInResponse> {
   if (request.calendarQuery) {
     request.calendarQuery = normalizeCalendarQuery(request.calendarQuery);
   }
   return await updatePassword(viewer, request);
 }
 
 export const updateUserSettingsInputValidator: TInterface<UpdateUserSettingsRequest> =
   tShape<UpdateUserSettingsRequest>({
     name: t.irreducible(
       userSettingsTypes.DEFAULT_NOTIFICATIONS,
       x => x === userSettingsTypes.DEFAULT_NOTIFICATIONS,
     ),
     data: t.enums.of(notificationTypeValues),
   });
 
 async function updateUserSettingsResponder(
   viewer: Viewer,
   request: UpdateUserSettingsRequest,
 ): Promise<void> {
   await updateUserSettings(viewer, request);
 }
 
 export const policyAcknowledgmentRequestInputValidator: TInterface<PolicyAcknowledgmentRequest> =
   tShape<PolicyAcknowledgmentRequest>({
     policy: t.maybe(t.enums.of(policies)),
   });
 
 async function policyAcknowledgmentResponder(
   viewer: Viewer,
   request: PolicyAcknowledgmentRequest,
 ): Promise<void> {
   await viewerAcknowledgmentUpdater(viewer, request.policy);
 }
 
 export const updateUserAvatarResponseValidator: TInterface<UpdateUserAvatarResponse> =
   tShape<UpdateUserAvatarResponse>({
     updates: createUpdatesResultValidator,
   });
 
 export const updateUserAvatarResponderValidator: TUnion<
   ?ClientAvatar | UpdateUserAvatarResponse,
 > = t.union([
   t.maybe(clientAvatarValidator),
   updateUserAvatarResponseValidator,
 ]);
 
 async function updateUserAvatarResponder(
   viewer: Viewer,
   request: UpdateUserAvatarRequest,
 ): Promise<?ClientAvatar | UpdateUserAvatarResponse> {
   return await updateUserAvatar(viewer, request);
 }
 
 export const claimUsernameResponseValidator: TInterface<ClaimUsernameResponse> =
   tShape<ClaimUsernameResponse>({
     message: t.String,
     signature: t.String,
   });
 
 async function claimUsernameResponder(
   viewer: Viewer,
 ): Promise<ClaimUsernameResponse> {
   const [username, accountInfo] = await Promise.all([
     fetchUsername(viewer.userID),
     fetchOlmAccount('content'),
   ]);
 
   if (!username) {
     throw new ServerError('invalid_credentials');
   }
 
   const issuedAt = new Date().toISOString();
   const reservedUsernameMessage: ReservedUsernameMessage = {
     statement: 'This user is the owner of the following username',
     payload: username,
     issuedAt,
   };
   const message = JSON.stringify(reservedUsernameMessage);
   const signature = accountInfo.account.sign(message);
 
   return { message, signature };
 }
 
 export {
   userSubscriptionUpdateResponder,
   passwordUpdateResponder,
   sendVerificationEmailResponder,
   sendPasswordResetEmailResponder,
   logOutResponder,
   accountDeletionResponder,
   accountCreationResponder,
   logInResponder,
   siweAuthResponder,
   oldPasswordUpdateResponder,
   updateUserSettingsResponder,
   policyAcknowledgmentResponder,
   updateUserAvatarResponder,
   claimUsernameResponder,
 };
diff --git a/keyserver/src/shared/state-sync/current-user-state-sync-spec.js b/keyserver/src/shared/state-sync/current-user-state-sync-spec.js
index 088f58dc0..d9da2413c 100644
--- a/keyserver/src/shared/state-sync/current-user-state-sync-spec.js
+++ b/keyserver/src/shared/state-sync/current-user-state-sync-spec.js
@@ -1,24 +1,21 @@
 // @flow
 
 import { currentUserStateSyncSpec as libSpec } from 'lib/shared/state-sync/current-user-state-sync-spec.js';
-import type {
-  CurrentUserInfo,
-  OldCurrentUserInfo,
-} from 'lib/types/user-types.js';
+import type { CurrentUserInfo } from 'lib/types/user-types.js';
 
 import type { ServerStateSyncSpec } from './state-sync-spec.js';
 import { fetchCurrentUserInfo } from '../../fetchers/user-fetchers.js';
 import type { Viewer } from '../../session/viewer.js';
 
 export const currentUserStateSyncSpec: ServerStateSyncSpec<
-  OldCurrentUserInfo | CurrentUserInfo,
-  OldCurrentUserInfo | CurrentUserInfo,
+  CurrentUserInfo,
+  CurrentUserInfo,
 > = Object.freeze({
   fetch(viewer: Viewer) {
     return fetchCurrentUserInfo(viewer);
   },
   fetchFullSocketSyncPayload(viewer: Viewer) {
     return fetchCurrentUserInfo(viewer);
   },
   ...libSpec,
 });
diff --git a/lib/shared/state-sync/current-user-state-sync-spec.js b/lib/shared/state-sync/current-user-state-sync-spec.js
index 78b1e2114..7399cd328 100644
--- a/lib/shared/state-sync/current-user-state-sync-spec.js
+++ b/lib/shared/state-sync/current-user-state-sync-spec.js
@@ -1,23 +1,21 @@
 // @flow
 
 import type { StateSyncSpec } from './state-sync-spec.js';
 import {
   type CurrentUserInfo,
-  type OldCurrentUserInfo,
   currentUserInfoValidator,
 } from '../../types/user-types.js';
 import { convertClientIDsToServerIDs } from '../../utils/conversion-utils.js';
 import { ashoatKeyserverID } from '../../utils/validation-utils.js';
 
-export const currentUserStateSyncSpec: StateSyncSpec<
-  OldCurrentUserInfo | CurrentUserInfo,
-> = Object.freeze({
-  hashKey: 'currentUserInfo',
-  convertClientToServerInfos(info: OldCurrentUserInfo | CurrentUserInfo) {
-    return convertClientIDsToServerIDs(
-      ashoatKeyserverID,
-      currentUserInfoValidator,
-      info,
-    );
-  },
-});
+export const currentUserStateSyncSpec: StateSyncSpec<CurrentUserInfo> =
+  Object.freeze({
+    hashKey: 'currentUserInfo',
+    convertClientToServerInfos(info: CurrentUserInfo) {
+      return convertClientIDsToServerIDs(
+        ashoatKeyserverID,
+        currentUserInfoValidator,
+        info,
+      );
+    },
+  });
diff --git a/lib/types/account-types.js b/lib/types/account-types.js
index 0d521b6a4..d5fa4fb9b 100644
--- a/lib/types/account-types.js
+++ b/lib/types/account-types.js
@@ -1,210 +1,209 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import type { SignedIdentityKeysBlob } from './crypto-types.js';
 import type { PlatformDetails } from './device-types.js';
 import type {
   CalendarQuery,
   CalendarResult,
   RawEntryInfo,
 } from './entry-types.js';
 import {
   type RawMessageInfo,
   type MessageTruncationStatuses,
   type GenericMessagesResult,
 } from './message-types.js';
 import type { PreRequestUserState } from './session-types.js';
 import { type RawThreadInfo } from './thread-types.js';
 import {
   type UserInfo,
   type LoggedOutUserInfo,
   type LoggedInUserInfo,
-  type OldLoggedInUserInfo,
 } from './user-types.js';
 import type { PolicyType } from '../facts/policies.js';
 import { values } from '../utils/objects.js';
 import { tShape } from '../utils/validation-utils.js';
 
 export type ResetPasswordRequest = {
   +usernameOrEmail: string,
 };
 
 export type LogOutResult = {
   +currentUserInfo: ?LoggedOutUserInfo,
   +preRequestUserState: PreRequestUserState,
 };
 
 export type LogOutResponse = {
   +currentUserInfo: LoggedOutUserInfo,
 };
 
 export type RegisterInfo = {
   ...LogInExtraInfo,
   +username: string,
   +password: string,
 };
 
 type DeviceTokenUpdateRequest = {
   +deviceToken: string,
 };
 
 export type RegisterRequest = {
   +username: string,
   +email?: empty,
   +password: string,
   +calendarQuery?: ?CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +platformDetails: PlatformDetails,
   +primaryIdentityPublicKey?: empty,
   +signedIdentityKeysBlob?: SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
 };
 
 export type RegisterResponse = {
   id: string,
   rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
-  currentUserInfo: OldLoggedInUserInfo | LoggedInUserInfo,
+  currentUserInfo: LoggedInUserInfo,
   cookieChange: {
     threadInfos: { +[id: string]: RawThreadInfo },
     userInfos: $ReadOnlyArray<UserInfo>,
   },
 };
 
 export type RegisterResult = {
   +currentUserInfo: LoggedInUserInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +threadInfos: { +[id: string]: RawThreadInfo },
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarQuery: CalendarQuery,
 };
 
 export type DeleteAccountRequest = {
   +password: ?string,
 };
 
 export const logInActionSources = Object.freeze({
   cookieInvalidationResolutionAttempt: 'COOKIE_INVALIDATION_RESOLUTION_ATTEMPT',
   appStartCookieLoggedInButInvalidRedux:
     'APP_START_COOKIE_LOGGED_IN_BUT_INVALID_REDUX',
   appStartReduxLoggedInButInvalidCookie:
     'APP_START_REDUX_LOGGED_IN_BUT_INVALID_COOKIE',
   socketAuthErrorResolutionAttempt: 'SOCKET_AUTH_ERROR_RESOLUTION_ATTEMPT',
   sqliteOpFailure: 'SQLITE_OP_FAILURE',
   sqliteLoadFailure: 'SQLITE_LOAD_FAILURE',
   logInFromWebForm: 'LOG_IN_FROM_WEB_FORM',
   logInFromNativeForm: 'LOG_IN_FROM_NATIVE_FORM',
   logInFromNativeSIWE: 'LOG_IN_FROM_NATIVE_SIWE',
   corruptedDatabaseDeletion: 'CORRUPTED_DATABASE_DELETION',
   refetchUserDataAfterAcknowledgment: 'REFETCH_USER_DATA_AFTER_ACKNOWLEDGMENT',
 });
 
 export type LogInActionSource = $Values<typeof logInActionSources>;
 
 export type LogInStartingPayload = {
   +calendarQuery: CalendarQuery,
   +logInActionSource?: LogInActionSource,
 };
 
 export type LogInExtraInfo = {
   +calendarQuery: CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +signedIdentityKeysBlob?: SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
 };
 
 export type LogInInfo = {
   ...LogInExtraInfo,
   +username: string,
   +password: string,
   +logInActionSource: LogInActionSource,
 };
 
 export type LogInRequest = {
   +usernameOrEmail?: ?string,
   +username?: ?string,
   +password: string,
   +calendarQuery?: ?CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +platformDetails: PlatformDetails,
   +watchedIDs: $ReadOnlyArray<string>,
   +source?: LogInActionSource,
   +primaryIdentityPublicKey?: empty,
   +signedIdentityKeysBlob?: SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
 };
 
 export type LogInResponse = {
-  +currentUserInfo: LoggedInUserInfo | OldLoggedInUserInfo,
+  +currentUserInfo: LoggedInUserInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +rawEntryInfos?: ?$ReadOnlyArray<RawEntryInfo>,
   +serverTime: number,
   +cookieChange: {
     +threadInfos: { +[id: string]: RawThreadInfo },
     +userInfos: $ReadOnlyArray<UserInfo>,
   },
   +notAcknowledgedPolicies?: $ReadOnlyArray<PolicyType>,
 };
 
 export type LogInResult = {
   +threadInfos: { +[id: string]: RawThreadInfo },
   +currentUserInfo: LoggedInUserInfo,
   +messagesResult: GenericMessagesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarResult: CalendarResult,
   +updatesCurrentAsOf: number,
   +logInActionSource: LogInActionSource,
   +notAcknowledgedPolicies?: $ReadOnlyArray<PolicyType>,
 };
 
 export type UpdatePasswordRequest = {
   code: string,
   password: string,
   calendarQuery?: ?CalendarQuery,
   deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   platformDetails: PlatformDetails,
   watchedIDs: $ReadOnlyArray<string>,
 };
 
 export type PolicyAcknowledgmentRequest = {
   +policy: PolicyType,
 };
 
 export type EmailSubscriptionRequest = {
   +email: string,
 };
 export type UpdateUserSettingsRequest = {
   +name: 'default_user_notifications',
   +data: NotificationTypes,
 };
 
 export const userSettingsTypes = Object.freeze({
   DEFAULT_NOTIFICATIONS: 'default_user_notifications',
 });
 
 export const notificationTypes = Object.freeze({
   FOCUSED: 'focused',
   BADGE_ONLY: 'badge_only',
   BACKGROUND: 'background',
 });
 
 export type NotificationTypes = $Values<typeof notificationTypes>;
 
 export const notificationTypeValues: $ReadOnlyArray<NotificationTypes> =
   values(notificationTypes);
 
 export type DefaultNotificationPayload = {
   +default_user_notifications: ?NotificationTypes,
 };
 
 export const defaultNotificationPayloadValidator: TInterface<DefaultNotificationPayload> =
   tShape<DefaultNotificationPayload>({
     default_user_notifications: t.maybe(t.enums.of(notificationTypeValues)),
   });
 
 export type ClaimUsernameResponse = {
   +message: string,
   +signature: string,
 };
diff --git a/lib/types/request-types.js b/lib/types/request-types.js
index d9d85b0b0..f3c0fc95d 100644
--- a/lib/types/request-types.js
+++ b/lib/types/request-types.js
@@ -1,306 +1,302 @@
 // @flow
 
 import invariant from 'invariant';
 import t, { type TUnion, type TInterface } from 'tcomb';
 
 import { type ActivityUpdate } from './activity-types.js';
 import type { Shape } from './core.js';
 import type { SignedIdentityKeysBlob } from './crypto-types.js';
 import { signedIdentityKeysBlobValidator } from './crypto-types.js';
 import type { Platform, PlatformDetails } from './device-types.js';
 import {
   type RawEntryInfo,
   type CalendarQuery,
   rawEntryInfoValidator,
 } from './entry-types.js';
 import type {
   ThreadInconsistencyReportShape,
   EntryInconsistencyReportShape,
   ClientThreadInconsistencyReportShape,
   ClientEntryInconsistencyReportShape,
 } from './report-types.js';
 import { type RawThreadInfo, rawThreadInfoValidator } from './thread-types.js';
 import {
   type CurrentUserInfo,
   currentUserInfoValidator,
-  type OldCurrentUserInfo,
-  oldCurrentUserInfoValidator,
   type AccountUserInfo,
   accountUserInfoValidator,
 } from './user-types.js';
 import { tNumber, tShape, tID } from '../utils/validation-utils.js';
 
 // "Server requests" are requests for information that the server delivers to
 // clients. Clients then respond to those requests with a "client response".
 export const serverRequestTypes = Object.freeze({
   PLATFORM: 0,
   //DEVICE_TOKEN: 1,            (DEPRECATED)
   THREAD_INCONSISTENCY: 2,
   PLATFORM_DETAILS: 3,
   //INITIAL_ACTIVITY_UPDATE: 4, (DEPRECATED)
   ENTRY_INCONSISTENCY: 5,
   CHECK_STATE: 6,
   INITIAL_ACTIVITY_UPDATES: 7,
   MORE_ONE_TIME_KEYS: 8,
   SIGNED_IDENTITY_KEYS_BLOB: 9,
   INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE: 10,
 });
 type ServerRequestType = $Values<typeof serverRequestTypes>;
 export function assertServerRequestType(
   serverRequestType: number,
 ): ServerRequestType {
   invariant(
     serverRequestType === 0 ||
       serverRequestType === 2 ||
       serverRequestType === 3 ||
       serverRequestType === 5 ||
       serverRequestType === 6 ||
       serverRequestType === 7 ||
       serverRequestType === 8 ||
       serverRequestType === 9 ||
       serverRequestType === 10,
     'number is not ServerRequestType enum',
   );
   return serverRequestType;
 }
 
 type PlatformServerRequest = {
   +type: 0,
 };
 const platformServerRequestValidator = tShape<PlatformServerRequest>({
   type: tNumber(serverRequestTypes.PLATFORM),
 });
 type PlatformClientResponse = {
   +type: 0,
   +platform: Platform,
 };
 
 export type ThreadInconsistencyClientResponse = {
   ...ThreadInconsistencyReportShape,
   +type: 2,
 };
 
 type PlatformDetailsServerRequest = {
   type: 3,
 };
 const platformDetailsServerRequestValidator =
   tShape<PlatformDetailsServerRequest>({
     type: tNumber(serverRequestTypes.PLATFORM_DETAILS),
   });
 
 type PlatformDetailsClientResponse = {
   type: 3,
   platformDetails: PlatformDetails,
 };
 
 export type EntryInconsistencyClientResponse = {
   type: 5,
   ...EntryInconsistencyReportShape,
 };
 
 export type ServerCheckStateServerRequest = {
   +type: 6,
   +hashesToCheck: { +[key: string]: number },
   +failUnmentioned?: Shape<{
     +threadInfos: boolean,
     +entryInfos: boolean,
     +userInfos: boolean,
   }>,
   +stateChanges?: Shape<{
     +rawThreadInfos: RawThreadInfo[],
     +rawEntryInfos: RawEntryInfo[],
-    +currentUserInfo: CurrentUserInfo | OldCurrentUserInfo,
+    +currentUserInfo: CurrentUserInfo,
     +userInfos: AccountUserInfo[],
     +deleteThreadIDs: string[],
     +deleteEntryIDs: string[],
     +deleteUserInfoIDs: string[],
   }>,
 };
 const serverCheckStateServerRequestValidator =
   tShape<ServerCheckStateServerRequest>({
     type: tNumber(serverRequestTypes.CHECK_STATE),
     hashesToCheck: t.dict(t.String, t.Number),
     failUnmentioned: t.maybe(
       tShape({
         threadInfos: t.maybe(t.Boolean),
         entryInfos: t.maybe(t.Boolean),
         userInfos: t.maybe(t.Boolean),
       }),
     ),
     stateChanges: t.maybe(
       tShape({
         rawThreadInfos: t.maybe(t.list(rawThreadInfoValidator)),
         rawEntryInfos: t.maybe(t.list(rawEntryInfoValidator)),
-        currentUserInfo: t.maybe(
-          t.union([currentUserInfoValidator, oldCurrentUserInfoValidator]),
-        ),
+        currentUserInfo: t.maybe(currentUserInfoValidator),
         userInfos: t.maybe(t.list(accountUserInfoValidator)),
         deleteThreadIDs: t.maybe(t.list(tID)),
         deleteEntryIDs: t.maybe(t.list(tID)),
         deleteUserInfoIDs: t.maybe(t.list(t.String)),
       }),
     ),
   });
 
 type CheckStateClientResponse = {
   +type: 6,
   +hashResults: { +[key: string]: boolean },
 };
 
 type InitialActivityUpdatesClientResponse = {
   +type: 7,
   +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
 };
 
 type MoreOneTimeKeysServerRequest = {
   +type: 8,
 };
 const moreOneTimeKeysServerRequestValidator =
   tShape<MoreOneTimeKeysServerRequest>({
     type: tNumber(serverRequestTypes.MORE_ONE_TIME_KEYS),
   });
 
 type MoreOneTimeKeysClientResponse = {
   +type: 8,
   +keys: $ReadOnlyArray<string>,
 };
 
 type SignedIdentityKeysBlobServerRequest = {
   +type: 9,
 };
 const signedIdentityKeysBlobServerRequestValidator =
   tShape<SignedIdentityKeysBlobServerRequest>({
     type: tNumber(serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB),
   });
 
 type SignedIdentityKeysBlobClientResponse = {
   +type: 9,
   +signedIdentityKeysBlob: SignedIdentityKeysBlob,
 };
 
 type InitialNotificationsEncryptedMessageServerRequest = {
   +type: 10,
 };
 const initialNotificationsEncryptedMessageServerRequestValidator =
   tShape<InitialNotificationsEncryptedMessageServerRequest>({
     type: tNumber(serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE),
   });
 
 type InitialNotificationsEncryptedMessageClientResponse = {
   +type: 10,
   +initialNotificationsEncryptedMessage: string,
 };
 
 export type ServerServerRequest =
   | PlatformServerRequest
   | PlatformDetailsServerRequest
   | ServerCheckStateServerRequest
   | MoreOneTimeKeysServerRequest
   | SignedIdentityKeysBlobServerRequest
   | InitialNotificationsEncryptedMessageServerRequest;
 export const serverServerRequestValidator: TUnion<ServerServerRequest> =
   t.union([
     platformServerRequestValidator,
     platformDetailsServerRequestValidator,
     serverCheckStateServerRequestValidator,
     moreOneTimeKeysServerRequestValidator,
     signedIdentityKeysBlobServerRequestValidator,
     initialNotificationsEncryptedMessageServerRequestValidator,
   ]);
 
 export type ClientResponse =
   | PlatformClientResponse
   | ThreadInconsistencyClientResponse
   | PlatformDetailsClientResponse
   | EntryInconsistencyClientResponse
   | CheckStateClientResponse
   | InitialActivityUpdatesClientResponse
   | MoreOneTimeKeysClientResponse
   | SignedIdentityKeysBlobClientResponse
   | InitialNotificationsEncryptedMessageClientResponse;
 
 export type ClientCheckStateServerRequest = {
   +type: 6,
   +hashesToCheck: { +[key: string]: number },
   +failUnmentioned?: Shape<{
     +threadInfos: boolean,
     +entryInfos: boolean,
     +userInfos: boolean,
   }>,
   +stateChanges?: Shape<{
     +rawThreadInfos: RawThreadInfo[],
     +rawEntryInfos: RawEntryInfo[],
     +currentUserInfo: CurrentUserInfo,
     +userInfos: AccountUserInfo[],
     +deleteThreadIDs: string[],
     +deleteEntryIDs: string[],
     +deleteUserInfoIDs: string[],
   }>,
 };
 export type ClientServerRequest =
   | PlatformServerRequest
   | PlatformDetailsServerRequest
   | ClientCheckStateServerRequest
   | MoreOneTimeKeysServerRequest
   | SignedIdentityKeysBlobServerRequest
   | InitialNotificationsEncryptedMessageServerRequest;
 
 // This is just the client variant of ClientResponse. The server needs to handle
 // multiple client versions so the type supports old versions of certain client
 // responses, but the client variant only need to support the latest version.
 type ClientThreadInconsistencyClientResponse = {
   ...ClientThreadInconsistencyReportShape,
   +type: 2,
 };
 type ClientEntryInconsistencyClientResponse = {
   +type: 5,
   ...ClientEntryInconsistencyReportShape,
 };
 export type ClientClientResponse =
   | PlatformClientResponse
   | ClientThreadInconsistencyClientResponse
   | PlatformDetailsClientResponse
   | ClientEntryInconsistencyClientResponse
   | CheckStateClientResponse
   | InitialActivityUpdatesClientResponse
   | MoreOneTimeKeysClientResponse
   | SignedIdentityKeysBlobClientResponse
   | InitialNotificationsEncryptedMessageClientResponse;
 
 export type ClientInconsistencyResponse =
   | ClientThreadInconsistencyClientResponse
   | ClientEntryInconsistencyClientResponse;
 
 export const processServerRequestsActionType = 'PROCESS_SERVER_REQUESTS';
 export type ProcessServerRequestsPayload = {
   +serverRequests: $ReadOnlyArray<ClientServerRequest>,
   +calendarQuery: CalendarQuery,
 };
 
 export type GetSessionPublicKeysArgs = {
   +session: string,
 };
 
 export type OlmSessionInitializationInfo = {
   +prekey: string,
   +prekeySignature: string,
   +oneTimeKey: string,
 };
 export const olmSessionInitializationInfoValidator: TInterface<OlmSessionInitializationInfo> =
   tShape<OlmSessionInitializationInfo>({
     prekey: t.String,
     prekeySignature: t.String,
     oneTimeKey: t.String,
   });
 
 export type GetOlmSessionInitializationDataResponse = {
   +signedIdentityKeysBlob: SignedIdentityKeysBlob,
   +contentInitializationInfo: OlmSessionInitializationInfo,
   +notifInitializationInfo: OlmSessionInitializationInfo,
 };
 export const getOlmSessionInitializationDataResponseValidator: TInterface<GetOlmSessionInitializationDataResponse> =
   tShape({
     signedIdentityKeysBlob: signedIdentityKeysBlobValidator,
     contentInitializationInfo: olmSessionInitializationInfoValidator,
     notifInitializationInfo: olmSessionInitializationInfoValidator,
   });
diff --git a/lib/types/socket-types.js b/lib/types/socket-types.js
index 363122322..7e9a8d8b0 100644
--- a/lib/types/socket-types.js
+++ b/lib/types/socket-types.js
@@ -1,519 +1,514 @@
 // @flow
 
 import invariant from 'invariant';
 import t, { type TInterface, type TUnion } from 'tcomb';
 
 import {
   type ActivityUpdate,
   activityUpdateValidator,
   type UpdateActivityResult,
   updateActivityResultValidator,
 } from './activity-types.js';
 import type { APIRequest } from './endpoints.js';
 import {
   type RawEntryInfo,
   rawEntryInfoValidator,
   type CalendarQuery,
 } from './entry-types.js';
 import {
   type MessagesResponse,
   messagesResponseValidator,
   type NewMessagesPayload,
   newMessagesPayloadValidator,
 } from './message-types.js';
 import {
   type ServerServerRequest,
   serverServerRequestValidator,
   type ClientServerRequest,
   type ClientResponse,
   type ClientClientResponse,
 } from './request-types.js';
 import type { SessionState, SessionIdentification } from './session-types.js';
 import { type RawThreadInfo, rawThreadInfoValidator } from './thread-types.js';
 import {
   type ClientUpdatesResult,
   type ClientUpdatesResultWithUserInfos,
   type ServerUpdatesResult,
   serverUpdatesResultValidator,
   type ServerUpdatesResultWithUserInfos,
   serverUpdatesResultWithUserInfosValidator,
 } from './update-types.js';
 import {
   type UserInfo,
   userInfoValidator,
   type CurrentUserInfo,
   currentUserInfoValidator,
-  type OldCurrentUserInfo,
-  oldCurrentUserInfoValidator,
   type LoggedOutUserInfo,
   loggedOutUserInfoValidator,
 } from './user-types.js';
 import { tShape, tNumber, tID } from '../utils/validation-utils.js';
 
 // The types of messages that the client sends across the socket
 export const clientSocketMessageTypes = Object.freeze({
   INITIAL: 0,
   RESPONSES: 1,
   //ACTIVITY_UPDATES: 2, (DEPRECATED)
   PING: 3,
   ACK_UPDATES: 4,
   API_REQUEST: 5,
 });
 export type ClientSocketMessageType = $Values<typeof clientSocketMessageTypes>;
 export function assertClientSocketMessageType(
   ourClientSocketMessageType: number,
 ): ClientSocketMessageType {
   invariant(
     ourClientSocketMessageType === 0 ||
       ourClientSocketMessageType === 1 ||
       ourClientSocketMessageType === 3 ||
       ourClientSocketMessageType === 4 ||
       ourClientSocketMessageType === 5,
     'number is not ClientSocketMessageType enum',
   );
   return ourClientSocketMessageType;
 }
 
 export type InitialClientSocketMessage = {
   +type: 0,
   +id: number,
   +payload: {
     +sessionIdentification: SessionIdentification,
     +sessionState: SessionState,
     +clientResponses: $ReadOnlyArray<ClientResponse>,
   },
 };
 export type ResponsesClientSocketMessage = {
   +type: 1,
   +id: number,
   +payload: {
     +clientResponses: $ReadOnlyArray<ClientResponse>,
   },
 };
 export type PingClientSocketMessage = {
   +type: 3,
   +id: number,
 };
 export type AckUpdatesClientSocketMessage = {
   +type: 4,
   +id: number,
   +payload: {
     +currentAsOf: number,
   },
 };
 export type APIRequestClientSocketMessage = {
   +type: 5,
   +id: number,
   +payload: APIRequest,
 };
 export type ClientSocketMessage =
   | InitialClientSocketMessage
   | ResponsesClientSocketMessage
   | PingClientSocketMessage
   | AckUpdatesClientSocketMessage
   | APIRequestClientSocketMessage;
 
 export type ClientInitialClientSocketMessage = {
   +type: 0,
   +id: number,
   +payload: {
     +sessionIdentification: SessionIdentification,
     +sessionState: SessionState,
     +clientResponses: $ReadOnlyArray<ClientClientResponse>,
   },
 };
 export type ClientResponsesClientSocketMessage = {
   +type: 1,
   +id: number,
   +payload: {
     +clientResponses: $ReadOnlyArray<ClientClientResponse>,
   },
 };
 export type ClientClientSocketMessage =
   | ClientInitialClientSocketMessage
   | ClientResponsesClientSocketMessage
   | PingClientSocketMessage
   | AckUpdatesClientSocketMessage
   | APIRequestClientSocketMessage;
 export type ClientSocketMessageWithoutID = $Diff<
   ClientClientSocketMessage,
   { id: number },
 >;
 
 // The types of messages that the server sends across the socket
 export const serverSocketMessageTypes = Object.freeze({
   STATE_SYNC: 0,
   REQUESTS: 1,
   ERROR: 2,
   AUTH_ERROR: 3,
   ACTIVITY_UPDATE_RESPONSE: 4,
   PONG: 5,
   UPDATES: 6,
   MESSAGES: 7,
   API_RESPONSE: 8,
 });
 export type ServerSocketMessageType = $Values<typeof serverSocketMessageTypes>;
 export function assertServerSocketMessageType(
   ourServerSocketMessageType: number,
 ): ServerSocketMessageType {
   invariant(
     ourServerSocketMessageType === 0 ||
       ourServerSocketMessageType === 1 ||
       ourServerSocketMessageType === 2 ||
       ourServerSocketMessageType === 3 ||
       ourServerSocketMessageType === 4 ||
       ourServerSocketMessageType === 5 ||
       ourServerSocketMessageType === 6 ||
       ourServerSocketMessageType === 7 ||
       ourServerSocketMessageType === 8,
     'number is not ServerSocketMessageType enum',
   );
   return ourServerSocketMessageType;
 }
 
 export const stateSyncPayloadTypes = Object.freeze({
   FULL: 0,
   INCREMENTAL: 1,
 });
 
 export const fullStateSyncActionType = 'FULL_STATE_SYNC';
 export type BaseFullStateSync = {
   +messagesResult: MessagesResponse,
   +threadInfos: { +[id: string]: RawThreadInfo },
   +rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +updatesCurrentAsOf: number,
 };
 const baseFullStateSyncValidator = tShape<BaseFullStateSync>({
   messagesResult: messagesResponseValidator,
   threadInfos: t.dict(tID, rawThreadInfoValidator),
   rawEntryInfos: t.list(rawEntryInfoValidator),
   userInfos: t.list(userInfoValidator),
   updatesCurrentAsOf: t.Number,
 });
 
 export type ClientFullStateSync = {
   ...BaseFullStateSync,
   +currentUserInfo: CurrentUserInfo,
 };
 export type StateSyncFullActionPayload = {
   ...ClientFullStateSync,
   +calendarQuery: CalendarQuery,
 };
 export type ClientStateSyncFullSocketPayload = {
   ...ClientFullStateSync,
   +type: 0,
   // Included iff client is using sessionIdentifierTypes.BODY_SESSION_ID
   +sessionID?: string,
 };
 
 export type ServerFullStateSync = {
   ...BaseFullStateSync,
-  +currentUserInfo: CurrentUserInfo | OldCurrentUserInfo,
+  +currentUserInfo: CurrentUserInfo,
 };
 const serverFullStateSyncValidator = tShape<ServerFullStateSync>({
   ...baseFullStateSyncValidator.meta.props,
-  currentUserInfo: t.union([
-    currentUserInfoValidator,
-    oldCurrentUserInfoValidator,
-  ]),
+  currentUserInfo: currentUserInfoValidator,
 });
 
 export type ServerStateSyncFullSocketPayload = {
   ...ServerFullStateSync,
   +type: 0,
   // Included iff client is using sessionIdentifierTypes.BODY_SESSION_ID
   +sessionID?: string,
 };
 const serverStateSyncFullSocketPayloadValidator =
   tShape<ServerStateSyncFullSocketPayload>({
     ...serverFullStateSyncValidator.meta.props,
     type: tNumber(stateSyncPayloadTypes.FULL),
     sessionID: t.maybe(t.String),
   });
 
 export const incrementalStateSyncActionType = 'INCREMENTAL_STATE_SYNC';
 export type BaseIncrementalStateSync = {
   +messagesResult: MessagesResponse,
   +deltaEntryInfos: $ReadOnlyArray<RawEntryInfo>,
   +deletedEntryIDs: $ReadOnlyArray<string>,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 const baseIncrementalStateSyncValidator = tShape<BaseIncrementalStateSync>({
   messagesResult: messagesResponseValidator,
   deltaEntryInfos: t.list(rawEntryInfoValidator),
   deletedEntryIDs: t.list(tID),
   userInfos: t.list(userInfoValidator),
 });
 
 export type ClientIncrementalStateSync = {
   ...BaseIncrementalStateSync,
   +updatesResult: ClientUpdatesResult,
 };
 export type StateSyncIncrementalActionPayload = {
   ...ClientIncrementalStateSync,
   +calendarQuery: CalendarQuery,
 };
 type ClientStateSyncIncrementalSocketPayload = {
   +type: 1,
   ...ClientIncrementalStateSync,
 };
 
 export type ServerIncrementalStateSync = {
   ...BaseIncrementalStateSync,
   +updatesResult: ServerUpdatesResult,
 };
 const serverIncrementalStateSyncValidator = tShape<ServerIncrementalStateSync>({
   ...baseIncrementalStateSyncValidator.meta.props,
   updatesResult: serverUpdatesResultValidator,
 });
 
 type ServerStateSyncIncrementalSocketPayload = {
   +type: 1,
   ...ServerIncrementalStateSync,
 };
 const serverStateSyncIncrementalSocketPayloadValidator =
   tShape<ServerStateSyncIncrementalSocketPayload>({
     type: tNumber(stateSyncPayloadTypes.INCREMENTAL),
     ...serverIncrementalStateSyncValidator.meta.props,
   });
 
 export type ClientStateSyncSocketPayload =
   | ClientStateSyncFullSocketPayload
   | ClientStateSyncIncrementalSocketPayload;
 export type ServerStateSyncSocketPayload =
   | ServerStateSyncFullSocketPayload
   | ServerStateSyncIncrementalSocketPayload;
 const serverStateSyncSocketPayloadValidator = t.union([
   serverStateSyncFullSocketPayloadValidator,
   serverStateSyncIncrementalSocketPayloadValidator,
 ]);
 
 export type ServerStateSyncServerSocketMessage = {
   +type: 0,
   +responseTo: number,
   +payload: ServerStateSyncSocketPayload,
 };
 export const serverStateSyncServerSocketMessageValidator: TInterface<ServerStateSyncServerSocketMessage> =
   tShape<ServerStateSyncServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.STATE_SYNC),
     responseTo: t.Number,
     payload: serverStateSyncSocketPayloadValidator,
   });
 
 export type ServerRequestsServerSocketMessage = {
   +type: 1,
   +responseTo?: number,
   +payload: {
     +serverRequests: $ReadOnlyArray<ServerServerRequest>,
   },
 };
 export const serverRequestsServerSocketMessageValidator: TInterface<ServerRequestsServerSocketMessage> =
   tShape<ServerRequestsServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.REQUESTS),
     responseTo: t.maybe(t.Number),
     payload: tShape({
       serverRequests: t.list(serverServerRequestValidator),
     }),
   });
 
 export type ErrorServerSocketMessage = {
   type: 2,
   responseTo?: number,
   message: string,
   payload?: Object,
 };
 export const errorServerSocketMessageValidator: TInterface<ErrorServerSocketMessage> =
   tShape<ErrorServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.ERROR),
     responseTo: t.maybe(t.Number),
     message: t.String,
     payload: t.maybe(t.Object),
   });
 
 export type AuthErrorServerSocketMessage = {
   type: 3,
   responseTo: number,
   message: string,
   // If unspecified, it is because the client is using cookieSources.HEADER,
   // which means the server can't update the cookie from a socket message.
   sessionChange?: {
     cookie: string,
     currentUserInfo: LoggedOutUserInfo,
   },
 };
 export const authErrorServerSocketMessageValidator: TInterface<AuthErrorServerSocketMessage> =
   tShape<AuthErrorServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.AUTH_ERROR),
     responseTo: t.Number,
     message: t.String,
     sessionChange: t.maybe(
       tShape({ cookie: t.String, currentUserInfo: loggedOutUserInfoValidator }),
     ),
   });
 
 export type ActivityUpdateResponseServerSocketMessage = {
   +type: 4,
   +responseTo: number,
   +payload: UpdateActivityResult,
 };
 export const activityUpdateResponseServerSocketMessageValidator: TInterface<ActivityUpdateResponseServerSocketMessage> =
   tShape<ActivityUpdateResponseServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.ACTIVITY_UPDATE_RESPONSE),
     responseTo: t.Number,
     payload: updateActivityResultValidator,
   });
 
 export type PongServerSocketMessage = {
   +type: 5,
   +responseTo: number,
 };
 export const pongServerSocketMessageValidator: TInterface<PongServerSocketMessage> =
   tShape<PongServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.PONG),
     responseTo: t.Number,
   });
 
 export type ServerUpdatesServerSocketMessage = {
   +type: 6,
   +payload: ServerUpdatesResultWithUserInfos,
 };
 export const serverUpdatesServerSocketMessageValidator: TInterface<ServerUpdatesServerSocketMessage> =
   tShape<ServerUpdatesServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.UPDATES),
     payload: serverUpdatesResultWithUserInfosValidator,
   });
 
 export type MessagesServerSocketMessage = {
   +type: 7,
   +payload: NewMessagesPayload,
 };
 export const messagesServerSocketMessageValidator: TInterface<MessagesServerSocketMessage> =
   tShape<MessagesServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.MESSAGES),
     payload: newMessagesPayloadValidator,
   });
 
 export type APIResponseServerSocketMessage = {
   +type: 8,
   +responseTo: number,
   +payload?: Object,
 };
 export const apiResponseServerSocketMessageValidator: TInterface<APIResponseServerSocketMessage> =
   tShape<APIResponseServerSocketMessage>({
     type: tNumber(serverSocketMessageTypes.API_RESPONSE),
     responseTo: t.Number,
     payload: t.maybe(t.Object),
   });
 
 export type ServerServerSocketMessage =
   | ServerStateSyncServerSocketMessage
   | ServerRequestsServerSocketMessage
   | ErrorServerSocketMessage
   | AuthErrorServerSocketMessage
   | ActivityUpdateResponseServerSocketMessage
   | PongServerSocketMessage
   | ServerUpdatesServerSocketMessage
   | MessagesServerSocketMessage
   | APIResponseServerSocketMessage;
 export const serverServerSocketMessageValidator: TUnion<ServerServerSocketMessage> =
   t.union([
     serverStateSyncServerSocketMessageValidator,
     serverRequestsServerSocketMessageValidator,
     errorServerSocketMessageValidator,
     authErrorServerSocketMessageValidator,
     activityUpdateResponseServerSocketMessageValidator,
     pongServerSocketMessageValidator,
     serverUpdatesServerSocketMessageValidator,
     messagesServerSocketMessageValidator,
     apiResponseServerSocketMessageValidator,
   ]);
 
 export type ClientRequestsServerSocketMessage = {
   +type: 1,
   +responseTo?: number,
   +payload: {
     +serverRequests: $ReadOnlyArray<ClientServerRequest>,
   },
 };
 export type ClientStateSyncServerSocketMessage = {
   +type: 0,
   +responseTo: number,
   +payload: ClientStateSyncSocketPayload,
 };
 export type ClientUpdatesServerSocketMessage = {
   +type: 6,
   +payload: ClientUpdatesResultWithUserInfos,
 };
 export type ClientServerSocketMessage =
   | ClientStateSyncServerSocketMessage
   | ClientRequestsServerSocketMessage
   | ErrorServerSocketMessage
   | AuthErrorServerSocketMessage
   | ActivityUpdateResponseServerSocketMessage
   | PongServerSocketMessage
   | ClientUpdatesServerSocketMessage
   | MessagesServerSocketMessage
   | APIResponseServerSocketMessage;
 
 export type SocketListener = (message: ClientServerSocketMessage) => void;
 
 export type ConnectionStatus =
   | 'connecting'
   | 'connected'
   | 'reconnecting'
   | 'disconnecting'
   | 'forcedDisconnecting'
   | 'disconnected';
 export type ConnectionInfo = {
   +status: ConnectionStatus,
   +queuedActivityUpdates: $ReadOnlyArray<ActivityUpdate>,
   +lateResponses: $ReadOnlyArray<number>,
   +showDisconnectedBar: boolean,
 };
 export const connectionInfoValidator: TInterface<ConnectionInfo> =
   tShape<ConnectionInfo>({
     status: t.enums.of([
       'connecting',
       'connected',
       'reconnecting',
       'disconnecting',
       'forcedDisconnecting',
       'disconnected',
     ]),
     queuedActivityUpdates: t.list(activityUpdateValidator),
     lateResponses: t.list(t.Number),
     showDisconnectedBar: t.Boolean,
   });
 export const defaultConnectionInfo: ConnectionInfo = {
   status: 'connecting',
   queuedActivityUpdates: [],
   lateResponses: [],
   showDisconnectedBar: false,
 };
 export const updateConnectionStatusActionType = 'UPDATE_CONNECTION_STATUS';
 export type UpdateConnectionStatusPayload = {
   +status: ConnectionStatus,
 };
 
 export const setLateResponseActionType = 'SET_LATE_RESPONSE';
 export type SetLateResponsePayload = {
   +messageID: number,
   +isLate: boolean,
 };
 
 export const updateDisconnectedBarActionType = 'UPDATE_DISCONNECTED_BAR';
 export type UpdateDisconnectedBarPayload = { +visible: boolean };
 
 export type OneTimeKeyGenerator = (inc: number) => string;
 
 export type GRPCStream = {
   readyState: number,
   onopen: (ev: any) => mixed,
   onmessage: (ev: MessageEvent) => mixed,
   onclose: (ev: CloseEvent) => mixed,
   close(code?: number, reason?: string): void,
   send(data: string | Blob | ArrayBuffer | $ArrayBufferView): void,
 };
 
 export type CommTransportLayer = GRPCStream | WebSocket;
diff --git a/lib/types/update-types.js b/lib/types/update-types.js
index d36881125..d1a78ad8a 100644
--- a/lib/types/update-types.js
+++ b/lib/types/update-types.js
@@ -1,404 +1,399 @@
 // @flow
 
 import t, { type TUnion, type TInterface } from 'tcomb';
 
 import { type RawEntryInfo, rawEntryInfoValidator } from './entry-types.js';
 import {
   type RawMessageInfo,
   rawMessageInfoValidator,
   type MessageTruncationStatus,
   messageTruncationStatusValidator,
 } from './message-types.js';
 import { type RawThreadInfo, rawThreadInfoValidator } from './thread-types.js';
 import { updateTypes } from './update-types-enum.js';
 import {
   type UserInfo,
   userInfoValidator,
   type UserInfos,
   userInfosValidator,
   type LoggedInUserInfo,
   loggedInUserInfoValidator,
-  type OldLoggedInUserInfo,
-  oldLoggedInUserInfoValidator,
 } from './user-types.js';
 import { tNumber, tShape, tID } from '../utils/validation-utils.js';
 
 type AccountDeletionData = {
   +deletedUserID: string,
 };
 type ThreadData = {
   +threadID: string,
 };
 type ThreadReadStatusData = {
   +threadID: string,
   +unread: boolean,
 };
 type ThreadDeletionData = {
   +threadID: string,
 };
 type ThreadJoinData = {
   +threadID: string,
 };
 type BadDeviceTokenData = {
   +deviceToken: string,
 };
 type EntryData = {
   +entryID: string,
 };
 type CurrentUserData = {};
 type UserData = {
   // ID of the UserInfo being updated
   +updatedUserID: string,
 };
 
 type SharedUpdateData = {
   +userID: string,
   +time: number,
 };
 type AccountDeletionUpdateData = {
   ...SharedUpdateData,
   ...AccountDeletionData,
   +type: 0,
 };
 type ThreadUpdateData = {
   ...SharedUpdateData,
   ...ThreadData,
   +type: 1,
   +targetSession?: string,
 };
 type ThreadReadStatusUpdateData = {
   ...SharedUpdateData,
   ...ThreadReadStatusData,
   +type: 2,
 };
 type ThreadDeletionUpdateData = {
   ...SharedUpdateData,
   ...ThreadDeletionData,
   +type: 3,
 };
 type ThreadJoinUpdateData = {
   ...SharedUpdateData,
   ...ThreadJoinData,
   +type: 4,
   +targetSession?: string,
 };
 type BadDeviceTokenUpdateData = {
   ...SharedUpdateData,
   ...BadDeviceTokenData,
   +type: 5,
   +targetCookie: string,
 };
 type EntryUpdateData = {
   ...SharedUpdateData,
   ...EntryData,
   +type: 6,
   +targetSession: string,
 };
 type CurrentUserUpdateData = {
   ...SharedUpdateData,
   ...CurrentUserData,
   +type: 7,
 };
 type UserUpdateData = {
   ...SharedUpdateData,
   ...UserData,
   +type: 8,
   +targetSession?: string,
 };
 export type UpdateData =
   | AccountDeletionUpdateData
   | ThreadUpdateData
   | ThreadReadStatusUpdateData
   | ThreadDeletionUpdateData
   | ThreadJoinUpdateData
   | BadDeviceTokenUpdateData
   | EntryUpdateData
   | CurrentUserUpdateData
   | UserUpdateData;
 
 type SharedRawUpdateInfo = {
   +id: string,
   +time: number,
 };
 type AccountDeletionRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...AccountDeletionData,
   +type: 0,
 };
 type ThreadRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...ThreadData,
   +type: 1,
 };
 type ThreadReadStatusRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...ThreadReadStatusData,
   +type: 2,
 };
 type ThreadDeletionRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...ThreadDeletionData,
   +type: 3,
 };
 type ThreadJoinRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...ThreadJoinData,
   +type: 4,
 };
 type BadDeviceTokenRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...BadDeviceTokenData,
   +type: 5,
 };
 type EntryRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...EntryData,
   +type: 6,
 };
 type CurrentUserRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...CurrentUserData,
   +type: 7,
 };
 type UserRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...UserData,
   +type: 8,
 };
 export type RawUpdateInfo =
   | AccountDeletionRawUpdateInfo
   | ThreadRawUpdateInfo
   | ThreadReadStatusRawUpdateInfo
   | ThreadDeletionRawUpdateInfo
   | ThreadJoinRawUpdateInfo
   | BadDeviceTokenRawUpdateInfo
   | EntryRawUpdateInfo
   | CurrentUserRawUpdateInfo
   | UserRawUpdateInfo;
 
 type AccountDeletionUpdateInfo = {
   +type: 0,
   +id: string,
   +time: number,
   +deletedUserID: string,
 };
 export const accountDeletionUpdateInfoValidator: TInterface<AccountDeletionUpdateInfo> =
   tShape<AccountDeletionUpdateInfo>({
     type: tNumber(updateTypes.DELETE_ACCOUNT),
     id: t.String,
     time: t.Number,
     deletedUserID: t.String,
   });
 
 type ThreadUpdateInfo = {
   +type: 1,
   +id: string,
   +time: number,
   +threadInfo: RawThreadInfo,
 };
 export const threadUpdateInfoValidator: TInterface<ThreadUpdateInfo> =
   tShape<ThreadUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_THREAD),
     id: t.String,
     time: t.Number,
     threadInfo: rawThreadInfoValidator,
   });
 type ThreadReadStatusUpdateInfo = {
   +type: 2,
   +id: string,
   +time: number,
   +threadID: string,
   +unread: boolean,
 };
 export const threadReadStatusUpdateInfoValidator: TInterface<ThreadReadStatusUpdateInfo> =
   tShape<ThreadReadStatusUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_THREAD_READ_STATUS),
     id: t.String,
     time: t.Number,
     threadID: tID,
     unread: t.Boolean,
   });
 type ThreadDeletionUpdateInfo = {
   +type: 3,
   +id: string,
   +time: number,
   +threadID: string,
 };
 export const threadDeletionUpdateInfoValidator: TInterface<ThreadDeletionUpdateInfo> =
   tShape<ThreadDeletionUpdateInfo>({
     type: tNumber(updateTypes.DELETE_THREAD),
     id: t.String,
     time: t.Number,
     threadID: tID,
   });
 
 type ThreadJoinUpdateInfo = {
   +type: 4,
   +id: string,
   +time: number,
   +threadInfo: RawThreadInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatus: MessageTruncationStatus,
   +rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
 };
 export const threadJoinUpdateInfoValidator: TInterface<ThreadJoinUpdateInfo> =
   tShape<ThreadJoinUpdateInfo>({
     type: tNumber(updateTypes.JOIN_THREAD),
     id: t.String,
     time: t.Number,
     threadInfo: rawThreadInfoValidator,
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatus: messageTruncationStatusValidator,
     rawEntryInfos: t.list(rawEntryInfoValidator),
   });
 type BadDeviceTokenUpdateInfo = {
   +type: 5,
   +id: string,
   +time: number,
   +deviceToken: string,
 };
 export const badDeviceTokenUpdateInfoValidator: TInterface<BadDeviceTokenUpdateInfo> =
   tShape<BadDeviceTokenUpdateInfo>({
     type: tNumber(updateTypes.BAD_DEVICE_TOKEN),
     id: t.String,
     time: t.Number,
     deviceToken: t.String,
   });
 type EntryUpdateInfo = {
   +type: 6,
   +id: string,
   +time: number,
   +entryInfo: RawEntryInfo,
 };
 export const entryUpdateInfoValidator: TInterface<EntryUpdateInfo> =
   tShape<EntryUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_ENTRY),
     id: t.String,
     time: t.Number,
     entryInfo: rawEntryInfoValidator,
   });
 type CurrentUserUpdateInfo = {
   +type: 7,
   +id: string,
   +time: number,
   +currentUserInfo: LoggedInUserInfo,
 };
 type UserUpdateInfo = {
   +type: 8,
   +id: string,
   +time: number,
   // Updated UserInfo is already contained within the UpdatesResultWithUserInfos
   +updatedUserID: string,
 };
 export const userUpdateInfoValidator: TInterface<UserUpdateInfo> =
   tShape<UserUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_USER),
     id: t.String,
     time: t.Number,
     updatedUserID: t.String,
   });
 export type ClientUpdateInfo =
   | AccountDeletionUpdateInfo
   | ThreadUpdateInfo
   | ThreadReadStatusUpdateInfo
   | ThreadDeletionUpdateInfo
   | ThreadJoinUpdateInfo
   | BadDeviceTokenUpdateInfo
   | EntryUpdateInfo
   | CurrentUserUpdateInfo
   | UserUpdateInfo;
 
 type ServerCurrentUserUpdateInfo = {
   +type: 7,
   +id: string,
   +time: number,
-  +currentUserInfo: LoggedInUserInfo | OldLoggedInUserInfo,
+  +currentUserInfo: LoggedInUserInfo,
 };
 export const serverCurrentUserUpdateInfoValidator: TInterface<ServerCurrentUserUpdateInfo> =
   tShape<ServerCurrentUserUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_CURRENT_USER),
     id: t.String,
     time: t.Number,
-    currentUserInfo: t.union([
-      loggedInUserInfoValidator,
-      oldLoggedInUserInfoValidator,
-    ]),
+    currentUserInfo: loggedInUserInfoValidator,
   });
 export type ServerUpdateInfo =
   | AccountDeletionUpdateInfo
   | ThreadUpdateInfo
   | ThreadReadStatusUpdateInfo
   | ThreadDeletionUpdateInfo
   | ThreadJoinUpdateInfo
   | BadDeviceTokenUpdateInfo
   | EntryUpdateInfo
   | ServerCurrentUserUpdateInfo
   | UserUpdateInfo;
 export const serverUpdateInfoValidator: TUnion<ServerUpdateInfo> = t.union([
   accountDeletionUpdateInfoValidator,
   threadUpdateInfoValidator,
   threadReadStatusUpdateInfoValidator,
   threadDeletionUpdateInfoValidator,
   threadJoinUpdateInfoValidator,
   badDeviceTokenUpdateInfoValidator,
   entryUpdateInfoValidator,
   serverCurrentUserUpdateInfoValidator,
   userUpdateInfoValidator,
 ]);
 
 export type ServerUpdatesResult = {
   +currentAsOf: number,
   +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
 };
 export const serverUpdatesResultValidator: TInterface<ServerUpdatesResult> =
   tShape<ServerUpdatesResult>({
     currentAsOf: t.Number,
     newUpdates: t.list(serverUpdateInfoValidator),
   });
 
 export type ServerUpdatesResultWithUserInfos = {
   +updatesResult: ServerUpdatesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 export const serverUpdatesResultWithUserInfosValidator: TInterface<ServerUpdatesResultWithUserInfos> =
   tShape<ServerUpdatesResultWithUserInfos>({
     updatesResult: serverUpdatesResultValidator,
     userInfos: t.list(userInfoValidator),
   });
 
 export type ClientUpdatesResult = {
   +currentAsOf: number,
   +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
 };
 export type ClientUpdatesResultWithUserInfos = {
   +updatesResult: ClientUpdatesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export type CreateUpdatesResult = {
   +viewerUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   +userInfos: UserInfos,
 };
 export const createUpdatesResultValidator: TInterface<CreateUpdatesResult> =
   tShape<CreateUpdatesResult>({
     viewerUpdates: t.list(serverUpdateInfoValidator),
     userInfos: userInfosValidator,
   });
 
 export type ServerCreateUpdatesResponse = {
   +viewerUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export const serverCreateUpdatesResponseValidator: TInterface<ServerCreateUpdatesResponse> =
   tShape<ServerCreateUpdatesResponse>({
     viewerUpdates: t.list(serverUpdateInfoValidator),
     userInfos: t.list(userInfoValidator),
   });
 
 export type ClientCreateUpdatesResponse = {
   +viewerUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export const processUpdatesActionType = 'PROCESS_UPDATES';
diff --git a/lib/types/user-types.js b/lib/types/user-types.js
index 8aa6e532a..670166749 100644
--- a/lib/types/user-types.js
+++ b/lib/types/user-types.js
@@ -1,142 +1,122 @@
 // @flow
 
 import t, { type TInterface, type TDict, type TUnion } from 'tcomb';
 
 import {
   type DefaultNotificationPayload,
   defaultNotificationPayloadValidator,
 } from './account-types.js';
 import { type ClientAvatar, clientAvatarValidator } from './avatar-types.js';
 import {
   type UserRelationshipStatus,
   userRelationshipStatusValidator,
 } from './relationship-types.js';
 import type { UserInconsistencyReportCreationRequest } from './report-types.js';
 import { tBool, tShape } from '../utils/validation-utils.js';
 
 export type GlobalUserInfo = {
   +id: string,
   +username: ?string,
   +avatar?: ?ClientAvatar,
 };
 
 export type GlobalAccountUserInfo = {
   +id: string,
   +username: string,
   +avatar?: ?ClientAvatar,
 };
 export const globalAccountUserInfoValidator: TInterface<GlobalAccountUserInfo> =
   tShape<GlobalAccountUserInfo>({
     id: t.String,
     username: t.String,
     avatar: t.maybe(clientAvatarValidator),
   });
 
 export type UserInfo = {
   +id: string,
   +username: ?string,
   +relationshipStatus?: UserRelationshipStatus,
   +avatar?: ?ClientAvatar,
 };
 export const userInfoValidator: TInterface<UserInfo> = tShape<UserInfo>({
   id: t.String,
   username: t.maybe(t.String),
   relationshipStatus: t.maybe(userRelationshipStatusValidator),
   avatar: t.maybe(clientAvatarValidator),
 });
 export type UserInfos = { +[id: string]: UserInfo };
 export const userInfosValidator: TDict<UserInfos> = t.dict(
   t.String,
   userInfoValidator,
 );
 
 export type AccountUserInfo = {
   +id: string,
   +username: string,
   +relationshipStatus?: UserRelationshipStatus,
   +avatar?: ?ClientAvatar,
 };
 export const accountUserInfoValidator: TInterface<AccountUserInfo> =
   tShape<AccountUserInfo>({
     id: t.String,
     username: t.String,
     relationshipStatus: t.maybe(userRelationshipStatusValidator),
     avatar: t.maybe(clientAvatarValidator),
   });
 
 export type UserStore = {
   +userInfos: UserInfos,
   +inconsistencyReports: $ReadOnlyArray<UserInconsistencyReportCreationRequest>,
 };
 
 export type RelativeUserInfo = {
   +id: string,
   +username: ?string,
   +isViewer: boolean,
   +avatar?: ?ClientAvatar,
 };
 
-export type OldLoggedInUserInfo = {
-  +id: string,
-  +username: string,
-  +email: string,
-  +emailVerified: boolean,
-};
-export const oldLoggedInUserInfoValidator: TInterface<OldLoggedInUserInfo> =
-  tShape<OldLoggedInUserInfo>({
-    id: t.String,
-    username: t.String,
-    email: t.String,
-    emailVerified: t.Boolean,
-  });
-
 export type LoggedInUserInfo = {
   +id: string,
   +username: string,
   +settings?: DefaultNotificationPayload,
   +avatar?: ?ClientAvatar,
 };
 export const loggedInUserInfoValidator: TInterface<LoggedInUserInfo> =
   tShape<LoggedInUserInfo>({
     id: t.String,
     username: t.String,
     settings: t.maybe(defaultNotificationPayloadValidator),
     avatar: t.maybe(clientAvatarValidator),
   });
 
 export type LoggedOutUserInfo = {
   +id: string,
   +anonymous: true,
 };
 export const loggedOutUserInfoValidator: TInterface<LoggedOutUserInfo> =
   tShape<LoggedOutUserInfo>({ id: t.String, anonymous: tBool(true) });
 
-export type OldCurrentUserInfo = OldLoggedInUserInfo | LoggedOutUserInfo;
-export const oldCurrentUserInfoValidator: TUnion<OldCurrentUserInfo> = t.union([
-  oldLoggedInUserInfoValidator,
-  loggedOutUserInfoValidator,
-]);
-
 export type CurrentUserInfo = LoggedInUserInfo | LoggedOutUserInfo;
 export const currentUserInfoValidator: TUnion<CurrentUserInfo> = t.union([
   loggedInUserInfoValidator,
   loggedOutUserInfoValidator,
 ]);
 
 export type PasswordUpdate = {
   +updatedFields: {
     +password?: ?string,
   },
   +currentPassword: string,
 };
 
 export type UserListItem = {
   ...AccountUserInfo,
   +disabled?: boolean,
   +notice?: string,
   +alert?: {
     +text: string,
     +title: string,
   },
   +avatar?: ?ClientAvatar,
 };