diff --git a/lib/shared/updates/delete-account-spec.js b/lib/shared/updates/delete-account-spec.js
index 9ec2bd85f..3c96a276d 100644
--- a/lib/shared/updates/delete-account-spec.js
+++ b/lib/shared/updates/delete-account-spec.js
@@ -1,119 +1,110 @@
 // @flow
 
 import t from 'tcomb';
 
 import type { UpdateSpec } from './update-spec.js';
 import type { RawThreadInfos } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import type {
   AccountDeletionRawUpdateInfo,
   AccountDeletionUpdateData,
   AccountDeletionUpdateInfo,
 } from '../../types/update-types.js';
-import type { UserInfos } from '../../types/user-types.js';
 import { tNumber, tShape, tUserID } from '../../utils/validation-utils.js';
 
 export const deleteAccountSpec: UpdateSpec<
   AccountDeletionUpdateInfo,
   AccountDeletionRawUpdateInfo,
   AccountDeletionUpdateData,
 > = Object.freeze({
   generateOpsForThreadUpdates(
     storeThreadInfos: RawThreadInfos,
     update: AccountDeletionUpdateInfo,
   ) {
     const operations = [];
     for (const threadID in storeThreadInfos) {
       const threadInfo = storeThreadInfos[threadID];
 
       let replacedThreadInfo;
       if (threadInfo.thick) {
         const newMembers = threadInfo.members.filter(
           member => member.id !== update.deletedUserID,
         );
         if (newMembers.length < threadInfo.members.length) {
           replacedThreadInfo = {
             ...threadInfo,
             members: newMembers,
           };
         }
       } else {
         const newMembers = threadInfo.members.filter(
           member => member.id !== update.deletedUserID,
         );
         if (newMembers.length < threadInfo.members.length) {
           replacedThreadInfo = {
             ...threadInfo,
             members: newMembers,
           };
         }
       }
       if (replacedThreadInfo) {
         operations.push({
           type: 'replace',
           payload: {
             id: threadInfo.id,
             threadInfo: replacedThreadInfo,
           },
         });
       }
     }
     return operations;
   },
-  reduceUserInfos(state: UserInfos, update: AccountDeletionUpdateInfo) {
-    const { deletedUserID } = update;
-    if (!state[deletedUserID]) {
-      return state;
-    }
-    const { [deletedUserID]: deleted, ...rest } = state;
-    return rest;
-  },
   rawUpdateInfoFromRow(row: Object) {
     const content = JSON.parse(row.content);
     return {
       type: updateTypes.DELETE_ACCOUNT,
       id: row.id.toString(),
       time: row.time,
       deletedUserID: content.deletedUserID,
     };
   },
   updateContentForServerDB(data: AccountDeletionUpdateData) {
     return JSON.stringify({ deletedUserID: data.deletedUserID });
   },
   rawInfoFromData(data: AccountDeletionUpdateData, id: string) {
     return {
       type: updateTypes.DELETE_ACCOUNT,
       id,
       time: data.time,
       deletedUserID: data.deletedUserID,
     };
   },
   updateInfoFromRawInfo(info: AccountDeletionRawUpdateInfo) {
     return {
       type: updateTypes.DELETE_ACCOUNT,
       id: info.id,
       time: info.time,
       deletedUserID: info.deletedUserID,
     };
   },
   deleteCondition: new Set([
     updateTypes.DELETE_ACCOUNT,
     updateTypes.UPDATE_USER,
   ]),
   keyForUpdateData(data: AccountDeletionUpdateData) {
     return data.deletedUserID;
   },
   keyForUpdateInfo(info: AccountDeletionUpdateInfo) {
     return info.deletedUserID;
   },
   typesOfReplacedUpdatesForMatchingKey: 'all_types',
   generateOpsForUserInfoUpdates(update: AccountDeletionUpdateInfo) {
     return [{ type: 'remove_users', payload: { ids: [update.deletedUserID] } }];
   },
   infoValidator: tShape<AccountDeletionUpdateInfo>({
     type: tNumber(updateTypes.DELETE_ACCOUNT),
     id: t.String,
     time: t.Number,
     deletedUserID: tUserID,
   }),
 });
diff --git a/lib/shared/updates/update-spec.js b/lib/shared/updates/update-spec.js
index df63f3820..b0a3c1608 100644
--- a/lib/shared/updates/update-spec.js
+++ b/lib/shared/updates/update-spec.js
@@ -1,114 +1,113 @@
 // @flow
 
 import type { TType } from 'tcomb';
 
 import type { ThreadStoreOperation } from '../../ops/thread-store-ops.js';
 import type { UserStoreOperation } from '../../ops/user-store-ops.js';
 import type {
   FetchEntryInfosBase,
   RawEntryInfo,
   RawEntryInfos,
 } from '../../types/entry-types.js';
 import type {
   RawMessageInfo,
   MessageTruncationStatuses,
   FetchMessageInfosResult,
 } from '../../types/message-types.js';
 import type { RawThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
 import type {
   RawThreadInfos,
   MixedRawThreadInfos,
   LegacyRawThreadInfo,
 } from '../../types/thread-types.js';
 import type { UpdateType } from '../../types/update-types-enum.js';
 import type {
   ClientUpdateInfo,
   RawUpdateInfo,
   UpdateData,
 } from '../../types/update-types.js';
 import type {
   CurrentUserInfo,
   LoggedInUserInfo,
   UserInfos,
 } from '../../types/user-types.js';
 
 export type UpdateInfosRawData = {
   +threadInfos: MixedRawThreadInfos,
   +messageInfosResult: ?FetchMessageInfosResult,
   +calendarResult: ?FetchEntryInfosBase,
   +entryInfosResult: ?RawEntryInfos,
   +currentUserInfoResult: ?LoggedInUserInfo,
   +userInfosResult: ?UserInfos,
 };
 
 export type UpdateInfoFromRawInfoParams = {
   +data: UpdateInfosRawData,
   +rawEntryInfosByThreadID: {
     +[id: string]: $ReadOnlyArray<RawEntryInfo>,
   },
   +rawMessageInfosByThreadID: {
     +[id: string]: $ReadOnlyArray<RawMessageInfo>,
   },
 };
 
 export type UpdateTypes = 'all_types' | $ReadOnlySet<UpdateType>;
 
 export type UpdateSpec<
   UpdateInfo: ClientUpdateInfo,
   RawInfo: RawUpdateInfo,
   Data: UpdateData,
 > = {
   +generateOpsForThreadUpdates?: (
     storeThreadInfos: RawThreadInfos,
     update: UpdateInfo,
   ) => ?$ReadOnlyArray<ThreadStoreOperation>,
   +mergeEntryInfos?: (
     entryIDs: Set<string>,
     mergedEntryInfos: Array<RawEntryInfo>,
     update: UpdateInfo,
   ) => void,
   +reduceCurrentUser?: (
     state: ?CurrentUserInfo,
     update: UpdateInfo,
   ) => ?CurrentUserInfo,
-  +reduceUserInfos?: (state: UserInfos, update: UpdateInfo) => UserInfos,
   +reduceCalendarThreadFilters?: (
     filteredThreadIDs: $ReadOnlySet<string>,
     update: UpdateInfo,
   ) => $ReadOnlySet<string>,
   +getRawMessageInfos?: (update: UpdateInfo) => $ReadOnlyArray<RawMessageInfo>,
   +mergeMessageInfosAndTruncationStatuses?: (
     messageIDs: Set<string>,
     messageInfos: Array<RawMessageInfo>,
     truncationStatuses: MessageTruncationStatuses,
     update: UpdateInfo,
   ) => void,
   +rawUpdateInfoFromRow: (row: Object) => RawInfo,
   +updateContentForServerDB: (data: Data) => ?string,
   +entitiesToFetch?: (update: RawInfo) => {
     +threadID?: string,
     +detailedThreadID?: string,
     +entryID?: string,
     +currentUser?: boolean,
     +userID?: string,
   },
   +rawInfoFromData: (data: Data, id: string) => RawInfo,
   +updateInfoFromRawInfo: (
     info: RawInfo,
     params: UpdateInfoFromRawInfoParams,
   ) => ?UpdateInfo,
   +deleteCondition: ?UpdateTypes,
   +keyForUpdateData?: (data: Data) => string,
   +keyForUpdateInfo?: (info: UpdateInfo) => string,
   +typesOfReplacedUpdatesForMatchingKey: ?UpdateTypes,
   +infoValidator: TType<UpdateInfo>,
   +generateOpsForUserInfoUpdates?: (
     update: UpdateInfo,
   ) => ?$ReadOnlyArray<UserStoreOperation>,
   +getUpdatedThreadInfo?: (
     update: UpdateInfo,
     threadInfos: {
       +[string]: LegacyRawThreadInfo | RawThreadInfo,
     },
   ) => ?(LegacyRawThreadInfo | RawThreadInfo),
 };