diff --git a/lib/actions/user-actions.js b/lib/actions/user-actions.js
index 379f6ab32..b5bba2616 100644
--- a/lib/actions/user-actions.js
+++ b/lib/actions/user-actions.js
@@ -1,529 +1,529 @@
 // @flow
 
 import threadWatcher from '../shared/thread-watcher.js';
 import type {
   LogOutResult,
   LogInInfo,
   LogInResult,
   RegisterResult,
   RegisterInfo,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
   ClaimUsernameResponse,
   LogInResponse,
   LogInRequest,
 } from '../types/account-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from '../types/avatar-types.js';
 import type { RawEntryInfo, CalendarQuery } from '../types/entry-types.js';
 import type {
   RawMessageInfo,
   MessageTruncationStatuses,
 } from '../types/message-types.js';
 import type {
   GetSessionPublicKeysArgs,
   GetOlmSessionInitializationDataResponse,
 } from '../types/request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from '../types/search-types.js';
 import type {
   SessionPublicKeys,
   PreRequestUserState,
 } from '../types/session-types.js';
 import type {
   SubscriptionUpdateRequest,
   SubscriptionUpdateResult,
 } from '../types/subscription-types.js';
 import type { LegacyRawThreadInfos } from '../types/thread-types';
 import type {
   UserInfo,
   PasswordUpdate,
   LoggedOutUserInfo,
 } from '../types/user-types.js';
 import {
   extractKeyserverIDFromID,
   sortThreadIDsPerKeyserver,
   sortCalendarQueryPerKeyserver,
 } from '../utils/action-utils.js';
 import type {
   CallServerEndpoint,
   CallServerEndpointOptions,
 } from '../utils/call-server-endpoint.js';
 import { getConfig } from '../utils/config.js';
 import type { CallKeyserverEndpoint } from '../utils/keyserver-call';
 import { useKeyserverCall } from '../utils/keyserver-call.js';
 import sleep from '../utils/sleep.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 const loggedOutUserInfo: LoggedOutUserInfo = {
   anonymous: true,
 };
 
 const logOutActionTypes = Object.freeze({
   started: 'LOG_OUT_STARTED',
   success: 'LOG_OUT_SUCCESS',
   failed: 'LOG_OUT_FAILED',
 });
 const logOut =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: PreRequestUserState) => Promise<LogOutResult>) =>
   async preRequestUserState => {
     const requests: { [string]: {} } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = {};
     }
 
     let response = null;
     try {
       response = await Promise.race([
         callKeyserverEndpoint('log_out', requests),
         (async () => {
           await sleep(500);
           throw new Error('log_out took more than 500ms');
         })(),
       ]);
     } catch {}
     const currentUserInfo = response ? loggedOutUserInfo : null;
     return { currentUserInfo, preRequestUserState };
   };
 
 function useLogOut(): (input: PreRequestUserState) => Promise<LogOutResult> {
   return useKeyserverCall(logOut);
 }
 
 const claimUsernameActionTypes = Object.freeze({
   started: 'CLAIM_USERNAME_STARTED',
   success: 'CLAIM_USERNAME_SUCCESS',
   failed: 'CLAIM_USERNAME_FAILED',
 });
 const claimUsernameCallServerEndpointOptions = { timeout: 500 };
 const claimUsername =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): (() => Promise<ClaimUsernameResponse>) =>
   async () => {
     const requests = { [ashoatKeyserverID]: {} };
     const responses = await callKeyserverEndpoint('claim_username', requests, {
       ...claimUsernameCallServerEndpointOptions,
     });
     const response = responses[ashoatKeyserverID];
     return {
       message: response.message,
       signature: response.signature,
     };
   };
 
 function useClaimUsername(): () => Promise<ClaimUsernameResponse> {
   return useKeyserverCall(claimUsername);
 }
 
-const deleteAccountActionTypes = Object.freeze({
-  started: 'DELETE_ACCOUNT_STARTED',
-  success: 'DELETE_ACCOUNT_SUCCESS',
-  failed: 'DELETE_ACCOUNT_FAILED',
+const deleteKeyserverAccountActionTypes = Object.freeze({
+  started: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
+  success: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
+  failed: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
 });
-const deleteAccount =
+const deleteKeyserverAccount =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: PreRequestUserState) => Promise<LogOutResult>) =>
   async preRequestUserState => {
     const requests: { [string]: {} } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = {};
     }
 
     await callKeyserverEndpoint('delete_account', requests);
     return { currentUserInfo: loggedOutUserInfo, preRequestUserState };
   };
 
-function useDeleteAccount(): (
+function useDeleteKeyserverAccount(): (
   input: PreRequestUserState,
 ) => Promise<LogOutResult> {
-  return useKeyserverCall(deleteAccount);
+  return useKeyserverCall(deleteKeyserverAccount);
 }
 
 const registerActionTypes = Object.freeze({
   started: 'REGISTER_STARTED',
   success: 'REGISTER_SUCCESS',
   failed: 'REGISTER_FAILED',
 });
 const registerCallServerEndpointOptions = { timeout: 60000 };
 const register =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     registerInfo: RegisterInfo,
     options?: CallServerEndpointOptions,
   ) => Promise<RegisterResult>) =>
   async (registerInfo, options) => {
     const deviceTokenUpdateRequest =
       registerInfo.deviceTokenUpdateRequest[ashoatKeyserverID];
 
     const response = await callServerEndpoint(
       'create_account',
       {
         ...registerInfo,
         deviceTokenUpdateRequest,
         platformDetails: getConfig().platformDetails,
       },
       {
         ...registerCallServerEndpointOptions,
         ...options,
       },
     );
     return {
       currentUserInfo: response.currentUserInfo,
       rawMessageInfos: response.rawMessageInfos,
       threadInfos: response.cookieChange.threadInfos,
       userInfos: response.cookieChange.userInfos,
       calendarQuery: registerInfo.calendarQuery,
     };
   };
 
 function mergeUserInfos(
   ...userInfoArrays: Array<$ReadOnlyArray<UserInfo>>
 ): UserInfo[] {
   const merged: { [string]: UserInfo } = {};
   for (const userInfoArray of userInfoArrays) {
     for (const userInfo of userInfoArray) {
       merged[userInfo.id] = userInfo;
     }
   }
   const flattened = [];
   for (const id in merged) {
     flattened.push(merged[id]);
   }
   return flattened;
 }
 
 type WritableGenericMessagesResult = {
   messageInfos: RawMessageInfo[],
   truncationStatus: MessageTruncationStatuses,
   watchedIDsAtRequestTime: string[],
   currentAsOf: { [keyserverID: string]: number },
 };
 type WritableCalendarResult = {
   rawEntryInfos: RawEntryInfo[],
   calendarQuery: CalendarQuery,
 };
 
 const logInActionTypes = Object.freeze({
   started: 'LOG_IN_STARTED',
   success: 'LOG_IN_SUCCESS',
   failed: 'LOG_IN_FAILED',
 });
 const logInCallServerEndpointOptions = { timeout: 60000 };
 const logIn =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: LogInInfo) => Promise<LogInResult>) =>
   async logInInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
     const {
       logInActionSource,
       calendarQuery,
       keyserverIDs: inputKeyserverIDs,
       ...restLogInInfo
     } = logInInfo;
 
     // Eventually the list of keyservers will be fetched from the
     // identity service
     const keyserverIDs = inputKeyserverIDs ?? [ashoatKeyserverID];
 
     const watchedIDsPerKeyserver = sortThreadIDsPerKeyserver(watchedIDs);
     const calendarQueryPerKeyserver = sortCalendarQueryPerKeyserver(
       calendarQuery,
       keyserverIDs,
     );
 
     const requests: { [string]: LogInRequest } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {
         ...restLogInInfo,
         deviceTokenUpdateRequest:
           logInInfo.deviceTokenUpdateRequest[keyserverID],
         source: logInActionSource,
         watchedIDs: watchedIDsPerKeyserver[keyserverID] ?? [],
         calendarQuery: calendarQueryPerKeyserver[keyserverID],
         platformDetails: getConfig().platformDetails,
       };
     }
 
     const responses: { +[string]: LogInResponse } = await callKeyserverEndpoint(
       'log_in',
       requests,
       logInCallServerEndpointOptions,
     );
 
     const userInfosArrays = [];
 
     let threadInfos: LegacyRawThreadInfos = {};
     const calendarResult: WritableCalendarResult = {
       calendarQuery: logInInfo.calendarQuery,
       rawEntryInfos: [],
     };
     const messagesResult: WritableGenericMessagesResult = {
       messageInfos: [],
       truncationStatus: {},
       watchedIDsAtRequestTime: watchedIDs,
       currentAsOf: {},
     };
     let updatesCurrentAsOf: { +[string]: number } = {};
     for (const keyserverID in responses) {
       threadInfos = {
         ...responses[keyserverID].cookieChange.threadInfos,
         ...threadInfos,
       };
       if (responses[keyserverID].rawEntryInfos) {
         calendarResult.rawEntryInfos = calendarResult.rawEntryInfos.concat(
           responses[keyserverID].rawEntryInfos,
         );
       }
       messagesResult.messageInfos = messagesResult.messageInfos.concat(
         responses[keyserverID].rawMessageInfos,
       );
       messagesResult.truncationStatus = {
         ...messagesResult.truncationStatus,
         ...responses[keyserverID].truncationStatuses,
       };
       messagesResult.currentAsOf = {
         ...messagesResult.currentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       updatesCurrentAsOf = {
         ...updatesCurrentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       userInfosArrays.push(responses[keyserverID].userInfos);
       userInfosArrays.push(responses[keyserverID].cookieChange.userInfos);
     }
 
     const userInfos = mergeUserInfos(...userInfosArrays);
 
     return {
       threadInfos,
       currentUserInfo: responses[ashoatKeyserverID].currentUserInfo,
       calendarResult,
       messagesResult,
       userInfos,
       updatesCurrentAsOf,
       logInActionSource: logInInfo.logInActionSource,
       notAcknowledgedPolicies:
         responses[ashoatKeyserverID].notAcknowledgedPolicies,
     };
   };
 
 function useLogIn(): (input: LogInInfo) => Promise<LogInResult> {
   return useKeyserverCall(logIn);
 }
 
 const changeUserPasswordActionTypes = Object.freeze({
   started: 'CHANGE_USER_PASSWORD_STARTED',
   success: 'CHANGE_USER_PASSWORD_SUCCESS',
   failed: 'CHANGE_USER_PASSWORD_FAILED',
 });
 const changeUserPassword =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((passwordUpdate: PasswordUpdate) => Promise<void>) =>
   async passwordUpdate => {
     await callServerEndpoint('update_account', passwordUpdate);
   };
 
 const searchUsersActionTypes = Object.freeze({
   started: 'SEARCH_USERS_STARTED',
   success: 'SEARCH_USERS_SUCCESS',
   failed: 'SEARCH_USERS_FAILED',
 });
 const searchUsers =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((usernamePrefix: string) => Promise<UserSearchResult>) =>
   async usernamePrefix => {
     const response = await callServerEndpoint('search_users', {
       prefix: usernamePrefix,
     });
     return {
       userInfos: response.userInfos,
     };
   };
 
 const exactSearchUserActionTypes = Object.freeze({
   started: 'EXACT_SEARCH_USER_STARTED',
   success: 'EXACT_SEARCH_USER_SUCCESS',
   failed: 'EXACT_SEARCH_USER_FAILED',
 });
 const exactSearchUser =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((username: string) => Promise<ExactUserSearchResult>) =>
   async username => {
     const response = await callServerEndpoint('exact_search_user', {
       username,
     });
     return {
       userInfo: response.userInfo,
     };
   };
 
 const updateSubscriptionActionTypes = Object.freeze({
   started: 'UPDATE_SUBSCRIPTION_STARTED',
   success: 'UPDATE_SUBSCRIPTION_SUCCESS',
   failed: 'UPDATE_SUBSCRIPTION_FAILED',
 });
 const updateSubscription =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: SubscriptionUpdateRequest,
   ) => Promise<SubscriptionUpdateResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'update_user_subscription',
       requests,
     );
     const response = responses[keyserverID];
     return {
       threadID: input.threadID,
       subscription: response.threadSubscription,
     };
   };
 
 function useUpdateSubscription(): (
   input: SubscriptionUpdateRequest,
 ) => Promise<SubscriptionUpdateResult> {
   return useKeyserverCall(updateSubscription);
 }
 
 const setUserSettingsActionTypes = Object.freeze({
   started: 'SET_USER_SETTINGS_STARTED',
   success: 'SET_USER_SETTINGS_SUCCESS',
   failed: 'SET_USER_SETTINGS_FAILED',
 });
 
 const setUserSettings =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: UpdateUserSettingsRequest) => Promise<void>) =>
   async input => {
     const requests: { [string]: UpdateUserSettingsRequest } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = input;
     }
     await callKeyserverEndpoint('update_user_settings', requests);
   };
 
 function useSetUserSettings(): (
   input: UpdateUserSettingsRequest,
 ) => Promise<void> {
   return useKeyserverCall(setUserSettings);
 }
 
 const getSessionPublicKeys =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((data: GetSessionPublicKeysArgs) => Promise<SessionPublicKeys | null>) =>
   async data => {
     return await callServerEndpoint('get_session_public_keys', data);
   };
 
 const getOlmSessionInitializationDataActionTypes = Object.freeze({
   started: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
   success: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
   failed: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
 });
 
 const getOlmSessionInitializationData =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     options?: ?CallServerEndpointOptions,
   ) => Promise<GetOlmSessionInitializationDataResponse>) =>
   async options => {
     return await callServerEndpoint(
       'get_olm_session_initialization_data',
       {},
       options,
     );
   };
 
 const policyAcknowledgmentActionTypes = Object.freeze({
   started: 'POLICY_ACKNOWLEDGMENT_STARTED',
   success: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
   failed: 'POLICY_ACKNOWLEDGMENT_FAILED',
 });
 const policyAcknowledgment =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((policyRequest: PolicyAcknowledgmentRequest) => Promise<void>) =>
   async policyRequest => {
     await callServerEndpoint('policy_acknowledgment', policyRequest);
   };
 
 const updateUserAvatarActionTypes = Object.freeze({
   started: 'UPDATE_USER_AVATAR_STARTED',
   success: 'UPDATE_USER_AVATAR_SUCCESS',
   failed: 'UPDATE_USER_AVATAR_FAILED',
 });
 const updateUserAvatar =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     avatarDBContent: UpdateUserAvatarRequest,
   ) => Promise<UpdateUserAvatarResponse>) =>
   async avatarDBContent => {
     const { updates }: UpdateUserAvatarResponse = await callServerEndpoint(
       'update_user_avatar',
       avatarDBContent,
     );
     return { updates };
   };
 
 const resetUserStateActionType = 'RESET_USER_STATE';
 
 const setAccessTokenActionType = 'SET_ACCESS_TOKEN';
 
 export {
   changeUserPasswordActionTypes,
   changeUserPassword,
   claimUsernameActionTypes,
   useClaimUsername,
-  useDeleteAccount,
-  deleteAccountActionTypes,
+  useDeleteKeyserverAccount,
+  deleteKeyserverAccountActionTypes,
   getSessionPublicKeys,
   getOlmSessionInitializationDataActionTypes,
   getOlmSessionInitializationData,
   mergeUserInfos,
   logIn as logInRawAction,
   useLogIn,
   logInActionTypes,
   useLogOut,
   logOutActionTypes,
   register,
   registerActionTypes,
   searchUsers,
   searchUsersActionTypes,
   exactSearchUser,
   exactSearchUserActionTypes,
   useSetUserSettings,
   setUserSettingsActionTypes,
   useUpdateSubscription,
   updateSubscriptionActionTypes,
   policyAcknowledgment,
   policyAcknowledgmentActionTypes,
   updateUserAvatarActionTypes,
   updateUserAvatar,
   resetUserStateActionType,
   setAccessTokenActionType,
 };
diff --git a/lib/reducers/calendar-filters-reducer.js b/lib/reducers/calendar-filters-reducer.js
index f1beb3fde..07274ecb6 100644
--- a/lib/reducers/calendar-filters-reducer.js
+++ b/lib/reducers/calendar-filters-reducer.js
@@ -1,180 +1,180 @@
 // @flow
 
 import {
   updateCalendarCommunityFilter,
   clearCalendarCommunityFilter,
 } from '../actions/community-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   newThreadActionTypes,
   joinThreadActionTypes,
   leaveThreadActionTypes,
   deleteThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
 } from '../actions/user-actions.js';
 import {
   filteredThreadIDs,
   nonThreadCalendarFilters,
   nonExcludeDeletedCalendarFilters,
 } from '../selectors/calendar-filter-selectors.js';
 import { threadInFilterList } from '../shared/thread-utils.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import {
   type CalendarFilter,
   defaultCalendarFilters,
   updateCalendarThreadFilter,
   clearCalendarThreadFilter,
   setCalendarDeletedFilter,
   calendarThreadFilterTypes,
 } from '../types/filter-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type {
   LegacyRawThreadInfos,
   ThreadStore,
 } from '../types/thread-types.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { filterThreadIDsBelongingToCommunity } from '../utils/drawer-utils.react.js';
 
 export default function reduceCalendarFilters(
   state: $ReadOnlyArray<CalendarFilter>,
   action: BaseAction,
   threadStore: ThreadStore,
 ): $ReadOnlyArray<CalendarFilter> {
   if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return defaultCalendarFilters;
   } else if (action.type === updateCalendarThreadFilter) {
     const nonThreadFilters = nonThreadCalendarFilters(state);
     return [
       ...nonThreadFilters,
       {
         type: calendarThreadFilterTypes.THREAD_LIST,
         threadIDs: action.payload.threadIDs,
       },
     ];
   } else if (action.type === clearCalendarThreadFilter) {
     return nonThreadCalendarFilters(state);
   } else if (action.type === setCalendarDeletedFilter) {
     const otherFilters = nonExcludeDeletedCalendarFilters(state);
     if (action.payload.includeDeleted && otherFilters.length === state.length) {
       // Attempting to remove NOT_DELETED filter, but it doesn't exist
       return state;
     } else if (action.payload.includeDeleted) {
       // Removing NOT_DELETED filter
       return otherFilters;
     } else if (otherFilters.length < state.length) {
       // Attempting to add NOT_DELETED filter, but it already exists
       return state;
     } else {
       // Adding NOT_DELETED filter
       return [...state, { type: calendarThreadFilterTypes.NOT_DELETED }];
     }
   } else if (
     action.type === newThreadActionTypes.success ||
     action.type === joinThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === processUpdatesActionType
   ) {
     return updateFilterListFromUpdateInfos(
       state,
       action.payload.updatesResult.newUpdates,
     );
   } else if (action.type === incrementalStateSyncActionType) {
     return updateFilterListFromUpdateInfos(
       state,
       action.payload.updatesResult.newUpdates,
     );
   } else if (action.type === fullStateSyncActionType) {
     return removeDeletedThreadIDsFromFilterList(
       state,
       action.payload.threadInfos,
     );
   } else if (action.type === updateCalendarCommunityFilter) {
     const nonThreadFilters = nonThreadCalendarFilters(state);
 
     const threadIDs = Array.from(
       filterThreadIDsBelongingToCommunity(
         action.payload,
         threadStore.threadInfos,
       ),
     );
     return [
       ...nonThreadFilters,
       {
         type: calendarThreadFilterTypes.THREAD_LIST,
         threadIDs,
       },
     ];
   } else if (action.type === clearCalendarCommunityFilter) {
     const nonThreadFilters = nonThreadCalendarFilters(state);
     return nonThreadFilters;
   }
   return state;
 }
 
 function updateFilterListFromUpdateInfos(
   state: $ReadOnlyArray<CalendarFilter>,
   updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
 ): $ReadOnlyArray<CalendarFilter> {
   const currentlyFilteredIDs: ?$ReadOnlySet<string> = filteredThreadIDs(state);
   if (!currentlyFilteredIDs) {
     return state;
   }
   const newFilteredThreadIDs = updateInfos.reduce(
     (reducedFilteredThreadIDs, update) => {
       const { reduceCalendarThreadFilters } = updateSpecs[update.type];
       return reduceCalendarThreadFilters
         ? reduceCalendarThreadFilters(reducedFilteredThreadIDs, update)
         : reducedFilteredThreadIDs;
     },
     currentlyFilteredIDs,
   );
   if (currentlyFilteredIDs !== newFilteredThreadIDs) {
     return [
       ...nonThreadCalendarFilters(state),
       { type: 'threads', threadIDs: [...newFilteredThreadIDs] },
     ];
   }
   return state;
 }
 
 function removeDeletedThreadIDsFromFilterList(
   state: $ReadOnlyArray<CalendarFilter>,
   threadInfos: LegacyRawThreadInfos,
 ): $ReadOnlyArray<CalendarFilter> {
   const currentlyFilteredIDs = filteredThreadIDs(state);
   if (!currentlyFilteredIDs) {
     return state;
   }
   const filtered = [...currentlyFilteredIDs].filter(threadID =>
     threadInFilterList(threadInfos[threadID]),
   );
   if (filtered.length < currentlyFilteredIDs.size) {
     return [
       ...nonThreadCalendarFilters(state),
       { type: 'threads', threadIDs: filtered },
     ];
   }
   return state;
 }
diff --git a/lib/reducers/calendar-query-reducer.js b/lib/reducers/calendar-query-reducer.js
index 27bac6be6..11f35a6f7 100644
--- a/lib/reducers/calendar-query-reducer.js
+++ b/lib/reducers/calendar-query-reducer.js
@@ -1,49 +1,49 @@
 // @flow
 
 import { updateCalendarQueryActionTypes } from '../actions/entry-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
 } from '../actions/user-actions.js';
 import { defaultCalendarQuery } from '../types/entry-types.js';
 import type { CalendarQuery } from '../types/entry-types.js';
 import { type BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { getConfig } from '../utils/config.js';
 
 function reduceCalendarQuery(
   state: CalendarQuery,
   action: BaseAction,
 ): CalendarQuery {
   if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return defaultCalendarQuery(getConfig().platformDetails.platform);
   } else if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success
   ) {
     return action.payload.calendarResult.calendarQuery;
   } else if (
     action.type === registerActionTypes.success ||
     action.type === updateCalendarQueryActionTypes.success ||
     action.type === fullStateSyncActionType ||
     action.type === incrementalStateSyncActionType
   ) {
     return action.payload.calendarQuery;
   }
 
   return state;
 }
 
 export { reduceCalendarQuery };
diff --git a/lib/reducers/data-loaded-reducer.js b/lib/reducers/data-loaded-reducer.js
index 8794e1a93..983b12c7b 100644
--- a/lib/reducers/data-loaded-reducer.js
+++ b/lib/reducers/data-loaded-reducer.js
@@ -1,34 +1,34 @@
 // @flow
 
 import { setDataLoadedActionType } from '../actions/client-db-store-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
 } from '../actions/user-actions.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 
 export default function reduceDataLoaded(
   state: boolean,
   action: BaseAction,
 ): boolean {
   if (action.type === setDataLoadedActionType) {
     return action.payload.dataLoaded;
   } else if (action.type === logInActionTypes.success) {
     return true;
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.currentUserInfo &&
     action.payload.sessionChange.currentUserInfo.anonymous
   ) {
     return false;
   } else if (
     action.type === logOutActionTypes.started ||
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success
+    action.type === deleteKeyserverAccountActionTypes.success
   ) {
     return false;
   }
   return state;
 }
diff --git a/lib/reducers/draft-reducer.js b/lib/reducers/draft-reducer.js
index 4939bc145..2028e04e0 100644
--- a/lib/reducers/draft-reducer.js
+++ b/lib/reducers/draft-reducer.js
@@ -1,91 +1,91 @@
 // @flow
 
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import {
   moveDraftActionType,
   updateDraftActionType,
 } from '../actions/draft-actions.js';
 import {
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logOutActionTypes,
 } from '../actions/user-actions.js';
 import type { DraftStore, DraftStoreOperation } from '../types/draft-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 
 type ReduceDraftStoreResult = {
   +draftStoreOperations: $ReadOnlyArray<DraftStoreOperation>,
   +draftStore: DraftStore,
 };
 
 function reduceDraftStore(
   draftStore: DraftStore,
   action: BaseAction,
 ): ReduceDraftStoreResult {
   if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return {
       draftStoreOperations: [{ type: 'remove_all' }],
       draftStore: { drafts: {} },
     };
   } else if (action.type === updateDraftActionType) {
     const { key, text } = action.payload;
 
     const draftStoreOperations = [
       {
         type: 'update',
         payload: { key, text },
       },
     ];
     return {
       draftStoreOperations,
       draftStore: {
         ...draftStore,
         drafts: {
           ...draftStore.drafts,
           [key]: text,
         },
       },
     };
   } else if (action.type === moveDraftActionType) {
     const { oldKey, newKey } = action.payload;
 
     const draftStoreOperations = [
       {
         type: 'move',
         payload: { oldKey, newKey },
       },
     ];
 
     const { [oldKey]: text, ...draftsWithoutOldKey } = draftStore.drafts;
     return {
       draftStoreOperations,
       draftStore: {
         ...draftStore,
         drafts: {
           ...draftsWithoutOldKey,
           [newKey]: text,
         },
       },
     };
   } else if (action.type === setClientDBStoreActionType) {
     const drafts: { [string]: string } = {};
     for (const dbDraftInfo of action.payload.drafts) {
       drafts[dbDraftInfo.key] = dbDraftInfo.text;
     }
     return {
       draftStoreOperations: [],
       draftStore: {
         ...draftStore,
         drafts: drafts,
       },
     };
   }
   return { draftStore, draftStoreOperations: [] };
 }
 
 export { reduceDraftStore };
diff --git a/lib/reducers/enabled-apps-reducer.js b/lib/reducers/enabled-apps-reducer.js
index 7235b025f..f8c8b91dc 100644
--- a/lib/reducers/enabled-apps-reducer.js
+++ b/lib/reducers/enabled-apps-reducer.js
@@ -1,38 +1,38 @@
 // @flow
 
 import {
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logOutActionTypes,
 } from '../actions/user-actions.js';
 import type { EnabledApps } from '../types/enabled-apps.js';
 import {
   defaultEnabledApps,
   defaultWebEnabledApps,
 } from '../types/enabled-apps.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 
 export const enableAppActionType = 'ENABLE_APP';
 export const disableAppActionType = 'DISABLE_APP';
 
 export default function reduceEnabledApps(
   state: EnabledApps,
   action: BaseAction,
 ): EnabledApps {
   if (action.type === enableAppActionType && action.payload === 'calendar') {
     return { ...state, calendar: true };
   } else if (
     action.type === disableAppActionType &&
     action.payload === 'calendar'
   ) {
     return { ...state, calendar: false };
   } else if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return process.env.BROWSER ? defaultWebEnabledApps : defaultEnabledApps;
   }
   return state;
 }
diff --git a/lib/reducers/entry-reducer.js b/lib/reducers/entry-reducer.js
index 17cf28ad3..605c1a0a2 100644
--- a/lib/reducers/entry-reducer.js
+++ b/lib/reducers/entry-reducer.js
@@ -1,673 +1,673 @@
 // @flow
 
 import invariant from 'invariant';
 import _filter from 'lodash/fp/filter.js';
 import _flow from 'lodash/fp/flow.js';
 import _groupBy from 'lodash/fp/groupBy.js';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _map from 'lodash/fp/map.js';
 import _mapKeys from 'lodash/fp/mapKeys.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _omitBy from 'lodash/fp/omitBy.js';
 import _pickBy from 'lodash/fp/pickBy.js';
 import _sortBy from 'lodash/fp/sortBy.js';
 import _union from 'lodash/fp/union.js';
 
 import {
   fetchEntriesActionTypes,
   updateCalendarQueryActionTypes,
   createLocalEntryActionType,
   createEntryActionTypes,
   saveEntryActionTypes,
   concurrentModificationResetActionType,
   deleteEntryActionTypes,
   fetchRevisionsForEntryActionTypes,
   restoreEntryActionTypes,
 } from '../actions/entry-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   deleteThreadActionTypes,
   leaveThreadActionTypes,
   joinThreadActionTypes,
   changeThreadSettingsActionTypes,
   removeUsersFromThreadActionTypes,
   changeThreadMemberRolesActionTypes,
   newThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
 } from '../actions/user-actions.js';
 import { entryID } from '../shared/entry-utils.js';
 import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
 import { threadInFilterList } from '../shared/thread-utils.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import type { RawEntryInfo, EntryStore } from '../types/entry-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { type ClientEntryInconsistencyReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   processServerRequestsActionType,
 } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { type LegacyRawThreadInfos } from '../types/thread-types.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { dateString } from '../utils/date-utils.js';
 import { values } from '../utils/objects.js';
 
 function daysToEntriesFromEntryInfos(
   entryInfos: $ReadOnlyArray<RawEntryInfo>,
 ): { [day: string]: string[] } {
   return _flow(
     _sortBy((['id', 'localID']: $ReadOnlyArray<string>)),
     _groupBy((entryInfo: RawEntryInfo) =>
       dateString(entryInfo.year, entryInfo.month, entryInfo.day),
     ),
     _mapValues((entryInfoGroup: $ReadOnlyArray<RawEntryInfo>) =>
       _map(entryID)(entryInfoGroup),
     ),
   )([...entryInfos]);
 }
 
 function filterExistingDaysToEntriesWithNewEntryInfos(
   oldDaysToEntries: { +[id: string]: string[] },
   newEntryInfos: { +[id: string]: RawEntryInfo },
 ) {
   return _mapValues((entryIDs: string[]) =>
     _filter((id: string) => newEntryInfos[id])(entryIDs),
   )(oldDaysToEntries);
 }
 
 function mergeNewEntryInfos(
   currentEntryInfos: { +[id: string]: RawEntryInfo },
   currentDaysToEntries: ?{ +[day: string]: string[] },
   newEntryInfos: $ReadOnlyArray<RawEntryInfo>,
   threadInfos: LegacyRawThreadInfos,
 ) {
   const mergedEntryInfos: { [string]: RawEntryInfo } = {};
   let someEntryUpdated = false;
 
   for (const rawEntryInfo of newEntryInfos) {
     const serverID = rawEntryInfo.id;
     invariant(serverID, 'new entryInfos should have serverID');
     const currentEntryInfo = currentEntryInfos[serverID];
     let newEntryInfo;
     if (currentEntryInfo && currentEntryInfo.localID) {
       newEntryInfo = {
         id: serverID,
         // Try to preserve localIDs. This is because we use them as React
         // keys and changing React keys leads to loss of component state.
         localID: currentEntryInfo.localID,
         threadID: rawEntryInfo.threadID,
         text: rawEntryInfo.text,
         year: rawEntryInfo.year,
         month: rawEntryInfo.month,
         day: rawEntryInfo.day,
         creationTime: rawEntryInfo.creationTime,
         creatorID: rawEntryInfo.creatorID,
         deleted: rawEntryInfo.deleted,
       };
     } else {
       newEntryInfo = {
         id: serverID,
         threadID: rawEntryInfo.threadID,
         text: rawEntryInfo.text,
         year: rawEntryInfo.year,
         month: rawEntryInfo.month,
         day: rawEntryInfo.day,
         creationTime: rawEntryInfo.creationTime,
         creatorID: rawEntryInfo.creatorID,
         deleted: rawEntryInfo.deleted,
       };
     }
 
     if (_isEqual(currentEntryInfo)(newEntryInfo)) {
       mergedEntryInfos[serverID] = currentEntryInfo;
     } else {
       mergedEntryInfos[serverID] = newEntryInfo;
       someEntryUpdated = true;
     }
   }
 
   for (const id in currentEntryInfos) {
     const newEntryInfo = mergedEntryInfos[id];
     if (!newEntryInfo) {
       mergedEntryInfos[id] = currentEntryInfos[id];
     }
   }
 
   for (const id in mergedEntryInfos) {
     const entryInfo = mergedEntryInfos[id];
     if (!threadInFilterList(threadInfos[entryInfo.threadID])) {
       someEntryUpdated = true;
       delete mergedEntryInfos[id];
     }
   }
 
   const daysToEntries =
     !currentDaysToEntries || someEntryUpdated
       ? daysToEntriesFromEntryInfos(values(mergedEntryInfos))
       : currentDaysToEntries;
   const entryInfos = someEntryUpdated ? mergedEntryInfos : currentEntryInfos;
   return [entryInfos, daysToEntries];
 }
 
 function reduceEntryInfos(
   entryStore: EntryStore,
   action: BaseAction,
   newThreadInfos: LegacyRawThreadInfos,
 ): [EntryStore, $ReadOnlyArray<ClientEntryInconsistencyReportCreationRequest>] {
   const { entryInfos, daysToEntries, lastUserInteractionCalendar } = entryStore;
   if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success
   ) {
     const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
     const newEntryInfos = _pickBy(
       (entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
     )(entryInfos);
     const newLastUserInteractionCalendar =
       action.type === logOutActionTypes.success ||
-      action.type === deleteAccountActionTypes.success
+      action.type === deleteKeyserverAccountActionTypes.success
         ? 0
         : lastUserInteractionCalendar;
     if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
       return [
         {
           entryInfos,
           daysToEntries,
           lastUserInteractionCalendar: newLastUserInteractionCalendar,
         },
         [],
       ];
     }
     const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
       daysToEntries,
       newEntryInfos,
     );
     return [
       {
         entryInfos: newEntryInfos,
         daysToEntries: newDaysToEntries,
         lastUserInteractionCalendar: newLastUserInteractionCalendar,
       },
       [],
     ];
   } else if (action.type === setNewSessionActionType) {
     const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
     const newEntryInfos = _pickBy(
       (entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
     )(entryInfos);
     const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
       daysToEntries,
       newEntryInfos,
     );
     const newLastUserInteractionCalendar = action.payload.sessionChange
       .cookieInvalidated
       ? 0
       : lastUserInteractionCalendar;
     if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
       return [
         {
           entryInfos,
           daysToEntries,
           lastUserInteractionCalendar: newLastUserInteractionCalendar,
         },
         [],
       ];
     }
     return [
       {
         entryInfos: newEntryInfos,
         daysToEntries: newDaysToEntries,
         lastUserInteractionCalendar: newLastUserInteractionCalendar,
       },
       [],
     ];
   } else if (action.type === fetchEntriesActionTypes.success) {
     const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
       entryInfos,
       daysToEntries,
       action.payload.rawEntryInfos,
       newThreadInfos,
     );
     return [
       {
         entryInfos: updatedEntryInfos,
         daysToEntries: updatedDaysToEntries,
         lastUserInteractionCalendar,
       },
       [],
     ];
   } else if (
     action.type === updateCalendarQueryActionTypes.started &&
     action.payload &&
     action.payload.calendarQuery
   ) {
     return [
       {
         entryInfos,
         daysToEntries,
         lastUserInteractionCalendar: Date.now(),
       },
       [],
     ];
   } else if (action.type === updateCalendarQueryActionTypes.success) {
     const newLastUserInteractionCalendar = action.payload.calendarQuery
       ? Date.now()
       : lastUserInteractionCalendar;
     const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
       entryInfos,
       daysToEntries,
       action.payload.rawEntryInfos,
       newThreadInfos,
     );
     const deletionMarkedEntryInfos = markDeletedEntries(
       updatedEntryInfos,
       action.payload.deletedEntryIDs,
     );
     return [
       {
         entryInfos: deletionMarkedEntryInfos,
         daysToEntries: updatedDaysToEntries,
         lastUserInteractionCalendar: newLastUserInteractionCalendar,
       },
       [],
     ];
   } else if (action.type === createLocalEntryActionType) {
     const entryInfo = action.payload;
     const localID = entryInfo.localID;
     invariant(localID, 'localID should be set in CREATE_LOCAL_ENTRY');
     const newEntryInfos = {
       ...entryInfos,
       [(localID: string)]: entryInfo,
     };
     const dayString = dateString(
       entryInfo.year,
       entryInfo.month,
       entryInfo.day,
     );
     const newDaysToEntries = {
       ...daysToEntries,
       [dayString]: _union([localID])(daysToEntries[dayString]),
     };
     return [
       {
         entryInfos: newEntryInfos,
         daysToEntries: newDaysToEntries,
         lastUserInteractionCalendar: Date.now(),
       },
       [],
     ];
   } else if (action.type === createEntryActionTypes.success) {
     const localID = action.payload.localID;
     const serverID = action.payload.entryID;
     // If an entry with this serverID already got into the store somehow
     // (likely through an unrelated request), we need to dedup them.
     let rekeyedEntryInfos;
     if (entryInfos[serverID]) {
       // It's fair to assume the serverID entry is newer than the localID
       // entry, and this probably won't happen often, so for now we can just
       // keep the serverID entry.
       rekeyedEntryInfos = _omitBy(
         (candidate: RawEntryInfo) =>
           !candidate.id && candidate.localID === localID,
       )(entryInfos);
     } else if (entryInfos[localID]) {
       rekeyedEntryInfos = _mapKeys((oldKey: string) =>
         entryInfos[oldKey].localID === localID ? serverID : oldKey,
       )(entryInfos);
     } else {
       // This happens if the entry is deauthorized before it's saved
       return [entryStore, []];
     }
 
     const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
       rekeyedEntryInfos,
       null,
       mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
       newThreadInfos,
     );
 
     return [
       {
         entryInfos: updatedEntryInfos,
         daysToEntries: updatedDaysToEntries,
         lastUserInteractionCalendar: Date.now(),
       },
       [],
     ];
   } else if (action.type === saveEntryActionTypes.success) {
     const serverID = action.payload.entryID;
     if (
       !entryInfos[serverID] ||
       !threadInFilterList(newThreadInfos[entryInfos[serverID].threadID])
     ) {
       // This happens if the entry is deauthorized before it's saved
       return [entryStore, []];
     }
 
     const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
       entryInfos,
       daysToEntries,
       mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
       newThreadInfos,
     );
 
     return [
       {
         entryInfos: updatedEntryInfos,
         daysToEntries: updatedDaysToEntries,
         lastUserInteractionCalendar: Date.now(),
       },
       [],
     ];
   } else if (action.type === concurrentModificationResetActionType) {
     const { payload } = action;
     if (
       !entryInfos[payload.id] ||
       !threadInFilterList(newThreadInfos[entryInfos[payload.id].threadID])
     ) {
       // This happens if the entry is deauthorized before it's restored
       return [entryStore, []];
     }
     const newEntryInfos = {
       ...entryInfos,
       [payload.id]: {
         ...entryInfos[payload.id],
         text: payload.dbText,
       },
     };
     return [
       {
         entryInfos: newEntryInfos,
         daysToEntries,
         lastUserInteractionCalendar,
       },
       [],
     ];
   } else if (action.type === deleteEntryActionTypes.started) {
     const payload = action.payload;
     const id =
       payload.serverID && entryInfos[payload.serverID]
         ? payload.serverID
         : payload.localID;
     invariant(id, 'either serverID or localID should be set');
     const newEntryInfos = {
       ...entryInfos,
       [(id: string)]: {
         ...entryInfos[id],
         deleted: true,
       },
     };
     return [
       {
         entryInfos: newEntryInfos,
         daysToEntries,
         lastUserInteractionCalendar: Date.now(),
       },
       [],
     ];
   } else if (action.type === deleteEntryActionTypes.success) {
     const { payload } = action;
     if (payload) {
       const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
         entryInfos,
         daysToEntries,
         mergeUpdateEntryInfos([], payload.updatesResult.viewerUpdates),
         newThreadInfos,
       );
       return [
         {
           entryInfos: updatedEntryInfos,
           daysToEntries: updatedDaysToEntries,
           lastUserInteractionCalendar,
         },
         [],
       ];
     }
   } else if (action.type === fetchRevisionsForEntryActionTypes.success) {
     const id = action.payload.entryID;
     if (
       !entryInfos[id] ||
       !threadInFilterList(newThreadInfos[entryInfos[id].threadID])
     ) {
       // This happens if the entry is deauthorized before it's restored
       return [entryStore, []];
     }
     // Make sure the entry is in sync with its latest revision
     const newEntryInfos = {
       ...entryInfos,
       [id]: {
         ...entryInfos[id],
         text: action.payload.text,
         deleted: action.payload.deleted,
       },
     };
     return [
       {
         entryInfos: newEntryInfos,
         daysToEntries,
         lastUserInteractionCalendar,
       },
       [],
     ];
   } else if (action.type === restoreEntryActionTypes.success) {
     const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
       entryInfos,
       daysToEntries,
       mergeUpdateEntryInfos([], action.payload.updatesResult.viewerUpdates),
       newThreadInfos,
     );
     return [
       {
         entryInfos: updatedEntryInfos,
         daysToEntries: updatedDaysToEntries,
         lastUserInteractionCalendar: Date.now(),
       },
       [],
     ];
   } else if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success
   ) {
     const { calendarResult } = action.payload;
     if (calendarResult) {
       const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
         entryInfos,
         daysToEntries,
         calendarResult.rawEntryInfos,
         newThreadInfos,
       );
       return [
         {
           entryInfos: updatedEntryInfos,
           daysToEntries: updatedDaysToEntries,
           lastUserInteractionCalendar,
         },
         [],
       ];
     }
   } else if (action.type === incrementalStateSyncActionType) {
     const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
       entryInfos,
       daysToEntries,
       mergeUpdateEntryInfos(
         action.payload.deltaEntryInfos,
         action.payload.updatesResult.newUpdates,
       ),
       newThreadInfos,
     );
     const deletionMarkedEntryInfos = markDeletedEntries(
       updatedEntryInfos,
       action.payload.deletedEntryIDs,
     );
     return [
       {
         entryInfos: deletionMarkedEntryInfos,
         daysToEntries: updatedDaysToEntries,
         lastUserInteractionCalendar,
       },
       [],
     ];
   } else if (
     action.type === processUpdatesActionType ||
     action.type === joinThreadActionTypes.success ||
     action.type === newThreadActionTypes.success
   ) {
     const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
       entryInfos,
       daysToEntries,
       mergeUpdateEntryInfos([], action.payload.updatesResult.newUpdates),
       newThreadInfos,
     );
     return [
       {
         entryInfos: updatedEntryInfos,
         daysToEntries: updatedDaysToEntries,
         lastUserInteractionCalendar,
       },
       [],
     ];
   } else if (action.type === fullStateSyncActionType) {
     const [updatedEntryInfos, updatedDaysToEntries] = mergeNewEntryInfos(
       entryInfos,
       daysToEntries,
       action.payload.rawEntryInfos,
       newThreadInfos,
     );
     return [
       {
         entryInfos: updatedEntryInfos,
         daysToEntries: updatedDaysToEntries,
         lastUserInteractionCalendar,
       },
       [],
     ];
   } else if (
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success
   ) {
     const authorizedThreadInfos = _pickBy(threadInFilterList)(newThreadInfos);
     const newEntryInfos = _pickBy(
       (entry: RawEntryInfo) => authorizedThreadInfos[entry.threadID],
     )(entryInfos);
     if (Object.keys(newEntryInfos).length === Object.keys(entryInfos).length) {
       return [entryStore, []];
     }
     const newDaysToEntries = filterExistingDaysToEntriesWithNewEntryInfos(
       daysToEntries,
       newEntryInfos,
     );
     return [
       {
         entryInfos: newEntryInfos,
         daysToEntries: newDaysToEntries,
         lastUserInteractionCalendar,
       },
       [],
     ];
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (!checkStateRequest || !checkStateRequest.stateChanges) {
       return [entryStore, []];
     }
     const { rawEntryInfos, deleteEntryIDs } = checkStateRequest.stateChanges;
     if (!rawEntryInfos && !deleteEntryIDs) {
       return [entryStore, []];
     }
 
     const updatedEntryInfos: { [string]: RawEntryInfo } = { ...entryInfos };
     if (deleteEntryIDs) {
       for (const deleteEntryID of deleteEntryIDs) {
         delete updatedEntryInfos[deleteEntryID];
       }
     }
 
     let mergedEntryInfos: { +[string]: RawEntryInfo };
     let mergedDaysToEntries;
     if (rawEntryInfos) {
       [mergedEntryInfos, mergedDaysToEntries] = mergeNewEntryInfos(
         updatedEntryInfos,
         null,
         rawEntryInfos,
         newThreadInfos,
       );
     } else {
       mergedEntryInfos = updatedEntryInfos;
       mergedDaysToEntries = daysToEntriesFromEntryInfos(
         values(updatedEntryInfos),
       );
     }
 
     const newInconsistencies = stateSyncSpecs.entries.findStoreInconsistencies(
       action,
       entryInfos,
       mergedEntryInfos,
     );
 
     return [
       {
         entryInfos: mergedEntryInfos,
         daysToEntries: mergedDaysToEntries,
         lastUserInteractionCalendar,
       },
       newInconsistencies,
     ];
   }
   return [entryStore, []];
 }
 
 function mergeUpdateEntryInfos(
   entryInfos: $ReadOnlyArray<RawEntryInfo>,
   newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
 ): RawEntryInfo[] {
   const entryIDs = new Set(
     entryInfos.map(entryInfo => entryInfo.id).filter(Boolean),
   );
   const mergedEntryInfos = [...entryInfos];
   for (const updateInfo of newUpdates) {
     updateSpecs[updateInfo.type].mergeEntryInfos?.(
       entryIDs,
       mergedEntryInfos,
       updateInfo,
     );
   }
   return mergedEntryInfos;
 }
 
 function markDeletedEntries(
   entryInfos: { +[id: string]: RawEntryInfo },
   deletedEntryIDs: $ReadOnlyArray<string>,
 ): { +[id: string]: RawEntryInfo } {
   let result = entryInfos;
   for (const deletedEntryID of deletedEntryIDs) {
     const entryInfo = entryInfos[deletedEntryID];
     if (!entryInfo || entryInfo.deleted) {
       continue;
     }
     result = {
       ...result,
       [deletedEntryID]: {
         ...entryInfo,
         deleted: true,
       },
     };
   }
   return result;
 }
 
 export { daysToEntriesFromEntryInfos, reduceEntryInfos };
diff --git a/lib/reducers/invite-links-reducer.js b/lib/reducers/invite-links-reducer.js
index 3acffe38e..cdc5e0df9 100644
--- a/lib/reducers/invite-links-reducer.js
+++ b/lib/reducers/invite-links-reducer.js
@@ -1,74 +1,74 @@
 // @flow
 
 import {
   createOrUpdatePublicLinkActionTypes,
   disableInviteLinkLinkActionTypes,
   fetchPrimaryInviteLinkActionTypes,
 } from '../actions/link-actions.js';
 import {
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logOutActionTypes,
 } from '../actions/user-actions.js';
 import type { InviteLinksStore, CommunityLinks } from '../types/link-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 
 function reduceInviteLinks(
   state: InviteLinksStore,
   action: BaseAction,
 ): InviteLinksStore {
   if (action.type === fetchPrimaryInviteLinkActionTypes.success) {
     const links: { [string]: CommunityLinks } = {};
     for (const link of action.payload.links) {
       links[link.communityID] = {
         ...state.links[link.communityID],
         primaryLink: link,
       };
     }
     return {
       links,
     };
   } else if (action.type === createOrUpdatePublicLinkActionTypes.success) {
     const communityID = action.payload.communityID;
     return {
       ...state,
       links: {
         ...state.links,
         [communityID]: {
           ...state.links[communityID],
           primaryLink: action.payload,
         },
       },
     };
   } else if (action.type === disableInviteLinkLinkActionTypes.success) {
     const communityID = action.payload.communityID;
     const currentPrimaryLink = state.links[communityID]?.primaryLink;
     if (currentPrimaryLink?.name !== action.payload.name) {
       return state;
     }
 
     const communityLinks = {
       ...state.links[communityID],
       primaryLink: null,
     };
     return {
       ...state,
       links: {
         ...state.links,
         [communityID]: communityLinks,
       },
     };
   } else if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return {
       links: {},
     };
   }
   return state;
 }
 
 export default reduceInviteLinks;
diff --git a/lib/reducers/keyserver-reducer.js b/lib/reducers/keyserver-reducer.js
index ce87afd3c..d3770b60d 100644
--- a/lib/reducers/keyserver-reducer.js
+++ b/lib/reducers/keyserver-reducer.js
@@ -1,370 +1,370 @@
 // @flow
 
 import { unsupervisedBackgroundActionType } from './lifecycle-state-reducer.js';
 import { updateActivityActionTypes } from '../actions/activity-actions.js';
 import {
   updateLastCommunicatedPlatformDetailsActionType,
   setDeviceTokenActionTypes,
 } from '../actions/device-actions.js';
 import {
   addKeyserverActionType,
   removeKeyserverActionType,
 } from '../actions/keyserver-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   registerActionTypes,
   logInActionTypes,
   resetUserStateActionType,
 } from '../actions/user-actions.js';
 import { queueActivityUpdatesActionType } from '../types/activity-types.js';
 import type { KeyserverInfos, KeyserverStore } from '../types/keyserver-types';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
   updateConnectionStatusActionType,
   setLateResponseActionType,
   updateDisconnectedBarActionType,
 } from '../types/socket-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { processUpdatesActionType } from '../types/update-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { getConfig } from '../utils/config.js';
 import { setURLPrefix } from '../utils/url-utils.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 export default function reduceKeyserverStore(
   state: KeyserverStore,
   action: BaseAction,
 ): KeyserverStore {
   if (action.type === addKeyserverActionType) {
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [action.payload.keyserverAdminUserID]: {
           ...action.payload.newKeyserverInfo,
         },
       },
     };
   } else if (action.type === removeKeyserverActionType) {
     const { [action.payload.keyserverAdminUserID]: _, ...rest } =
       state.keyserverInfos;
 
     return {
       ...state,
       keyserverInfos: rest,
     };
   } else if (action.type === resetUserStateActionType) {
     // this action is only dispatched on native
     const keyserverInfos = { ...state.keyserverInfos };
     for (const keyserverID in keyserverInfos) {
       const stateCookie = state.keyserverInfos[keyserverID]?.cookie;
       const cookie =
         stateCookie && stateCookie.startsWith('anonymous=')
           ? stateCookie
           : null;
       keyserverInfos[keyserverID] = { ...keyserverInfos[keyserverID], cookie };
     }
 
     return {
       ...state,
       keyserverInfos,
     };
   } else if (action.type === setNewSessionActionType) {
     const { keyserverID } = action.payload;
     if (action.payload.sessionChange.cookie !== undefined) {
       state = {
         ...state,
         keyserverInfos: {
           ...state.keyserverInfos,
           [keyserverID]: {
             ...state.keyserverInfos[keyserverID],
             cookie: action.payload.sessionChange.cookie,
           },
         },
       };
     }
     if (action.payload.sessionChange.cookieInvalidated) {
       state = {
         ...state,
         keyserverInfos: {
           ...state.keyserverInfos,
           [keyserverID]: {
             ...state.keyserverInfos[keyserverID],
             connection: {
               ...state.keyserverInfos[keyserverID].connection,
               queuedActivityUpdates: [],
             },
           },
         },
       };
     }
     return state;
   } else if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success
   ) {
     const { updatesCurrentAsOf } = action.payload;
     let keyserverInfos = { ...state.keyserverInfos };
     for (const keyserverID in updatesCurrentAsOf) {
       keyserverInfos = {
         ...keyserverInfos,
         [keyserverID]: {
           ...keyserverInfos[keyserverID],
           updatesCurrentAsOf: updatesCurrentAsOf[keyserverID],
           lastCommunicatedPlatformDetails: getConfig().platformDetails,
         },
       };
     }
     return {
       ...state,
       keyserverInfos,
     };
   } else if (action.type === fullStateSyncActionType) {
     const { keyserverID } = action.payload;
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [keyserverID]: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf: action.payload.updatesCurrentAsOf,
         },
       },
     };
   } else if (action.type === incrementalStateSyncActionType) {
     const { keyserverID } = action.payload;
     let { deviceToken } = state.keyserverInfos[keyserverID];
     for (const update of action.payload.updatesResult.newUpdates) {
       if (
         update.type === updateTypes.BAD_DEVICE_TOKEN &&
         update.deviceToken === state.keyserverInfos[keyserverID].deviceToken
       ) {
         deviceToken = null;
         break;
       }
     }
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [keyserverID]: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf: action.payload.updatesResult.currentAsOf,
           deviceToken,
         },
       },
     };
   } else if (action.type === processUpdatesActionType) {
     const { keyserverID } = action.payload;
     const updatesCurrentAsOf = Math.max(
       action.payload.updatesResult.currentAsOf,
       state.keyserverInfos[keyserverID].updatesCurrentAsOf,
     );
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [keyserverID]: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf,
         },
       },
     };
   } else if (action.type === setURLPrefix) {
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [ashoatKeyserverID]: {
           ...state.keyserverInfos[ashoatKeyserverID],
           urlPrefix: action.payload,
         },
       },
     };
   } else if (action.type === updateLastCommunicatedPlatformDetailsActionType) {
     const { keyserverID, platformDetails } = action.payload;
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [keyserverID]: {
           ...state.keyserverInfos[keyserverID],
           lastCommunicatedPlatformDetails: platformDetails,
         },
       },
     };
   } else if (action.type === registerActionTypes.success) {
     state = {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [ashoatKeyserverID]: {
           ...state.keyserverInfos[ashoatKeyserverID],
           lastCommunicatedPlatformDetails: getConfig().platformDetails,
         },
       },
     };
   } else if (action.type === updateConnectionStatusActionType) {
     const { keyserverID, status } = action.payload;
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [keyserverID]: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             status,
             lateResponses: [],
           },
         },
       },
     };
   } else if (action.type === unsupervisedBackgroundActionType) {
     const { keyserverID } = action.payload;
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [keyserverID]: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             status: 'disconnected',
             lateResponses: [],
           },
         },
       },
     };
   } else if (action.type === queueActivityUpdatesActionType) {
     const { activityUpdates, keyserverID } = action.payload;
     const oldConnection = state.keyserverInfos[keyserverID].connection;
     const connection = {
       ...oldConnection,
       queuedActivityUpdates: [
         ...oldConnection.queuedActivityUpdates.filter(existingUpdate => {
           for (const activityUpdate of activityUpdates) {
             if (
               ((existingUpdate.focus && activityUpdate.focus) ||
                 (existingUpdate.focus === false &&
                   activityUpdate.focus !== undefined)) &&
               existingUpdate.threadID === activityUpdate.threadID
             ) {
               return false;
             }
           }
           return true;
         }),
         ...activityUpdates,
       ],
     };
 
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [keyserverID]: {
           ...state.keyserverInfos[keyserverID],
           connection,
         },
       },
     };
   } else if (action.type === updateActivityActionTypes.success) {
     const { activityUpdates } = action.payload;
     let keyserverInfos = { ...state.keyserverInfos };
     for (const keyserverID in activityUpdates) {
       const oldConnection = keyserverInfos[keyserverID].connection;
       const queuedActivityUpdates = oldConnection.queuedActivityUpdates.filter(
         activityUpdate =>
           !activityUpdates[keyserverID].includes(activityUpdate),
       );
 
       keyserverInfos = {
         ...keyserverInfos,
         [keyserverID]: {
           ...keyserverInfos[keyserverID],
           connection: { ...oldConnection, queuedActivityUpdates },
         },
       };
     }
     return {
       ...state,
       keyserverInfos,
     };
   } else if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success
+    action.type === deleteKeyserverAccountActionTypes.success
   ) {
     // We want to remove all keyservers but Ashoat's keyserver
     const oldConnection = state.keyserverInfos[ashoatKeyserverID].connection;
 
     const keyserverInfos = {
       [ashoatKeyserverID]: {
         ...state.keyserverInfos[ashoatKeyserverID],
         connection: { ...oldConnection, queuedActivityUpdates: [] },
       },
     };
 
     return {
       ...state,
       keyserverInfos,
     };
   } else if (action.type === setLateResponseActionType) {
     const { messageID, isLate, keyserverID } = action.payload;
     const lateResponsesSet = new Set<number>(
       state.keyserverInfos[keyserverID].connection.lateResponses,
     );
     if (isLate) {
       lateResponsesSet.add(messageID);
     } else {
       lateResponsesSet.delete(messageID);
     }
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [keyserverID]: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             lateResponses: [...lateResponsesSet],
           },
         },
       },
     };
   } else if (action.type === updateDisconnectedBarActionType) {
     const { keyserverID } = action.payload;
     return {
       ...state,
       keyserverInfos: {
         ...state.keyserverInfos,
         [keyserverID]: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             showDisconnectedBar: action.payload.visible,
           },
         },
       },
     };
   } else if (action.type === setDeviceTokenActionTypes.success) {
     const { deviceTokens } = action.payload;
     const keyserverInfos: { ...KeyserverInfos } = { ...state.keyserverInfos };
     for (const keyserverID in deviceTokens) {
       keyserverInfos[keyserverID] = {
         ...keyserverInfos[keyserverID],
         deviceToken: deviceTokens[keyserverID],
       };
     }
     return {
       ...state,
       keyserverInfos,
     };
   }
 
   return state;
 }
diff --git a/lib/reducers/message-reducer.js b/lib/reducers/message-reducer.js
index c9c4b605f..bc208976f 100644
--- a/lib/reducers/message-reducer.js
+++ b/lib/reducers/message-reducer.js
@@ -1,1662 +1,1662 @@
 // @flow
 
 import invariant from 'invariant';
 import _difference from 'lodash/fp/difference.js';
 import _flow from 'lodash/fp/flow.js';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import _map from 'lodash/fp/map.js';
 import _mapKeys from 'lodash/fp/mapKeys.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _omit from 'lodash/fp/omit.js';
 import _omitBy from 'lodash/fp/omitBy.js';
 import _pickBy from 'lodash/fp/pickBy.js';
 import _uniq from 'lodash/fp/uniq.js';
 
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import {
   createEntryActionTypes,
   saveEntryActionTypes,
   deleteEntryActionTypes,
   restoreEntryActionTypes,
 } from '../actions/entry-actions.js';
 import {
   toggleMessagePinActionTypes,
   fetchMessagesBeforeCursorActionTypes,
   fetchMostRecentMessagesActionTypes,
   sendTextMessageActionTypes,
   sendMultimediaMessageActionTypes,
   sendReactionMessageActionTypes,
   sendEditMessageActionTypes,
   saveMessagesActionType,
   processMessagesActionType,
   messageStorePruneActionType,
   createLocalMessageActionType,
   fetchSingleMostRecentMessagesFromThreadsActionTypes,
 } from '../actions/message-actions.js';
 import { sendMessageReportActionTypes } from '../actions/message-report-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   changeThreadSettingsActionTypes,
   deleteThreadActionTypes,
   leaveThreadActionTypes,
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
   changeThreadMemberRolesActionTypes,
   joinThreadActionTypes,
 } from '../actions/thread-actions.js';
 import { updateMultimediaMessageMediaActionType } from '../actions/upload-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
 } from '../actions/user-actions.js';
 import {
   messageStoreOpsHandlers,
   type MessageStoreOperation,
   type ReplaceMessageOperation,
 } from '../ops/message-store-ops.js';
 import { pendingToRealizedThreadIDsSelector } from '../selectors/thread-selectors.js';
 import {
   messageID,
   sortMessageInfoList,
   sortMessageIDs,
   mergeThreadMessageInfos,
   findNewestMessageTimePerKeyserver,
 } from '../shared/message-utils.js';
 import {
   threadHasPermission,
   threadInChatList,
   threadIsPending,
 } from '../shared/thread-utils.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import { unshimMessageInfos } from '../shared/unshim-utils.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import type { Media, Image } from '../types/media-types.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import {
   type RawMessageInfo,
   type LocalMessageInfo,
   type MessageStore,
   type MessageTruncationStatus,
   type MessageTruncationStatuses,
   messageTruncationStatus,
   defaultNumberPerThread,
   type ThreadMessageInfo,
 } from '../types/message-types.js';
 import type { RawImagesMessageInfo } from '../types/messages/images.js';
 import type { RawMediaMessageInfo } from '../types/messages/media.js';
 import { type BaseAction } from '../types/redux-types.js';
 import { processServerRequestsActionType } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
 import type {
   LegacyRawThreadInfo,
   LegacyRawThreadInfos,
 } from '../types/thread-types.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { translateClientDBThreadMessageInfos } from '../utils/message-ops-utils.js';
 
 const _mapValuesWithKeys = _mapValues.convert({ cap: false });
 
 // Input must already be ordered!
 function mapThreadsToMessageIDsFromOrderedMessageInfos(
   orderedMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 ): { [threadID: string]: string[] } {
   const threadsToMessageIDs: { [threadID: string]: string[] } = {};
   for (const messageInfo of orderedMessageInfos) {
     const key = messageID(messageInfo);
     if (!threadsToMessageIDs[messageInfo.threadID]) {
       threadsToMessageIDs[messageInfo.threadID] = [key];
     } else {
       threadsToMessageIDs[messageInfo.threadID].push(key);
     }
   }
   return threadsToMessageIDs;
 }
 
 function isThreadWatched(
   threadID: string,
   threadInfo: ?LegacyRawThreadInfo,
   watchedIDs: $ReadOnlyArray<string>,
 ) {
   return (
     threadIsPending(threadID) ||
     (threadInfo &&
       threadHasPermission(threadInfo, threadPermissions.VISIBLE) &&
       (threadInChatList(threadInfo) || watchedIDs.includes(threadID)))
   );
 }
 
 const newThread = (): ThreadMessageInfo => ({
   messageIDs: [],
   startReached: false,
 });
 
 type FreshMessageStoreResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 function freshMessageStore(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   truncationStatus: { [threadID: string]: MessageTruncationStatus },
   currentAsOf: { +[keyserverID: string]: number },
   threadInfos: LegacyRawThreadInfos,
 ): FreshMessageStoreResult {
   const unshimmed = unshimMessageInfos(messageInfos);
   const orderedMessageInfos = sortMessageInfoList(unshimmed);
   const messages = _keyBy(messageID)(orderedMessageInfos);
 
   const messageStoreReplaceOperations = orderedMessageInfos.map(
     messageInfo => ({
       type: 'replace',
       payload: { id: messageID(messageInfo), messageInfo },
     }),
   );
 
   const threadsToMessageIDs =
     mapThreadsToMessageIDsFromOrderedMessageInfos(orderedMessageInfos);
   const threads = _mapValuesWithKeys(
     (messageIDs: string[], threadID: string) => ({
       ...newThread(),
       messageIDs,
       startReached:
         truncationStatus[threadID] === messageTruncationStatus.EXHAUSTIVE,
     }),
   )(threadsToMessageIDs);
   const watchedIDs = threadWatcher.getWatchedIDs();
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (
       threads[threadID] ||
       !isThreadWatched(threadID, threadInfo, watchedIDs)
     ) {
       continue;
     }
     threads[threadID] = newThread();
   }
 
   const messageStoreOperations = [
     { type: 'remove_all' },
     {
       type: 'remove_all_threads',
     },
     {
       type: 'replace_threads',
       payload: { threads },
     },
     ...messageStoreReplaceOperations,
   ];
 
   return {
     messageStoreOperations,
     messageStore: {
       messages,
       threads,
       local: {},
       currentAsOf,
     },
   };
 }
 
 type ReassignmentResult = {
   +messageStoreOperations: MessageStoreOperation[],
   +messageStore: MessageStore,
   +reassignedThreadIDs: string[],
 };
 
 function reassignMessagesToRealizedThreads(
   messageStore: MessageStore,
   threadInfos: LegacyRawThreadInfos,
 ): ReassignmentResult {
   const pendingToRealizedThreadIDs =
     pendingToRealizedThreadIDsSelector(threadInfos);
 
   const messageStoreOperations: MessageStoreOperation[] = [];
   const messages: { [string]: RawMessageInfo } = {};
   for (const storeMessageID in messageStore.messages) {
     const message = messageStore.messages[storeMessageID];
     const newThreadID = pendingToRealizedThreadIDs.get(message.threadID);
 
     messages[storeMessageID] = newThreadID
       ? {
           ...message,
           threadID: newThreadID,
           time: threadInfos[newThreadID]?.creationTime ?? message.time,
         }
       : message;
 
     if (!newThreadID) {
       continue;
     }
 
     const updateMsgOperation: ReplaceMessageOperation = {
       type: 'replace',
       payload: { id: storeMessageID, messageInfo: messages[storeMessageID] },
     };
 
     messageStoreOperations.push(updateMsgOperation);
   }
 
   const threads: { [string]: ThreadMessageInfo } = {};
   const reassignedThreadIDs = [];
   const updatedThreads: { [string]: ThreadMessageInfo } = {};
   const threadsToRemove = [];
   for (const threadID in messageStore.threads) {
     const threadMessageInfo = messageStore.threads[threadID];
     const newThreadID = pendingToRealizedThreadIDs.get(threadID);
     if (!newThreadID) {
       threads[threadID] = threadMessageInfo;
       continue;
     }
     const realizedThread = messageStore.threads[newThreadID];
     if (!realizedThread) {
       reassignedThreadIDs.push(newThreadID);
       threads[newThreadID] = threadMessageInfo;
       updatedThreads[newThreadID] = threadMessageInfo;
       threadsToRemove.push(threadID);
       continue;
     }
     threads[newThreadID] = mergeThreadMessageInfos(
       threadMessageInfo,
       realizedThread,
       messages,
     );
     updatedThreads[newThreadID] = threads[newThreadID];
   }
   if (threadsToRemove.length) {
     messageStoreOperations.push({
       type: 'remove_threads',
       payload: {
         ids: threadsToRemove,
       },
     });
   }
   messageStoreOperations.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   return {
     messageStoreOperations,
     messageStore: {
       ...messageStore,
       threads,
       messages,
     },
     reassignedThreadIDs,
   };
 }
 
 type MergeNewMessagesResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 // oldMessageStore is from the old state
 // newMessageInfos, truncationStatus come from server
 function mergeNewMessages(
   oldMessageStore: MessageStore,
   newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   truncationStatus: { +[threadID: string]: MessageTruncationStatus },
   threadInfos: LegacyRawThreadInfos,
 ): MergeNewMessagesResult {
   const {
     messageStoreOperations: updateWithLatestThreadInfosOps,
     messageStore: messageStoreUpdatedWithLatestThreadInfos,
     reassignedThreadIDs,
   } = updateMessageStoreWithLatestThreadInfos(oldMessageStore, threadInfos);
 
   const messageStoreAfterUpdateOps = processMessageStoreOperations(
     oldMessageStore,
     updateWithLatestThreadInfosOps,
   );
 
   const updatedMessageStore = {
     ...messageStoreUpdatedWithLatestThreadInfos,
     messages: messageStoreAfterUpdateOps.messages,
     threads: messageStoreAfterUpdateOps.threads,
   };
 
   const localIDsToServerIDs: Map<string, string> = new Map();
 
   const watchedThreadIDs = [
     ...threadWatcher.getWatchedIDs(),
     ...reassignedThreadIDs,
   ];
   const unshimmedNewMessages = unshimMessageInfos(newMessageInfos);
   const unshimmedNewMessagesOfWatchedThreads = unshimmedNewMessages.filter(
     msg =>
       isThreadWatched(
         msg.threadID,
         threadInfos[msg.threadID],
         watchedThreadIDs,
       ),
   );
   const orderedNewMessageInfos = _flow(
     _map((messageInfo: RawMessageInfo) => {
       const { id: inputID } = messageInfo;
       invariant(inputID, 'new messageInfos should have serverID');
       invariant(
         !threadIsPending(messageInfo.threadID),
         'new messageInfos should have realized thread id',
       );
       const currentMessageInfo = updatedMessageStore.messages[inputID];
       if (
         messageInfo.type === messageTypes.TEXT ||
         messageInfo.type === messageTypes.IMAGES ||
         messageInfo.type === messageTypes.MULTIMEDIA
       ) {
         const { localID: inputLocalID } = messageInfo;
         const currentLocalMessageInfo = inputLocalID
           ? updatedMessageStore.messages[inputLocalID]
           : null;
         if (currentMessageInfo && currentMessageInfo.localID) {
           // If the client already has a RawMessageInfo with this serverID, keep
           // any localID associated with the existing one. This is because we
           // use localIDs as React keys and changing React keys leads to loss of
           // component state. (The conditional below is for Flow)
           if (messageInfo.type === messageTypes.TEXT) {
             messageInfo = {
               ...messageInfo,
               localID: currentMessageInfo.localID,
             };
           } else if (messageInfo.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({
               ...messageInfo,
               localID: currentMessageInfo.localID,
             }: RawMediaMessageInfo);
           } else {
             messageInfo = ({
               ...messageInfo,
               localID: currentMessageInfo.localID,
             }: RawImagesMessageInfo);
           }
         } else if (currentLocalMessageInfo && currentLocalMessageInfo.localID) {
           // If the client has a RawMessageInfo with this localID, but not with
           // the serverID, that means the message creation succeeded but the
           // success action never got processed. We set a key in
           // localIDsToServerIDs here to fix the messageIDs for the rest of the
           // MessageStore too. (The conditional below is for Flow)
           invariant(inputLocalID, 'inputLocalID should be set');
           localIDsToServerIDs.set(inputLocalID, inputID);
           if (messageInfo.type === messageTypes.TEXT) {
             messageInfo = {
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             };
           } else if (messageInfo.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             }: RawMediaMessageInfo);
           } else {
             messageInfo = ({
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             }: RawImagesMessageInfo);
           }
         } else {
           // If neither the serverID nor the localID from the delivered
           // RawMessageInfo exists in the client store, then this message is
           // brand new to us. Ignore any localID provided by the server.
           // (The conditional below is for Flow)
           const { localID, ...rest } = messageInfo;
           if (rest.type === messageTypes.TEXT) {
             messageInfo = { ...rest };
           } else if (rest.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({ ...rest }: RawMediaMessageInfo);
           } else {
             messageInfo = ({ ...rest }: RawImagesMessageInfo);
           }
         }
       } else if (
         currentMessageInfo &&
         messageInfo.time > currentMessageInfo.time
       ) {
         // When thick threads will be introduced it will be possible for two
         // clients to create the same message (e.g. when they create the same
         // sidebar at the same time). We're going to use deterministic ids for
         // messages which should be unique within a thread and we have to find
         // a way for clients to agree which message to keep. We can't rely on
         // always choosing incoming messages nor messages from the store,
         // because a message that is in one user's store, will be send to
         // another user. One way to deal with it is to always choose a message
         // which is older, according to its timestamp. We can use this strategy
         // only for messages that can start a thread, because for other types
         // it might break the "contiguous" property of message ids (we can
         // consider selecting younger messages in that case, but for now we use
         // an invariant).
         invariant(
           messageInfo.type === messageTypes.CREATE_SIDEBAR ||
             messageInfo.type === messageTypes.CREATE_THREAD ||
             messageInfo.type === messageTypes.SIDEBAR_SOURCE,
           `Two different messages of type ${messageInfo.type} with the same ` +
             'id found',
         );
         return currentMessageInfo;
       }
       return _isEqual(messageInfo)(currentMessageInfo)
         ? currentMessageInfo
         : messageInfo;
     }),
     sortMessageInfoList,
   )(unshimmedNewMessagesOfWatchedThreads);
 
   const newMessageOps: MessageStoreOperation[] = [];
   const threadsToMessageIDs = mapThreadsToMessageIDsFromOrderedMessageInfos(
     orderedNewMessageInfos,
   );
   const oldMessageInfosToCombine = [];
   const threadsThatNeedMessageIDsResorted = [];
   const local: { [string]: LocalMessageInfo } = {};
   const updatedThreads: { [string]: ThreadMessageInfo } = {};
   const threads = _flow(
     _mapValuesWithKeys((messageIDs: string[], threadID: string) => {
       const oldThread = updatedMessageStore.threads[threadID];
       const truncate = truncationStatus[threadID];
       if (!oldThread) {
         updatedThreads[threadID] = {
           ...newThread(),
           messageIDs,
           startReached: truncate === messageTruncationStatus.EXHAUSTIVE,
         };
         return updatedThreads[threadID];
       }
       let oldMessageIDsUnchanged = true;
       const oldMessageIDs = oldThread.messageIDs.map(oldID => {
         const newID = localIDsToServerIDs.get(oldID);
         if (newID !== null && newID !== undefined) {
           oldMessageIDsUnchanged = false;
           return newID;
         }
         return oldID;
       });
       if (truncate === messageTruncationStatus.TRUNCATED) {
         // If the result set in the payload isn't contiguous with what we have
         // now, that means we need to dump what we have in the state and replace
         // it with the result set. We do this to achieve our two goals for the
         // messageStore: currentness and contiguousness.
         newMessageOps.push({
           type: 'remove_messages_for_threads',
           payload: { threadIDs: [threadID] },
         });
         updatedThreads[threadID] = {
           messageIDs,
           startReached: false,
         };
         return updatedThreads[threadID];
       }
       const oldNotInNew = _difference(oldMessageIDs)(messageIDs);
       for (const id of oldNotInNew) {
         const oldMessageInfo = updatedMessageStore.messages[id];
         invariant(oldMessageInfo, `could not find ${id} in messageStore`);
         oldMessageInfosToCombine.push(oldMessageInfo);
         const localInfo = updatedMessageStore.local[id];
         if (localInfo) {
           local[id] = localInfo;
         }
       }
       const startReached =
         oldThread.startReached ||
         truncate === messageTruncationStatus.EXHAUSTIVE;
       if (_difference(messageIDs)(oldMessageIDs).length === 0) {
         if (startReached === oldThread.startReached && oldMessageIDsUnchanged) {
           return oldThread;
         }
         updatedThreads[threadID] = {
           messageIDs: oldMessageIDs,
           startReached,
         };
         return updatedThreads[threadID];
       }
       const mergedMessageIDs = [...messageIDs, ...oldNotInNew];
       threadsThatNeedMessageIDsResorted.push(threadID);
       return {
         messageIDs: mergedMessageIDs,
         startReached,
       };
     }),
     _pickBy(thread => !!thread),
   )(threadsToMessageIDs);
 
   for (const threadID in updatedMessageStore.threads) {
     if (threads[threadID]) {
       continue;
     }
     let thread = updatedMessageStore.threads[threadID];
     const truncate = truncationStatus[threadID];
     if (truncate === messageTruncationStatus.EXHAUSTIVE) {
       thread = {
         ...thread,
         startReached: true,
       };
     }
     threads[threadID] = thread;
     updatedThreads[threadID] = thread;
 
     for (const id of thread.messageIDs) {
       const messageInfo = updatedMessageStore.messages[id];
       if (messageInfo) {
         oldMessageInfosToCombine.push(messageInfo);
       }
       const localInfo = updatedMessageStore.local[id];
       if (localInfo) {
         local[id] = localInfo;
       }
     }
   }
 
   const messages = _flow(
     sortMessageInfoList,
     _keyBy(messageID),
   )([...orderedNewMessageInfos, ...oldMessageInfosToCombine]);
 
   const newMessages = _keyBy(messageID)(orderedNewMessageInfos);
   for (const id in newMessages) {
     newMessageOps.push({
       type: 'replace',
       payload: { id, messageInfo: newMessages[id] },
     });
   }
 
   if (localIDsToServerIDs.size > 0) {
     newMessageOps.push({
       type: 'remove',
       payload: { ids: [...localIDsToServerIDs.keys()] },
     });
   }
 
   for (const threadID of threadsThatNeedMessageIDsResorted) {
     threads[threadID].messageIDs = sortMessageIDs(messages)(
       threads[threadID].messageIDs,
     );
     updatedThreads[threadID] = threads[threadID];
   }
 
   newMessageOps.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   const processedMessageStore = processMessageStoreOperations(
     updatedMessageStore,
     newMessageOps,
   );
 
   const currentAsOf: { [keyserverID: string]: number } = {};
   const newestMessageTimePerKeyserver = findNewestMessageTimePerKeyserver(
     orderedNewMessageInfos,
   );
   for (const keyserverID in newestMessageTimePerKeyserver) {
     currentAsOf[keyserverID] = Math.max(
       newestMessageTimePerKeyserver[keyserverID],
       processedMessageStore.currentAsOf[keyserverID],
     );
   }
 
   const messageStore = {
     messages: processedMessageStore.messages,
     threads: processedMessageStore.threads,
     local,
     currentAsOf: {
       ...processedMessageStore.currentAsOf,
       ...currentAsOf,
     },
   };
 
   return {
     messageStoreOperations: [
       ...updateWithLatestThreadInfosOps,
       ...newMessageOps,
     ],
     messageStore,
   };
 }
 
 type UpdateMessageStoreWithLatestThreadInfosResult = {
   +messageStoreOperations: MessageStoreOperation[],
   +messageStore: MessageStore,
   +reassignedThreadIDs: string[],
 };
 function updateMessageStoreWithLatestThreadInfos(
   messageStore: MessageStore,
   threadInfos: LegacyRawThreadInfos,
 ): UpdateMessageStoreWithLatestThreadInfosResult {
   const messageStoreOperations: MessageStoreOperation[] = [];
   const {
     messageStore: reassignedMessageStore,
     messageStoreOperations: reassignMessagesOps,
     reassignedThreadIDs,
   } = reassignMessagesToRealizedThreads(messageStore, threadInfos);
   messageStoreOperations.push(...reassignMessagesOps);
   const watchedIDs = [...threadWatcher.getWatchedIDs(), ...reassignedThreadIDs];
 
   const filteredThreads: { [string]: ThreadMessageInfo } = {};
   const threadsToRemoveMessagesFrom = [];
   const messageIDsToRemove: string[] = [];
   for (const threadID in reassignedMessageStore.threads) {
     const threadMessageInfo = reassignedMessageStore.threads[threadID];
     const threadInfo = threadInfos[threadID];
     if (isThreadWatched(threadID, threadInfo, watchedIDs)) {
       filteredThreads[threadID] = threadMessageInfo;
     } else {
       threadsToRemoveMessagesFrom.push(threadID);
       messageIDsToRemove.push(...threadMessageInfo.messageIDs);
     }
   }
 
   const updatedThreads: { [string]: ThreadMessageInfo } = {};
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (
       isThreadWatched(threadID, threadInfo, watchedIDs) &&
       !filteredThreads[threadID]
     ) {
       filteredThreads[threadID] = newThread();
       updatedThreads[threadID] = filteredThreads[threadID];
     }
   }
 
   messageStoreOperations.push({
     type: 'remove_threads',
     payload: { ids: threadsToRemoveMessagesFrom },
   });
 
   messageStoreOperations.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   messageStoreOperations.push({
     type: 'remove_messages_for_threads',
     payload: { threadIDs: threadsToRemoveMessagesFrom },
   });
 
   return {
     messageStoreOperations,
     messageStore: {
       messages: _omit(messageIDsToRemove)(reassignedMessageStore.messages),
       threads: filteredThreads,
       local: _omit(messageIDsToRemove)(reassignedMessageStore.local),
       currentAsOf: reassignedMessageStore.currentAsOf,
     },
     reassignedThreadIDs,
   };
 }
 
 function ensureRealizedThreadIDIsUsedWhenPossible<T: RawMessageInfo>(
   payload: T,
   threadInfos: LegacyRawThreadInfos,
 ): T {
   const pendingToRealizedThreadIDs =
     pendingToRealizedThreadIDsSelector(threadInfos);
   const realizedThreadID = pendingToRealizedThreadIDs.get(payload.threadID);
   return realizedThreadID
     ? { ...payload, threadID: realizedThreadID }
     : payload;
 }
 
 const { processStoreOperations: processMessageStoreOperations } =
   messageStoreOpsHandlers;
 
 type ReduceMessageStoreResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 function reduceMessageStore(
   messageStore: MessageStore,
   action: BaseAction,
   newThreadInfos: LegacyRawThreadInfos,
 ): ReduceMessageStoreResult {
   if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success
   ) {
     const messagesResult = action.payload.messagesResult;
     const { messageStoreOperations, messageStore: freshStore } =
       freshMessageStore(
         messagesResult.messageInfos,
         messagesResult.truncationStatus,
         messagesResult.currentAsOf,
         newThreadInfos,
       );
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...freshStore,
         messages: processedMessageStore.messages,
         threads: processedMessageStore.threads,
       },
     };
   } else if (action.type === incrementalStateSyncActionType) {
     if (
       action.payload.messagesResult.rawMessageInfos.length === 0 &&
       action.payload.updatesResult.newUpdates.length === 0
     ) {
       return { messageStoreOperations: [], messageStore };
     }
 
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.messagesResult.rawMessageInfos,
       action.payload.updatesResult.newUpdates,
       action.payload.messagesResult.truncationStatuses,
     );
 
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
     );
   } else if (action.type === processUpdatesActionType) {
     if (action.payload.updatesResult.newUpdates.length === 0) {
       return { messageStoreOperations: [], messageStore };
     }
 
     const messagesResult = mergeUpdatesWithMessageInfos(
       [],
       action.payload.updatesResult.newUpdates,
     );
 
     const { messageStoreOperations, messageStore: newMessageStore } =
       mergeNewMessages(
         messageStore,
         messagesResult.rawMessageInfos,
         messagesResult.truncationStatuses,
         newThreadInfos,
       );
     return {
       messageStoreOperations,
       messageStore: {
         messages: newMessageStore.messages,
         threads: newMessageStore.threads,
         local: newMessageStore.local,
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (
     action.type === fullStateSyncActionType ||
     action.type === processMessagesActionType
   ) {
     const { messagesResult } = action.payload;
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
     );
   } else if (
     action.type === fetchSingleMostRecentMessagesFromThreadsActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       action.payload.truncationStatuses,
       newThreadInfos,
     );
   } else if (
     action.type === fetchMessagesBeforeCursorActionTypes.success ||
     action.type === fetchMostRecentMessagesActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       { [action.payload.threadID]: action.payload.truncationStatus },
       newThreadInfos,
     );
   } else if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === setNewSessionActionType
   ) {
     const { messageStoreOperations, messageStore: filteredMessageStore } =
       updateMessageStoreWithLatestThreadInfos(messageStore, newThreadInfos);
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...filteredMessageStore,
         messages: processedMessageStore.messages,
         threads: processedMessageStore.threads,
       },
     };
   } else if (action.type === newThreadActionTypes.success) {
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.newMessageInfos,
       action.payload.updatesResult.newUpdates,
     );
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
     );
   } else if (action.type === sendMessageReportActionTypes.success) {
     return mergeNewMessages(
       messageStore,
       [action.payload.messageInfo],
       {
         [(action.payload.messageInfo.threadID: string)]:
           messageTruncationStatus.UNCHANGED,
       },
       newThreadInfos,
     );
   } else if (action.type === registerActionTypes.success) {
     const truncationStatuses: { [string]: MessageTruncationStatus } = {};
     for (const messageInfo of action.payload.rawMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.EXHAUSTIVE;
     }
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       truncationStatuses,
       newThreadInfos,
     );
   } else if (
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success ||
     action.type === createEntryActionTypes.success ||
     action.type === saveEntryActionTypes.success ||
     action.type === restoreEntryActionTypes.success ||
     action.type === toggleMessagePinActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.newMessageInfos,
       {
         [(action.payload.threadID: string)]: messageTruncationStatus.UNCHANGED,
       },
       newThreadInfos,
     );
   } else if (action.type === deleteEntryActionTypes.success) {
     const payload = action.payload;
     if (payload) {
       return mergeNewMessages(
         messageStore,
         payload.newMessageInfos,
         { [payload.threadID]: messageTruncationStatus.UNCHANGED },
         newThreadInfos,
       );
     }
   } else if (action.type === joinThreadActionTypes.success) {
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.rawMessageInfos,
       action.payload.updatesResult.newUpdates,
     );
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
     );
   } else if (action.type === sendEditMessageActionTypes.success) {
     const { newMessageInfos } = action.payload;
     const truncationStatuses: { [string]: MessageTruncationStatus } = {};
     for (const messageInfo of newMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.UNCHANGED;
     }
     return mergeNewMessages(
       messageStore,
       newMessageInfos,
       truncationStatuses,
       newThreadInfos,
     );
   } else if (
     action.type === sendTextMessageActionTypes.started ||
     action.type === sendMultimediaMessageActionTypes.started ||
     action.type === sendReactionMessageActionTypes.started
   ) {
     const payload = ensureRealizedThreadIDIsUsedWhenPossible(
       action.payload,
       newThreadInfos,
     );
     const { localID, threadID } = payload;
     invariant(localID, `localID should be set on ${action.type}`);
 
     const messageIDs = messageStore.threads[threadID]?.messageIDs ?? [];
     if (!messageStore.messages[localID]) {
       for (const existingMessageID of messageIDs) {
         const existingMessageInfo = messageStore.messages[existingMessageID];
         if (existingMessageInfo && existingMessageInfo.localID === localID) {
           return { messageStoreOperations: [], messageStore };
         }
       }
     }
 
     const messageStoreOperations: MessageStoreOperation[] = [
       {
         type: 'replace',
         payload: { id: localID, messageInfo: payload },
       },
     ];
 
     let updatedThreads;
     let local = { ...messageStore.local };
     if (messageStore.messages[localID]) {
       const messages = {
         ...messageStore.messages,
         [(localID: string)]: payload,
       };
       local = _pickBy(
         (localInfo: LocalMessageInfo, key: string) => key !== localID,
       )(messageStore.local);
       const thread = messageStore.threads[threadID];
       updatedThreads = {
         [(threadID: string)]: {
           messageIDs: sortMessageIDs(messages)(messageIDs),
           startReached: thread?.startReached ?? true,
         },
       };
     } else {
       updatedThreads = {
         [(threadID: string)]: messageStore.threads[threadID]
           ? {
               ...messageStore.threads[threadID],
               messageIDs: [localID, ...messageIDs],
             }
           : {
               messageIDs: [localID],
               startReached: true,
             },
       };
     }
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: {
         threads: { ...updatedThreads },
       },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       messages: processedMessageStore.messages,
       threads: processedMessageStore.threads,
       local,
       currentAsOf: messageStore.currentAsOf,
     };
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (
     action.type === sendTextMessageActionTypes.failed ||
     action.type === sendMultimediaMessageActionTypes.failed
   ) {
     const { localID } = action.payload;
     return {
       messageStoreOperations: [],
       messageStore: {
         messages: messageStore.messages,
         threads: messageStore.threads,
         local: {
           ...messageStore.local,
           [(localID: string)]: { sendFailed: true },
         },
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (action.type === sendReactionMessageActionTypes.failed) {
     const { localID, threadID } = action.payload;
     const messageStoreOperations: MessageStoreOperation[] = [];
 
     messageStoreOperations.push({
       type: 'remove',
       payload: { ids: [localID] },
     });
 
     const newMessageIDs = messageStore.threads[threadID].messageIDs.filter(
       id => id !== localID,
     );
     const updatedThreads = {
       [threadID]: {
         ...messageStore.threads[threadID],
         messageIDs: newMessageIDs,
       },
     };
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: updatedThreads },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: processedMessageStore,
     };
   } else if (
     action.type === sendTextMessageActionTypes.success ||
     action.type === sendMultimediaMessageActionTypes.success ||
     action.type === sendReactionMessageActionTypes.success
   ) {
     const { payload } = action;
     invariant(
       !threadIsPending(payload.threadID),
       'Successful message action should have realized thread id',
     );
     const replaceMessageKey = (messageKey: string) =>
       messageKey === payload.localID ? payload.serverID : messageKey;
     let newMessages;
     const messageStoreOperations: MessageStoreOperation[] = [];
     if (messageStore.messages[payload.serverID]) {
       // If somehow the serverID got in there already, we'll just update the
       // serverID message and scrub the localID one
       newMessages = _omitBy(
         (messageInfo: RawMessageInfo) =>
           messageInfo.type === messageTypes.TEXT &&
           !messageInfo.id &&
           messageInfo.localID === payload.localID,
       )(messageStore.messages);
       messageStoreOperations.push({
         type: 'remove',
         payload: { ids: [payload.localID] },
       });
     } else if (messageStore.messages[payload.localID]) {
       // The normal case, the localID message gets replaced by the serverID one
       newMessages = _mapKeys(replaceMessageKey)(messageStore.messages);
       messageStoreOperations.push({
         type: 'rekey',
         payload: { from: payload.localID, to: payload.serverID },
       });
     } else {
       // Well this is weird, we probably got deauthorized between when the
       // action was dispatched and when we ran this reducer...
       return { messageStoreOperations, messageStore };
     }
 
     const newMessage = {
       ...newMessages[payload.serverID],
       id: payload.serverID,
       localID: payload.localID,
       time: payload.time,
     };
     newMessages[payload.serverID] = newMessage;
     messageStoreOperations.push({
       type: 'replace',
       payload: { id: payload.serverID, messageInfo: newMessage },
     });
     const threadID = payload.threadID;
     const newMessageIDs = _flow(
       _uniq,
       sortMessageIDs(newMessages),
     )(messageStore.threads[threadID].messageIDs.map(replaceMessageKey));
     const local = _pickBy(
       (localInfo: LocalMessageInfo, key: string) => key !== payload.localID,
     )(messageStore.local);
 
     const updatedThreads = {
       [threadID]: {
         ...messageStore.threads[threadID],
         messageIDs: newMessageIDs,
       },
     };
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: updatedThreads },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStore,
         messages: processedMessageStore.messages,
         threads: processedMessageStore.threads,
         local,
       },
     };
   } else if (action.type === saveMessagesActionType) {
     const truncationStatuses: { [string]: MessageTruncationStatus } = {};
     for (const messageInfo of action.payload.rawMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.UNCHANGED;
     }
     const { messageStoreOperations, messageStore: newMessageStore } =
       mergeNewMessages(
         messageStore,
         action.payload.rawMessageInfos,
         truncationStatuses,
         newThreadInfos,
       );
     return {
       messageStoreOperations,
       messageStore: {
         messages: newMessageStore.messages,
         threads: newMessageStore.threads,
         local: newMessageStore.local,
         // We avoid bumping currentAsOf because notifs may include a contracted
         // RawMessageInfo, so we want to make sure we still fetch it
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (action.type === messageStorePruneActionType) {
     const messageIDsToPrune = [];
 
     const updatedThreads: { [string]: ThreadMessageInfo } = {};
     for (const threadID of action.payload.threadIDs) {
       let thread = messageStore.threads[threadID];
       if (!thread) {
         continue;
       }
 
       const newMessageIDs = [...thread.messageIDs];
       const removed = newMessageIDs.splice(defaultNumberPerThread);
       if (removed.length > 0) {
         thread = {
           ...thread,
           messageIDs: newMessageIDs,
           startReached: false,
         };
       }
       for (const id of removed) {
         messageIDsToPrune.push(id);
       }
 
       updatedThreads[threadID] = thread;
     }
 
     const messageStoreOperations = [
       {
         type: 'remove',
         payload: { ids: messageIDsToPrune },
       },
       {
         type: 'replace_threads',
         payload: {
           threads: updatedThreads,
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       messages: processedMessageStore.messages,
       threads: processedMessageStore.threads,
       local: _omit(messageIDsToPrune)(messageStore.local),
       currentAsOf: messageStore.currentAsOf,
     };
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (action.type === updateMultimediaMessageMediaActionType) {
     const { messageID: id, currentMediaID, mediaUpdate } = action.payload;
     const message = messageStore.messages[id];
     invariant(message, `message with ID ${id} could not be found`);
     invariant(
       message.type === messageTypes.IMAGES ||
         message.type === messageTypes.MULTIMEDIA,
       `message with ID ${id} is not multimedia`,
     );
 
     let updatedMessage;
     let replaced = false;
     if (message.type === messageTypes.IMAGES) {
       const media: Image[] = [];
       for (const singleMedia of message.media) {
         if (singleMedia.id !== currentMediaID) {
           media.push(singleMedia);
         } else {
           let updatedMedia: Image = {
             id: mediaUpdate.id ?? singleMedia.id,
             type: 'photo',
             uri: mediaUpdate.uri ?? singleMedia.uri,
             dimensions: mediaUpdate.dimensions ?? singleMedia.dimensions,
             thumbHash: mediaUpdate.thumbHash ?? singleMedia.thumbHash,
           };
 
           if (
             'localMediaSelection' in singleMedia &&
             !('localMediaSelection' in mediaUpdate)
           ) {
             updatedMedia = {
               ...updatedMedia,
               localMediaSelection: singleMedia.localMediaSelection,
             };
           } else if (mediaUpdate.localMediaSelection) {
             updatedMedia = {
               ...updatedMedia,
               localMediaSelection: mediaUpdate.localMediaSelection,
             };
           }
 
           media.push(updatedMedia);
           replaced = true;
         }
       }
       updatedMessage = { ...message, media };
     } else {
       const media: Media[] = [];
       for (const singleMedia of message.media) {
         if (singleMedia.id !== currentMediaID) {
           media.push(singleMedia);
         } else if (
           singleMedia.type === 'photo' &&
           mediaUpdate.type === 'photo'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'video' &&
           mediaUpdate.type === 'video'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'encrypted_photo' &&
           mediaUpdate.type === 'encrypted_photo'
         ) {
           // TODO: Remove this $FlowFixMe after updating Flow to 0.202
           // There's no way in Flow to refine both of these types appropriately
           // so they can be spread together.
           // $FlowFixMe
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'encrypted_video' &&
           mediaUpdate.type === 'encrypted_video'
         ) {
           // TODO: Remove this $FlowFixMe after updating Flow to 0.202
           // There's no way in Flow to refine both of these types appropriately
           // so they can be spread together.
           // $FlowFixMe
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'photo' &&
           mediaUpdate.type === 'encrypted_photo'
         ) {
           // extract fields that are absent in encrypted_photo type
           const { uri, localMediaSelection, ...original } = singleMedia;
           const {
             holder: newHolder,
             blobURI: newBlobURI,
             encryptionKey,
             ...update
           } = mediaUpdate;
           const blobURI = newBlobURI ?? newHolder;
           invariant(
             blobURI && encryptionKey,
             'holder and encryptionKey are required for encrypted_photo message',
           );
           media.push({
             ...original,
             ...update,
             type: 'encrypted_photo',
             blobURI,
             encryptionKey,
           });
           replaced = true;
         } else if (
           singleMedia.type === 'video' &&
           mediaUpdate.type === 'encrypted_video'
         ) {
           const { uri, thumbnailURI, localMediaSelection, ...original } =
             singleMedia;
           const {
             holder: newHolder,
             blobURI: newBlobURI,
             encryptionKey,
             thumbnailHolder: newThumbnailHolder,
             thumbnailBlobURI: newThumbnailBlobURI,
             thumbnailEncryptionKey,
             ...update
           } = mediaUpdate;
           const blobURI = newBlobURI ?? newHolder;
           invariant(
             blobURI && encryptionKey,
             'holder and encryptionKey are required for encrypted_video message',
           );
           const thumbnailBlobURI = newThumbnailBlobURI ?? newThumbnailHolder;
           invariant(
             thumbnailBlobURI && thumbnailEncryptionKey,
             'thumbnailHolder and thumbnailEncryptionKey are required for ' +
               'encrypted_video message',
           );
           media.push({
             ...original,
             ...update,
             type: 'encrypted_video',
             blobURI,
             encryptionKey,
             thumbnailBlobURI,
             thumbnailEncryptionKey,
           });
           replaced = true;
         } else if (mediaUpdate.id) {
           const { id: newID } = mediaUpdate;
           // branching for Flow
           if (singleMedia.type === 'photo') {
             media.push({ ...singleMedia, id: newID });
           } else if (singleMedia.type === 'video') {
             media.push({ ...singleMedia, id: newID });
           } else if (singleMedia.type === 'encrypted_photo') {
             // TODO: Try removing this branching after Flow 0.202 update
             if (singleMedia.blobURI) {
               media.push({ ...singleMedia, id: newID });
             } else {
               invariant(
                 singleMedia.holder,
                 'Encrypted media must have holder or blobURI',
               );
               media.push({ ...singleMedia, id: newID });
             }
           } else if (singleMedia.type === 'encrypted_video') {
             // TODO: Try removing this branching after Flow 0.202 update
             if (singleMedia.blobURI) {
               media.push({ ...singleMedia, id: newID });
             } else {
               invariant(
                 singleMedia.holder,
                 'Encrypted media must have holder or blobURI',
               );
               media.push({ ...singleMedia, id: newID });
             }
           }
           replaced = true;
         }
       }
       updatedMessage = { ...message, media };
     }
 
     invariant(
       replaced,
       `message ${id} did not contain media with ID ${currentMediaID}`,
     );
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: {
           id,
           messageInfo: updatedMessage,
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStore,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === createLocalMessageActionType) {
     const messageInfo = ensureRealizedThreadIDIsUsedWhenPossible(
       action.payload,
       newThreadInfos,
     );
     const { localID, threadID } = messageInfo;
 
     const messageIDs =
       messageStore.threads[messageInfo.threadID]?.messageIDs ?? [];
     const threadState: ThreadMessageInfo = messageStore.threads[threadID]
       ? {
           ...messageStore.threads[threadID],
           messageIDs: [localID, ...messageIDs],
         }
       : {
           messageIDs: [localID],
           startReached: true,
         };
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: { id: localID, messageInfo },
       },
       {
         type: 'replace_threads',
         payload: {
           threads: { [(threadID: string)]: threadState },
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStore,
         threads: processedMessageStore.threads,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === processServerRequestsActionType) {
     const {
       messageStoreOperations,
       messageStore: messageStoreAfterReassignment,
     } = reassignMessagesToRealizedThreads(messageStore, newThreadInfos);
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStoreAfterReassignment,
         messages: processedMessageStore.messages,
         threads: processedMessageStore.threads,
       },
     };
   } else if (action.type === setClientDBStoreActionType) {
     const actionPayloadMessageStoreThreads =
       translateClientDBThreadMessageInfos(
         action.payload.messageStoreThreads ?? [],
       );
 
     const newThreads: {
       [threadID: string]: ThreadMessageInfo,
     } = { ...messageStore.threads };
     for (const threadID in actionPayloadMessageStoreThreads) {
       newThreads[threadID] = {
         ...actionPayloadMessageStoreThreads[threadID],
         messageIDs: messageStore.threads?.[threadID]?.messageIDs ?? [],
       };
     }
 
     const payloadMessages = action.payload.messages;
     if (!payloadMessages) {
       return {
         messageStoreOperations: [],
         messageStore: { ...messageStore, threads: newThreads },
       };
     }
 
     const { messageStoreOperations, messageStore: updatedMessageStore } =
       updateMessageStoreWithLatestThreadInfos(
         { ...messageStore, threads: newThreads },
         newThreadInfos,
       );
 
     let threads = { ...updatedMessageStore.threads };
     let local = { ...updatedMessageStore.local };
 
     // Store message IDs already contained within threads so that we
     // do not insert duplicates
     const existingMessageIDs = new Set<string>();
     for (const threadID in threads) {
       threads[threadID].messageIDs.forEach(msgID => {
         existingMessageIDs.add(msgID);
       });
     }
     const threadsNeedMsgIDsResorting = new Set<string>();
     const actionPayloadMessages =
       messageStoreOpsHandlers.translateClientDBData(payloadMessages);
 
     // When starting the app on native, we filter out any local-only multimedia
     // messages because the relevant context is no longer available
     const messageIDsToBeRemoved = [];
     const threadsToAdd: { [string]: ThreadMessageInfo } = {};
     for (const id in actionPayloadMessages) {
       const message = actionPayloadMessages[id];
       const { threadID } = message;
       let existingThread = threads[threadID];
       if (!existingThread) {
         existingThread = newThread();
         threadsToAdd[threadID] = existingThread;
       }
       if (
         (message.type === messageTypes.IMAGES ||
           message.type === messageTypes.MULTIMEDIA) &&
         !message.id
       ) {
         messageIDsToBeRemoved.push(id);
         threads = {
           ...threads,
           [(threadID: string)]: {
             ...existingThread,
             messageIDs: existingThread.messageIDs.filter(
               curMessageID => curMessageID !== id,
             ),
           },
         };
         local = _pickBy(
           (localInfo: LocalMessageInfo, key: string) => key !== id,
         )(local);
       } else if (!existingMessageIDs.has(id)) {
         threads = {
           ...threads,
           [(threadID: string)]: {
             ...existingThread,
             messageIDs: [...existingThread.messageIDs, id],
           },
         };
         threadsNeedMsgIDsResorting.add(threadID);
       } else if (!threads[threadID]) {
         threads = { ...threads, [(threadID: string)]: existingThread };
       }
     }
 
     for (const threadID of threadsNeedMsgIDsResorting) {
       threads[threadID].messageIDs = sortMessageIDs(actionPayloadMessages)(
         threads[threadID].messageIDs,
       );
     }
 
     const newMessageStore = {
       ...updatedMessageStore,
       messages: actionPayloadMessages,
       threads: threads,
       local: local,
     };
 
     if (messageIDsToBeRemoved.length > 0) {
       messageStoreOperations.push({
         type: 'remove',
         payload: { ids: messageIDsToBeRemoved },
       });
     }
 
     const processedMessageStore = processMessageStoreOperations(
       newMessageStore,
       messageStoreOperations,
     );
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: threadsToAdd },
     });
 
     return {
       messageStoreOperations,
       messageStore: processedMessageStore,
     };
   }
   return { messageStoreOperations: [], messageStore };
 }
 
 type MergedUpdatesWithMessages = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
 };
 function mergeUpdatesWithMessageInfos(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   truncationStatuses?: MessageTruncationStatuses,
 ): MergedUpdatesWithMessages {
   const messageIDs = new Set(
     messageInfos.map(messageInfo => messageInfo.id).filter(Boolean),
   );
   const mergedMessageInfos = [...messageInfos];
   const mergedTruncationStatuses = { ...truncationStatuses };
 
   for (const update of newUpdates) {
     const { mergeMessageInfosAndTruncationStatuses } = updateSpecs[update.type];
     if (!mergeMessageInfosAndTruncationStatuses) {
       continue;
     }
     mergeMessageInfosAndTruncationStatuses(
       messageIDs,
       mergedMessageInfos,
       mergedTruncationStatuses,
       update,
     );
   }
   return {
     rawMessageInfos: mergedMessageInfos,
     truncationStatuses: mergedTruncationStatuses,
   };
 }
 
 export { freshMessageStore, reduceMessageStore };
diff --git a/lib/reducers/policies-reducer.js b/lib/reducers/policies-reducer.js
index aca946e23..a62a91ea6 100644
--- a/lib/reducers/policies-reducer.js
+++ b/lib/reducers/policies-reducer.js
@@ -1,58 +1,58 @@
 // @flow
 
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
   logOutActionTypes,
   policyAcknowledgmentActionTypes,
 } from '../actions/user-actions.js';
 import type { PolicyType } from '../facts/policies.js';
 import {
   type UserPolicies,
   forcePolicyAcknowledgmentActionType,
 } from '../types/policy-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 
 function policiesReducer(
   state: UserPolicies,
   action: BaseAction,
 ): UserPolicies {
   if (
     action.type === forcePolicyAcknowledgmentActionType ||
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success
   ) {
     const { notAcknowledgedPolicies } = action.payload;
     if (!notAcknowledgedPolicies) {
       return state;
     }
     const newState = { ...state };
 
     notAcknowledgedPolicies.forEach((policy: PolicyType) => {
       newState[policy] = {
         ...newState[policy],
         isAcknowledged: false,
       };
     });
     return newState;
   } else if (action.type === policyAcknowledgmentActionTypes.success) {
     const { policy } = action.payload;
     return {
       ...state,
       [policy]: {
         ...state[policy],
         isAcknowledged: true,
       },
     };
   } else if (
     action.type === logOutActionTypes.started ||
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success
+    action.type === deleteKeyserverAccountActionTypes.success
   ) {
     return {};
   }
   return state;
 }
 
 export default policiesReducer;
diff --git a/lib/reducers/report-store-reducer.js b/lib/reducers/report-store-reducer.js
index a70c9bb17..ce0652d6c 100644
--- a/lib/reducers/report-store-reducer.js
+++ b/lib/reducers/report-store-reducer.js
@@ -1,195 +1,195 @@
 // @flow
 
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import {
   sendReportActionTypes,
   sendReportsActionTypes,
   queueReportsActionType,
 } from '../actions/report-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
 } from '../actions/user-actions.js';
 import type { ReportStoreOperation } from '../ops/report-store-ops.js';
 import {
   convertReportsToRemoveReportsOperation,
   convertReportsToReplaceReportOps,
   reportStoreOpsHandlers,
 } from '../ops/report-store-ops.js';
 import { isStaff } from '../shared/staff-utils.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   type ReportStore,
   defaultEnabledReports,
   defaultDevEnabledReports,
   type ClientReportCreationRequest,
 } from '../types/report-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { isDev } from '../utils/dev-utils.js';
 import { isReportEnabled } from '../utils/report-utils.js';
 
 export const updateReportsEnabledActionType = 'UPDATE_REPORTS_ENABLED';
 
 const { processStoreOperations: processReportStoreOperations } =
   reportStoreOpsHandlers;
 
 export default function reduceReportStore(
   state: ReportStore,
   action: BaseAction,
   newInconsistencies: $ReadOnlyArray<ClientReportCreationRequest>,
 ): {
   reportStore: ReportStore,
   reportStoreOperations: $ReadOnlyArray<ReportStoreOperation>,
 } {
   const newReports = newInconsistencies.filter(report =>
     isReportEnabled(report, state.enabledReports),
   );
 
   if (action.type === updateReportsEnabledActionType) {
     const newEnabledReports = { ...state.enabledReports, ...action.payload };
     const newFilteredReports = newReports.filter(report =>
       isReportEnabled(report, newEnabledReports),
     );
     const reportsToRemove = state.queuedReports.filter(
       report => !isReportEnabled(report, newEnabledReports),
     );
 
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> = [
       convertReportsToRemoveReportsOperation(reportsToRemove),
       ...convertReportsToReplaceReportOps(newFilteredReports),
     ];
 
     const queuedReports = processReportStoreOperations(
       state.queuedReports,
       reportStoreOperations,
     );
 
     return {
       reportStore: {
         queuedReports,
         enabledReports: newEnabledReports,
       },
       reportStoreOperations,
     };
   } else if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return {
       reportStore: {
         queuedReports: [],
         enabledReports: isDev
           ? defaultDevEnabledReports
           : defaultEnabledReports,
       },
       reportStoreOperations: [{ type: 'remove_all_reports' }],
     };
   } else if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success
   ) {
     return {
       reportStore: {
         queuedReports: [],
         enabledReports:
           isStaff(action.payload.currentUserInfo.id) || isDev
             ? defaultDevEnabledReports
             : defaultEnabledReports,
       },
       reportStoreOperations: [{ type: 'remove_all_reports' }],
     };
   } else if (
     (action.type === sendReportActionTypes.success ||
       action.type === sendReportsActionTypes.success) &&
     action.payload
   ) {
     const { payload } = action;
     const sentReports = state.queuedReports.filter(response =>
       payload.reports.includes(response),
     );
 
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> = [
       convertReportsToRemoveReportsOperation(sentReports),
       ...convertReportsToReplaceReportOps(newReports),
     ];
 
     const queuedReports = processReportStoreOperations(
       state.queuedReports,
       reportStoreOperations,
     );
 
     return {
       reportStore: { ...state, queuedReports },
       reportStoreOperations,
     };
   } else if (action.type === queueReportsActionType) {
     const { reports } = action.payload;
     const filteredReports = reports.filter(report =>
       isReportEnabled(report, state.enabledReports),
     );
 
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> =
       convertReportsToReplaceReportOps([...newReports, ...filteredReports]);
 
     const queuedReports = processReportStoreOperations(
       state.queuedReports,
       reportStoreOperations,
     );
 
     return {
       reportStore: {
         ...state,
         queuedReports,
       },
       reportStoreOperations,
     };
   } else if (action.type === setClientDBStoreActionType) {
     const { reports } = action.payload;
     if (!reports) {
       return {
         reportStore: state,
         reportStoreOperations: [],
       };
     }
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> = [
       {
         type: 'remove_all_reports',
       },
       ...convertReportsToReplaceReportOps(reports),
     ];
 
     const queuedReports = processReportStoreOperations(
       state.queuedReports,
       reportStoreOperations,
     );
 
     return {
       reportStore: { ...state, queuedReports },
       reportStoreOperations: [],
     };
   }
 
   if (newReports.length > 0) {
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> =
       convertReportsToReplaceReportOps(newReports);
 
     const queuedReports = processReportStoreOperations(
       state.queuedReports,
       reportStoreOperations,
     );
 
     return {
       reportStore: {
         ...state,
         queuedReports,
       },
       reportStoreOperations,
     };
   }
 
   return { reportStore: state, reportStoreOperations: [] };
 }
diff --git a/lib/reducers/services-access-token-reducer.js b/lib/reducers/services-access-token-reducer.js
index 2936ecca0..1b494c104 100644
--- a/lib/reducers/services-access-token-reducer.js
+++ b/lib/reducers/services-access-token-reducer.js
@@ -1,31 +1,31 @@
 // @flow
 
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   setAccessTokenActionType,
 } from '../actions/user-actions.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 
 export default function reduceServicesAccessToken(
   state: ?string,
   action: BaseAction,
 ): ?string {
   if (action.type === setAccessTokenActionType) {
     return action.payload;
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.currentUserInfo &&
     action.payload.sessionChange.currentUserInfo.anonymous
   ) {
     return null;
   } else if (
     action.type === logOutActionTypes.started ||
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success
+    action.type === deleteKeyserverAccountActionTypes.success
   ) {
     return null;
   }
   return state;
 }
diff --git a/lib/reducers/theme-reducer.js b/lib/reducers/theme-reducer.js
index 1b7d7de39..6ba0ceaf7 100644
--- a/lib/reducers/theme-reducer.js
+++ b/lib/reducers/theme-reducer.js
@@ -1,47 +1,47 @@
 // @flow
 
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import { updateThemeInfoActionType } from '../actions/theme-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
 } from '../actions/user-actions.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   defaultGlobalThemeInfo,
   type GlobalThemeInfo,
 } from '../types/theme-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 
 export default function reduceGlobalThemeInfo(
   state: GlobalThemeInfo,
   action: BaseAction,
 ): GlobalThemeInfo {
   if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success
   ) {
     return defaultGlobalThemeInfo;
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.currentUserInfo &&
     action.payload.sessionChange.currentUserInfo.anonymous
   ) {
     return defaultGlobalThemeInfo;
   } else if (
     action.type === logOutActionTypes.started ||
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success
+    action.type === deleteKeyserverAccountActionTypes.success
   ) {
     return defaultGlobalThemeInfo;
   } else if (action.type === updateThemeInfoActionType) {
     return {
       ...state,
       ...action.payload,
     };
   }
   return state;
 }
diff --git a/lib/reducers/thread-activity-reducer.js b/lib/reducers/thread-activity-reducer.js
index c253e62e8..0529f230a 100644
--- a/lib/reducers/thread-activity-reducer.js
+++ b/lib/reducers/thread-activity-reducer.js
@@ -1,103 +1,103 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageStorePruneActionType } from '../actions/message-actions.js';
 import {
   changeThreadMemberRolesActionTypes,
   changeThreadSettingsActionTypes,
   deleteCommunityRoleActionTypes,
   deleteThreadActionTypes,
   joinThreadActionTypes,
   leaveThreadActionTypes,
   modifyCommunityRoleActionTypes,
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
 } from '../actions/user-actions.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { incrementalStateSyncActionType } from '../types/socket-types.js';
 import type { ThreadActivityStore } from '../types/thread-activity-types.js';
 import { updateThreadLastNavigatedActionType } from '../types/thread-activity-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import type { ClientUpdateInfo } from '../types/update-types.js';
 import { processUpdatesActionType } from '../types/update-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 
 function reduceThreadActivity(
   state: ThreadActivityStore,
   action: BaseAction,
 ): ThreadActivityStore {
   if (action.type === updateThreadLastNavigatedActionType) {
     const { threadID, time } = action.payload;
     const updatedThreadActivityStore = {
       ...state,
       [threadID]: {
         ...state[threadID],
         lastNavigatedTo: time,
       },
     };
     return updatedThreadActivityStore;
   } else if (action.type === messageStorePruneActionType) {
     const now = Date.now();
     let updatedThreadActivityStore = { ...state };
     for (const threadID: string of action.payload.threadIDs) {
       updatedThreadActivityStore = {
         ...updatedThreadActivityStore,
         [threadID]: {
           ...updatedThreadActivityStore[threadID],
           lastPruned: now,
         },
       };
     }
     return updatedThreadActivityStore;
   } else if (
     action.type === joinThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success ||
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType ||
     action.type === newThreadActionTypes.success ||
     action.type === modifyCommunityRoleActionTypes.success ||
     action.type === deleteCommunityRoleActionTypes.success
   ) {
     const { newUpdates } = action.payload.updatesResult;
     if (newUpdates.length === 0) {
       return state;
     }
 
     const deleteThreadUpdates = newUpdates.filter(
       (update: ClientUpdateInfo) => update.type === updateTypes.DELETE_THREAD,
     );
     if (deleteThreadUpdates.length === 0) {
       return state;
     }
 
     let updatedState = { ...state };
     for (const update: ClientUpdateInfo of deleteThreadUpdates) {
       invariant(
         update.type === updateTypes.DELETE_THREAD,
         'update must be of type DELETE_THREAD',
       );
       const { [update.threadID]: _, ...stateSansRemovedThread } = updatedState;
       updatedState = stateSansRemovedThread;
     }
     return updatedState;
   } else if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return {};
   }
   return state;
 }
 
 export { reduceThreadActivity };
diff --git a/lib/reducers/thread-reducer.js b/lib/reducers/thread-reducer.js
index ce3bdad85..429de923a 100644
--- a/lib/reducers/thread-reducer.js
+++ b/lib/reducers/thread-reducer.js
@@ -1,415 +1,415 @@
 // @flow
 
 import {
   setThreadUnreadStatusActionTypes,
   updateActivityActionTypes,
 } from '../actions/activity-actions.js';
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import { saveMessagesActionType } from '../actions/message-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   changeThreadSettingsActionTypes,
   deleteThreadActionTypes,
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
   changeThreadMemberRolesActionTypes,
   joinThreadActionTypes,
   leaveThreadActionTypes,
   modifyCommunityRoleActionTypes,
   deleteCommunityRoleActionTypes,
 } from '../actions/thread-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
   updateSubscriptionActionTypes,
 } from '../actions/user-actions.js';
 import {
   type ThreadStoreOperation,
   threadStoreOpsHandlers,
 } from '../ops/thread-store-ops.js';
 import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   processServerRequestsActionType,
 } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type {
   LegacyRawThreadInfo,
   LegacyRawThreadInfos,
   ThreadStore,
 } from '../types/thread-types.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 
 const { processStoreOperations: processThreadStoreOperations } =
   threadStoreOpsHandlers;
 
 function generateOpsForThreadUpdates(
   threadInfos: LegacyRawThreadInfos,
   payload: {
     +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
     ...
   },
 ): $ReadOnlyArray<ThreadStoreOperation> {
   return payload.updatesResult.newUpdates
     .map(update =>
       updateSpecs[update.type].generateOpsForThreadUpdates?.(
         threadInfos,
         update,
       ),
     )
     .filter(Boolean)
     .flat();
 }
 
 function reduceThreadInfos(
   state: ThreadStore,
   action: BaseAction,
 ): {
   threadStore: ThreadStore,
   newThreadInconsistencies: $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>,
   threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 } {
   if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success ||
     action.type === fullStateSyncActionType
   ) {
     const newThreadInfos = action.payload.threadInfos;
     const threadStoreOperations = [
       {
         type: 'remove_all',
       },
       ...Object.keys(newThreadInfos).map((id: string) => ({
         type: 'replace',
         payload: { id, threadInfo: newThreadInfos[id] },
       })),
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     if (Object.keys(state.threadInfos).length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = [
       {
         type: 'remove_all',
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (
     action.type === joinThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success ||
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType ||
     action.type === newThreadActionTypes.success ||
     action.type === modifyCommunityRoleActionTypes.success ||
     action.type === deleteCommunityRoleActionTypes.success
   ) {
     const { newUpdates } = action.payload.updatesResult;
     if (newUpdates.length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = generateOpsForThreadUpdates(
       state.threadInfos,
       action.payload,
     );
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === updateSubscriptionActionTypes.success) {
     const { threadID, subscription } = action.payload;
     const newThreadInfo = {
       ...state.threadInfos[threadID],
       currentUser: {
         ...state.threadInfos[threadID].currentUser,
         subscription,
       },
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: newThreadInfo,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === saveMessagesActionType) {
     const threadIDToMostRecentTime = new Map<string, number>();
     for (const messageInfo of action.payload.rawMessageInfos) {
       const current = threadIDToMostRecentTime.get(messageInfo.threadID);
       if (!current || current < messageInfo.time) {
         threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
       }
     }
     const changedThreadInfos: { [string]: LegacyRawThreadInfo } = {};
     for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
       const threadInfo = state.threadInfos[threadID];
       if (
         !threadInfo ||
         threadInfo.currentUser.unread ||
         action.payload.updatesCurrentAsOf > mostRecentTime
       ) {
         continue;
       }
       changedThreadInfos[threadID] = {
         ...state.threadInfos[threadID],
         currentUser: {
           ...state.threadInfos[threadID].currentUser,
           unread: true,
         },
       };
     }
     if (Object.keys(changedThreadInfos).length !== 0) {
       const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
         type: 'replace',
         payload: {
           id,
           threadInfo: changedThreadInfos[id],
         },
       }));
       const updatedThreadStore = processThreadStoreOperations(
         state,
         threadStoreOperations,
       );
       return {
         threadStore: updatedThreadStore,
         newThreadInconsistencies: [],
         threadStoreOperations,
       };
     }
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (!checkStateRequest || !checkStateRequest.stateChanges) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const { rawThreadInfos, deleteThreadIDs } = checkStateRequest.stateChanges;
     if (!rawThreadInfos && !deleteThreadIDs) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const threadStoreOperations: ThreadStoreOperation[] = [];
     if (rawThreadInfos) {
       for (const rawThreadInfo of rawThreadInfos) {
         threadStoreOperations.push({
           type: 'replace',
           payload: {
             id: rawThreadInfo.id,
             threadInfo: rawThreadInfo,
           },
         });
       }
     }
     if (deleteThreadIDs) {
       threadStoreOperations.push({
         type: 'remove',
         payload: {
           ids: deleteThreadIDs,
         },
       });
     }
 
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
 
     const newThreadInconsistencies =
       stateSyncSpecs.threads.findStoreInconsistencies(
         action,
         state.threadInfos,
         updatedThreadStore.threadInfos,
       );
 
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies,
       threadStoreOperations,
     };
   } else if (action.type === updateActivityActionTypes.success) {
     const updatedThreadInfos: { [string]: LegacyRawThreadInfo } = {};
     for (const setToUnread of action.payload.result.unfocusedToUnread) {
       const threadInfo = state.threadInfos[setToUnread];
       if (threadInfo && !threadInfo.currentUser.unread) {
         updatedThreadInfos[setToUnread] = {
           ...threadInfo,
           currentUser: {
             ...threadInfo.currentUser,
             unread: true,
           },
         };
       }
     }
     if (Object.keys(updatedThreadInfos).length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
       type: 'replace',
       payload: {
         id,
         threadInfo: updatedThreadInfos[id],
       },
     }));
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setThreadUnreadStatusActionTypes.started) {
     const { threadID, unread } = action.payload;
     const updatedThreadInfo = {
       ...state.threadInfos[threadID],
       currentUser: {
         ...state.threadInfos[threadID].currentUser,
         unread,
       },
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: updatedThreadInfo,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setThreadUnreadStatusActionTypes.success) {
     const { threadID, resetToUnread } = action.payload;
     const currentUser = state.threadInfos[threadID].currentUser;
 
     if (!resetToUnread || currentUser.unread) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const updatedUser = {
       ...currentUser,
       unread: true,
     };
     const updatedThread = {
       ...state.threadInfos[threadID],
       currentUser: updatedUser,
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: updatedThread,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setClientDBStoreActionType) {
     return {
       threadStore: action.payload.threadStore ?? state,
       newThreadInconsistencies: [],
       threadStoreOperations: [],
     };
   }
   return {
     threadStore: state,
     newThreadInconsistencies: [],
     threadStoreOperations: [],
   };
 }
 
 export { reduceThreadInfos };
diff --git a/lib/reducers/user-reducer.js b/lib/reducers/user-reducer.js
index adb395534..c77a4a9b5 100644
--- a/lib/reducers/user-reducer.js
+++ b/lib/reducers/user-reducer.js
@@ -1,411 +1,411 @@
 // @flow
 
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   joinThreadActionTypes,
   newThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
   setUserSettingsActionTypes,
   updateUserAvatarActionTypes,
   resetUserStateActionType,
 } from '../actions/user-actions.js';
 import {
   convertUserInfosToReplaceUserOps,
   type UserStoreOperation,
   userStoreOpsHandlers,
 } from '../ops/user-store-ops.js';
 import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import type { BaseAction } from '../types/redux-types.js';
 import type { ClientUserInconsistencyReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   processServerRequestsActionType,
 } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { processUpdatesActionType } from '../types/update-types.js';
 import type { ClientUpdateInfo } from '../types/update-types.js';
 import type {
   CurrentUserInfo,
   UserInfos,
   UserStore,
 } from '../types/user-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { getMessageForException } from '../utils/errors.js';
 import { assertObjectsAreEqual } from '../utils/objects.js';
 
 function reduceCurrentUserInfo(
   state: ?CurrentUserInfo,
   action: BaseAction,
 ): ?CurrentUserInfo {
   if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success ||
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success
+    action.type === deleteKeyserverAccountActionTypes.success
   ) {
     if (!_isEqual(action.payload.currentUserInfo)(state)) {
       return action.payload.currentUserInfo;
     }
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.currentUserInfo
   ) {
     const { sessionChange } = action.payload;
     if (!_isEqual(sessionChange.currentUserInfo)(state)) {
       return sessionChange.currentUserInfo;
     }
   } else if (action.type === fullStateSyncActionType) {
     const { currentUserInfo } = action.payload;
     if (!_isEqual(currentUserInfo)(state)) {
       return currentUserInfo;
     }
   } else if (
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType
   ) {
     return action.payload.updatesResult.newUpdates.reduce(
       (reducedState, update) => {
         const { reduceCurrentUser } = updateSpecs[update.type];
         return reduceCurrentUser
           ? reduceCurrentUser(reducedState, update)
           : reducedState;
       },
       state,
     );
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     const newCurrentUserInfo = checkStateRequest?.stateChanges?.currentUserInfo;
     if (newCurrentUserInfo && !_isEqual(newCurrentUserInfo)(state)) {
       return newCurrentUserInfo;
     }
   } else if (
     action.type === updateUserAvatarActionTypes.success &&
     state &&
     !state.anonymous
   ) {
     const { viewerUpdates } = action.payload.updates;
     for (const update of viewerUpdates) {
       if (
         update.type === updateTypes.UPDATE_CURRENT_USER &&
         !_isEqual(update.currentUserInfo.avatar)(state.avatar)
       ) {
         return {
           ...state,
           avatar: update.currentUserInfo.avatar,
         };
       }
     }
     return state;
   } else if (action.type === setUserSettingsActionTypes.success) {
     if (state?.settings) {
       return {
         ...state,
         settings: {
           ...state.settings,
           ...action.payload,
         },
       };
     }
   } else if (action.type === resetUserStateActionType) {
     state = state && state.anonymous ? state : null;
   }
   return state;
 }
 
 function assertUserStoresAreEqual(
   processedUserStore: UserInfos,
   expectedUserStore: UserInfos,
   location: string,
   onStateDifference: (message: string) => mixed,
 ) {
   try {
     assertObjectsAreEqual(
       processedUserStore,
       expectedUserStore,
       `UserInfos - ${location}`,
     );
   } catch (e) {
     console.log(
       'Error processing UserStore ops',
       processedUserStore,
       expectedUserStore,
     );
     const message = `Error processing UserStore ops ${
       getMessageForException(e) ?? '{no exception message}'
     }`;
     onStateDifference(message);
   }
 }
 
 const { processStoreOperations: processUserStoreOps } = userStoreOpsHandlers;
 
 function generateOpsForUserUpdates(payload: {
   +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
   ...
 }): $ReadOnlyArray<UserStoreOperation> {
   return payload.updatesResult.newUpdates
     .map(update =>
       updateSpecs[update.type].generateOpsForUserInfoUpdates?.(update),
     )
     .filter(Boolean)
     .flat();
 }
 
 function reduceUserInfos(
   state: UserStore,
   action: BaseAction,
   onStateDifference: (message: string) => mixed,
 ): [
   UserStore,
   $ReadOnlyArray<ClientUserInconsistencyReportCreationRequest>,
   $ReadOnlyArray<UserStoreOperation>,
 ] {
   if (
     action.type === joinThreadActionTypes.success ||
     action.type === newThreadActionTypes.success
   ) {
     const newUserInfos: UserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
 
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> =
       convertUserInfosToReplaceUserOps(newUserInfos);
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
     const updated: UserInfos = { ...state.userInfos, ...newUserInfos };
     assertUserStoresAreEqual(
       processedUserInfos,
       updated,
       action.type,
       onStateDifference,
     );
 
     if (!_isEqual(state.userInfos)(updated)) {
       return [
         {
           ...state,
           userInfos: updated,
         },
         [],
         userStoreOps,
       ];
     }
   } else if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> = [
       { type: 'remove_all_users' },
     ];
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
     assertUserStoresAreEqual(
       processedUserInfos,
       {},
       action.type,
       onStateDifference,
     );
 
     if (Object.keys(state.userInfos).length === 0) {
       return [state, [], []];
     }
     return [
       {
         userInfos: {},
       },
       [],
       userStoreOps,
     ];
   } else if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success ||
     action.type === fullStateSyncActionType
   ) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> = [
       { type: 'remove_all_users' },
       ...convertUserInfosToReplaceUserOps(newUserInfos),
     ];
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
     assertUserStoresAreEqual(
       processedUserInfos,
       newUserInfos,
       action.type,
       onStateDifference,
     );
     if (!_isEqual(state.userInfos)(newUserInfos)) {
       return [
         {
           userInfos: newUserInfos,
         },
         [],
         userStoreOps,
       ];
     }
   } else if (
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType
   ) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> = [
       ...convertUserInfosToReplaceUserOps(newUserInfos),
       ...generateOpsForUserUpdates(action.payload),
     ];
     const updated = action.payload.updatesResult.newUpdates.reduce(
       (reducedState, update) => {
         const { reduceUserInfos: reduceUserInfosUpdate } =
           updateSpecs[update.type];
         return reduceUserInfosUpdate
           ? reduceUserInfosUpdate(reducedState, update)
           : reducedState;
       },
       { ...state.userInfos, ...newUserInfos },
     );
 
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
     assertUserStoresAreEqual(
       processedUserInfos,
       updated,
       action.type,
       onStateDifference,
     );
     if (!_isEqual(state.userInfos)(updated)) {
       return [
         {
           ...state,
           userInfos: updated,
         },
         [],
         userStoreOps,
       ];
     }
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (!checkStateRequest || !checkStateRequest.stateChanges) {
       return [state, [], []];
     }
     const { userInfos, deleteUserInfoIDs } = checkStateRequest.stateChanges;
     if (!userInfos && !deleteUserInfoIDs) {
       return [state, [], []];
     }
 
     const userStoreOps: UserStoreOperation[] = [];
     const newUserInfos = { ...state.userInfos };
     if (userInfos) {
       for (const userInfo of userInfos) {
         newUserInfos[userInfo.id] = userInfo;
         userStoreOps.push({ type: 'replace_user', payload: { ...userInfo } });
       }
     }
     if (deleteUserInfoIDs) {
       for (const deleteUserInfoID of deleteUserInfoIDs) {
         delete newUserInfos[deleteUserInfoID];
       }
       userStoreOps.push({
         type: 'remove_users',
         payload: { ids: deleteUserInfoIDs },
       });
     }
 
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
     assertUserStoresAreEqual(
       processedUserInfos,
       newUserInfos,
       action.type,
       onStateDifference,
     );
 
     const newInconsistencies = stateSyncSpecs.users.findStoreInconsistencies(
       action,
       state.userInfos,
       newUserInfos,
     );
     return [
       {
         userInfos: newUserInfos,
       },
       newInconsistencies,
       userStoreOps,
     ];
   } else if (action.type === updateUserAvatarActionTypes.success) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.updates.userInfos,
     );
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> =
       convertUserInfosToReplaceUserOps(newUserInfos);
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
     const updated: UserInfos = { ...state.userInfos, ...newUserInfos };
     assertUserStoresAreEqual(
       processedUserInfos,
       updated,
       action.type,
       onStateDifference,
     );
     const newState = !_isEqual(state.userInfos)(updated)
       ? {
           ...state,
           userInfos: updated,
         }
       : state;
     return [newState, [], userStoreOps];
   } else if (action.type === setClientDBStoreActionType) {
     if (!action.payload.users) {
       return [state, [], []];
     }
     // Once the functionality is confirmed to work correctly,
     // we will proceed with returning the users from the payload.
     assertUserStoresAreEqual(
       action.payload.users ?? {},
       state.userInfos,
       action.type,
       onStateDifference,
     );
     return [state, [], []];
   }
 
   return [state, [], []];
 }
 
 export { reduceCurrentUserInfo, reduceUserInfos };
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index 274c54ba1..da51b55be 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1252 +1,1252 @@
 // @flow
 
 import type {
   LogOutResult,
   LogInStartingPayload,
   LogInResult,
   RegisterResult,
   DefaultNotificationPayload,
   ClaimUsernameResponse,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type { CryptoStore } from './crypto-types.js';
 import type {
   GetVersionActionPayload,
   LastCommunicatedPlatformDetails,
 } from './device-types.js';
 import type { DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
   CalendarQuery,
   FetchRevisionsForEntryPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { IntegrityStore } from './integrity-types.js';
 import type {
   KeyserverStore,
   AddKeyserverPayload,
   RemoveKeyserverPayload,
 } from './keyserver-types.js';
 import type { LifecycleState } from './lifecycle-state-types.js';
 import type {
   FetchInviteLinksResponse,
   InviteLink,
   InviteLinksStore,
   InviteLinkVerificationResponse,
   DisableInviteLinkPayload,
 } from './link-types.js';
 import type { LoadingStatus, LoadingInfo } from './loading-types.js';
 import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
 import type { MessageReportCreationResult } from './message-report-types.js';
 import type {
   MessageStore,
   RawMultimediaMessageInfo,
   FetchMessageInfosPayload,
   SendMessagePayload,
   EditMessagePayload,
   SaveMessagesPayload,
   NewMessagesPayload,
   MessageStorePrunePayload,
   LocallyComposedMessageInfo,
   SimpleMessagesPayload,
   FetchPinnedMessagesResult,
   SearchMessagesResponse,
 } from './message-types.js';
 import type { RawReactionMessageInfo } from './messages/reaction.js';
 import type { RawTextMessageInfo } from './messages/text.js';
 import type { BaseNavInfo } from './nav-types.js';
 import {
   type ForcePolicyAcknowledgmentPayload,
   type PolicyAcknowledgmentPayload,
   type UserPolicies,
 } from './policy-types.js';
 import type { RelationshipErrors } from './relationship-types.js';
 import type {
   EnabledReports,
   ClearDeliveredReportsPayload,
   QueueReportsPayload,
   ReportStore,
 } from './report-types.js';
 import type {
   ProcessServerRequestAction,
   GetOlmSessionInitializationDataResponse,
 } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateDisconnectedBarPayload,
 } from './socket-types.js';
 import { type ClientStore } from './store-ops-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type { GlobalThemeInfo } from './theme-types.js';
 import type { ThreadActivityStore } from './thread-activity-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
   RoleModificationPayload,
   RoleDeletionPayload,
 } from './thread-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type { CurrentUserInfo, UserStore } from './user-types.js';
 import type { SetDeviceTokenActionPayload } from '../actions/device-actions.js';
 import type { NotifPermissionAlertInfo } from '../utils/push-alerts.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo = BaseNavInfo> = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +notifPermissionAlertInfo: NotifPermissionAlertInfo,
   +actualizedCalendarQuery: CalendarQuery,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +nextLocalID: number,
   +dataLoaded: boolean,
   +userPolicies: UserPolicies,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
   ...
 };
 
 export type NativeAppState = BaseAppState<>;
 export type WebAppState = BaseAppState<> & {
   +cryptoStore: ?CryptoStore,
   +pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type BaseAction =
   | {
       +type: '@@redux/INIT',
       +payload?: void,
     }
   | {
       +type: 'FETCH_ENTRIES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_SUCCESS',
       +payload: FetchEntryInfosResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_SUCCESS',
       +payload: LogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CLAIM_USERNAME_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CLAIM_USERNAME_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CLAIM_USERNAME_SUCCESS',
       +payload: ClaimUsernameResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
-      +type: 'DELETE_ACCOUNT_STARTED',
+      +type: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
-      +type: 'DELETE_ACCOUNT_FAILED',
+      +type: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
-      +type: 'DELETE_ACCOUNT_SUCCESS',
+      +type: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
       +payload: LogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_LOCAL_ENTRY',
       +payload: RawEntryInfo,
     }
   | {
       +type: 'CREATE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_SUCCESS',
       +payload: CreateEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_SUCCESS',
       +payload: SaveEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CONCURRENT_MODIFICATION_RESET',
       +payload: {
         +id: string,
         +dbText: string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: {
         +localID: ?string,
         +serverID: ?string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ENTRY_SUCCESS',
       +payload: ?DeleteEntryResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'LOG_IN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'REGISTER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_SUCCESS',
       +payload: RegisterResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_SUCCESS',
       +payload: NewThreadResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
       +payload: FetchRevisionsForEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_SUCCESS',
       +payload: RestoreEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_SUCCESS',
       +payload: ThreadJoinPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_NEW_SESSION',
       +payload: SetSessionPayload,
     }
   | {
       +type: 'persist/REHYDRATE',
       +payload: ?BaseAppState<>,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
       +payload: SimpleMessagesPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawTextMessageInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawMultimediaMessageInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawReactionMessageInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
         +targetMessageID: string,
         +reaction: string,
         +action: string,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_SUCCESS',
       +payload: UserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_SUCCESS',
       +payload: ExactUserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_DRAFT',
       +payload: {
         +key: string,
         +text: string,
       },
     }
   | {
       +type: 'MOVE_DRAFT',
       +payload: {
         +oldKey: string,
         +newKey: string,
       },
     }
   | {
       +type: 'SET_CLIENT_DB_STORE',
       +payload: ClientStore,
     }
   | {
       +type: 'UPDATE_ACTIVITY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_SUCCESS',
       +payload: ActivityUpdateSuccessPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_SUCCESS',
       +payload: SetDeviceTokenActionPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'QUEUE_REPORTS',
       +payload: QueueReportsPayload,
     }
   | {
       +type: 'SET_URL_PREFIX',
       +payload: string,
     }
   | {
       +type: 'SAVE_MESSAGES',
       +payload: SaveMessagesPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_THREAD_FILTER',
       +payload: CalendarThreadFilter,
     }
   | {
       +type: 'CLEAR_CALENDAR_THREAD_FILTER',
       +payload?: void,
     }
   | {
       +type: 'SET_CALENDAR_DELETED_FILTER',
       +payload: SetCalendarDeletedFilterPayload,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_SUCCESS',
       +payload: SubscriptionUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload?: CalendarQueryUpdateStartingPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
       +payload: CalendarQueryUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FULL_STATE_SYNC',
       +payload: StateSyncFullActionPayload,
     }
   | {
       +type: 'INCREMENTAL_STATE_SYNC',
       +payload: StateSyncIncrementalActionPayload,
     }
   | ProcessServerRequestAction
   | {
       +type: 'UPDATE_CONNECTION_STATUS',
       +payload: UpdateConnectionStatusPayload,
     }
   | {
       +type: 'QUEUE_ACTIVITY_UPDATES',
       +payload: QueueActivityUpdatesPayload,
     }
   | {
       +type: 'UNSUPERVISED_BACKGROUND',
       +payload: { +keyserverID: string },
     }
   | {
       +type: 'UPDATE_LIFECYCLE_STATE',
       +payload: LifecycleState,
     }
   | {
       +type: 'ENABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'DISABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'UPDATE_REPORTS_ENABLED',
       +payload: Partial<EnabledReports>,
     }
   | {
       +type: 'PROCESS_UPDATES',
       +payload: ClientUpdatesResultWithUserInfos,
     }
   | {
       +type: 'PROCESS_MESSAGES',
       +payload: NewMessagesPayload,
     }
   | {
       +type: 'MESSAGE_STORE_PRUNE',
       +payload: MessageStorePrunePayload,
     }
   | {
       +type: 'SET_LATE_RESPONSE',
       +payload: SetLateResponsePayload,
     }
   | {
       +type: 'UPDATE_DISCONNECTED_BAR',
       +payload: UpdateDisconnectedBarPayload,
     }
   | {
       +type: 'REQUEST_ACCESS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
       +payload: UpdateMultimediaMessageMediaPayload,
     }
   | {
       +type: 'CREATE_LOCAL_MESSAGE',
       +payload: LocallyComposedMessageInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_SUCCESS',
       +payload: RelationshipErrors,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_STARTED',
       +payload: {
         +threadID: string,
         +unread: boolean,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
       +payload: SetThreadUnreadStatusPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_USER_SETTINGS_SUCCESS',
       +payload: DefaultNotificationPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_FAILED',
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_SUCCESS',
       +payload: MessageReportCreationResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FORCE_POLICY_ACKNOWLEDGMENT',
       +payload: ForcePolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
       +payload: PolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_STARTED',
       +payload: LogInStartingPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RECORD_NOTIF_PERMISSION_ALERT',
       +payload: { +time: number },
     }
   | {
       +type: 'UPDATE_USER_AVATAR_STARTED',
       +payload: UpdateUserAvatarRequest,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_SUCCESS',
       +payload: UpdateUserAvatarResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_SUCCESS',
       +payload: EditMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
       +payload: ToggleMessagePinResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_SUCCESS',
       +payload: FetchPinnedMessagesResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_SUCCESS',
       +payload: InviteLinkVerificationResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
       +payload: FetchInviteLinksResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'UPDATE_CHAT_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CHAT_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'SEARCH_MESSAGES_STARTED',
       +payload: void,
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_SUCCESS',
       +payload: SearchMessagesResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
       +payload: InviteLink,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_SUCCESS',
       +payload: DisableInviteLinkPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
       +payload: GetOlmSessionInitializationDataResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DATA_LOADED',
       +payload: {
         +dataLoaded: boolean,
       },
     }
   | {
       +type: 'GET_VERSION_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'GET_VERSION_SUCCESS',
       +payload: GetVersionActionPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_VERSION_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS',
       +payload: LastCommunicatedPlatformDetails,
     }
   | { +type: 'RESET_USER_STATE', +payload?: void }
   | {
       +type: 'MODIFY_COMMUNITY_ROLE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
       +payload: RoleModificationPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'MODIFY_COMMUNITY_ROLE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_COMMUNITY_ROLE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'DELETE_COMMUNITY_ROLE_SUCCESS',
       +payload: RoleDeletionPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_COMMUNITY_ROLE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_ACCESS_TOKEN',
       +payload: string,
     }
   | {
       +type: 'UPDATE_THREAD_LAST_NAVIGATED',
       +payload: { +threadID: string, +time: number },
     }
   | {
       +type: 'UPDATE_INTEGRITY_STORE',
       +payload: {
         +threadIDsToHash?: $ReadOnlyArray<string>,
         +threadHashingStatus?: 'starting' | 'running' | 'completed',
       },
     }
   | {
       +type: 'UPDATE_THEME_INFO',
       +payload: Partial<GlobalThemeInfo>,
     }
   | {
       +type: 'ADD_KEYSERVER',
       +payload: AddKeyserverPayload,
     }
   | {
       +type: 'REMOVE_KEYSERVER',
       +payload: RemoveKeyserverPayload,
     };
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type SuperAction = {
   type: string,
   payload?: ActionPayload,
   loadingInfo?: LoadingInfo,
   error?: boolean,
 };
 type ThunkedAction = (dispatch: Dispatch) => void;
 export type PromisedAction = (dispatch: Dispatch) => Promise<void>;
 export type Dispatch = ((promisedAction: PromisedAction) => Promise<void>) &
   ((thunkedAction: ThunkedAction) => void) &
   ((action: SuperAction) => boolean);
 
 // This is lifted from redux-persist/lib/constants.js
 // I don't want to add redux-persist to the web/server bundles...
 // import { REHYDRATE } from 'redux-persist';
 export const rehydrateActionType = 'persist/REHYDRATE';
diff --git a/native/profile/delete-account.react.js b/native/profile/delete-account.react.js
index b5c3ff020..43966efd3 100644
--- a/native/profile/delete-account.react.js
+++ b/native/profile/delete-account.react.js
@@ -1,122 +1,122 @@
 // @flow
 
 import * as React from 'react';
 import { Text, View, ActivityIndicator } from 'react-native';
 import { ScrollView } from 'react-native-gesture-handler';
 
 import {
-  deleteAccountActionTypes,
-  useDeleteAccount,
+  deleteKeyserverAccountActionTypes,
+  useDeleteKeyserverAccount,
 } from 'lib/actions/user-actions.js';
 import { preRequestUserStateSelector } from 'lib/selectors/account-selectors.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import { deleteNativeCredentialsFor } from '../account/native-credentials.js';
 import Button from '../components/button.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 import Alert from '../utils/alert.js';
 
 const loadingStatusSelector = createLoadingStatusSelector(
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
 );
 
 type Props = {
   +navigation: ProfileNavigationProp<'DeleteAccount'>,
   +route: NavigationRoute<'DeleteAccount'>,
 };
 const DeleteAccount: React.ComponentType<Props> = React.memo<Props>(
   function DeleteAccount() {
     const loadingStatus = useSelector(loadingStatusSelector);
     const preRequestUserState = useSelector(preRequestUserStateSelector);
     const styles = useStyles(unboundStyles);
 
     const dispatchActionPromise = useDispatchActionPromise();
-    const callDeleteAccount = useDeleteAccount();
+    const callDeleteAccount = useDeleteKeyserverAccount();
 
     const buttonContent =
       loadingStatus === 'loading' ? (
         <ActivityIndicator size="small" color="white" />
       ) : (
         <Text style={styles.saveText}>Delete account</Text>
       );
 
     const noWayToReverseThisStyles = React.useMemo(
       () => [styles.warningText, styles.lastWarningText],
       [styles.warningText, styles.lastWarningText],
     );
 
     const deleteAction = React.useCallback(async () => {
       try {
         await deleteNativeCredentialsFor();
         return await callDeleteAccount(preRequestUserState);
       } catch (e) {
         Alert.alert('Unknown error', 'Uhh... try again?', [{ text: 'OK' }], {
           cancelable: false,
         });
         throw e;
       }
     }, [callDeleteAccount, preRequestUserState]);
 
     const onDelete = React.useCallback(() => {
-      dispatchActionPromise(deleteAccountActionTypes, deleteAction());
+      dispatchActionPromise(deleteKeyserverAccountActionTypes, deleteAction());
     }, [dispatchActionPromise, deleteAction]);
 
     return (
       <ScrollView
         contentContainerStyle={styles.scrollViewContentContainer}
         style={styles.scrollView}
       >
         <View>
           <Text style={styles.warningText}>
             Your account will be permanently deleted.
           </Text>
         </View>
         <View>
           <Text style={noWayToReverseThisStyles}>
             There is no way to reverse this.
           </Text>
         </View>
         <Button onPress={onDelete} style={styles.deleteButton}>
           {buttonContent}
         </Button>
       </ScrollView>
     );
   },
 );
 
 const unboundStyles = {
   deleteButton: {
     backgroundColor: 'vibrantRedButton',
     borderRadius: 5,
     flex: 1,
     marginHorizontal: 24,
     marginVertical: 12,
     padding: 12,
   },
   lastWarningText: {
     marginBottom: 24,
   },
   saveText: {
     color: 'white',
     fontSize: 18,
     textAlign: 'center',
   },
   scrollView: {
     backgroundColor: 'panelBackground',
   },
   scrollViewContentContainer: {
     paddingTop: 24,
   },
   warningText: {
     color: 'panelForegroundLabel',
     fontSize: 16,
     marginHorizontal: 24,
     textAlign: 'center',
   },
 };
 
 export default DeleteAccount;
diff --git a/native/redux/redux-setup.js b/native/redux/redux-setup.js
index 435997160..c790101bc 100644
--- a/native/redux/redux-setup.js
+++ b/native/redux/redux-setup.js
@@ -1,388 +1,388 @@
 // @flow
 
 import { AppState as NativeAppState, Alert } from 'react-native';
 import { createStore, applyMiddleware, type Store, compose } from 'redux';
 import { persistStore, persistReducer } from 'redux-persist';
 import thunk from 'redux-thunk';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import { siweAuthActionTypes } from 'lib/actions/siwe-actions.js';
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
   logInActionTypes,
 } from 'lib/actions/user-actions.js';
 import type { ThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import baseReducer from 'lib/reducers/master-reducer.js';
 import {
   invalidSessionDowngrade,
   invalidSessionRecovery,
 } from 'lib/shared/session-utils.js';
 import { isStaff } from 'lib/shared/staff-utils.js';
 import type { Dispatch, BaseAction } from 'lib/types/redux-types.js';
 import { rehydrateActionType } from 'lib/types/redux-types.js';
 import type { SetSessionPayload } from 'lib/types/session-types.js';
 import { reduxLoggerMiddleware } from 'lib/utils/action-logger.js';
 import { setNewSessionActionType } from 'lib/utils/action-utils.js';
 
 import {
   updateDimensionsActiveType,
   updateConnectivityActiveType,
   updateDeviceCameraInfoActionType,
   updateDeviceOrientationActionType,
   backgroundActionTypes,
   setReduxStateActionType,
   setStoreLoadedActionType,
   type Action,
   setLocalSettingsActionType,
 } from './action-types.js';
 import { defaultState } from './default-state.js';
 import { remoteReduxDevServerConfig } from './dev-tools.js';
 import { persistConfig, setPersistor } from './persist.js';
 import { onStateDifference } from './redux-debug-utils.js';
 import { processDBStoreOperations } from './redux-utils.js';
 import type { AppState } from './state-types.js';
 import { getGlobalNavContext } from '../navigation/icky-global.js';
 import { activeMessageListSelector } from '../navigation/nav-selectors.js';
 import reactotron from '../reactotron.js';
 import { AppOutOfDateAlertDetails } from '../utils/alert-messages.js';
 import { isStaffRelease } from '../utils/staff-utils.js';
 import { setCustomServer, getDevServerHostname } from '../utils/url-utils.js';
 
 function reducer(state: AppState = defaultState, action: Action) {
   if (action.type === setReduxStateActionType) {
     return action.payload.state;
   }
 
   // We want to alert staff/developers if there's a difference between the keys
   // we expect to see REHYDRATED and the keys that are actually REHYDRATED.
   // Context: https://linear.app/comm/issue/ENG-2127/
   if (
     action.type === rehydrateActionType &&
     (__DEV__ ||
       isStaffRelease ||
       (state.currentUserInfo &&
         state.currentUserInfo.id &&
         isStaff(state.currentUserInfo.id)))
   ) {
     // 1. Construct set of keys expected to be REHYDRATED
     const defaultKeys: $ReadOnlyArray<string> = Object.keys(defaultState);
     const expectedKeys = defaultKeys.filter(
       each => !persistConfig.blacklist.includes(each),
     );
     const expectedKeysSet = new Set(expectedKeys);
 
     // 2. Construct set of keys actually REHYDRATED
     const rehydratedKeys: $ReadOnlyArray<string> = Object.keys(
       action.payload ?? {},
     );
     const rehydratedKeysSet = new Set(rehydratedKeys);
 
     // 3. Determine the difference between the two sets
     const expectedKeysNotRehydrated = expectedKeys.filter(
       each => !rehydratedKeysSet.has(each),
     );
     const rehydratedKeysNotExpected = rehydratedKeys.filter(
       each => !expectedKeysSet.has(each),
     );
 
     // 4. Display alerts with the differences between the two sets
     if (expectedKeysNotRehydrated.length > 0) {
       Alert.alert(
         `EXPECTED KEYS NOT REHYDRATED: ${JSON.stringify(
           expectedKeysNotRehydrated,
         )}`,
       );
     }
     if (rehydratedKeysNotExpected.length > 0) {
       Alert.alert(
         `REHYDRATED KEYS NOT EXPECTED: ${JSON.stringify(
           rehydratedKeysNotExpected,
         )}`,
       );
     }
   }
 
   if (
     (action.type === setNewSessionActionType &&
       invalidSessionDowngrade(
         state,
         action.payload.sessionChange.currentUserInfo,
         action.payload.preRequestUserState,
       )) ||
     (action.type === logOutActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
       )) ||
-    (action.type === deleteAccountActionTypes.success &&
+    (action.type === deleteKeyserverAccountActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
       ))
   ) {
     return state;
   }
   if (
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.currentUserInfo &&
       invalidSessionRecovery(
         state,
         action.payload.sessionChange.currentUserInfo,
         action.payload.logInActionSource,
       )) ||
     ((action.type === logInActionTypes.success ||
       action.type === siweAuthActionTypes.success) &&
       invalidSessionRecovery(
         state,
         action.payload.currentUserInfo,
         action.payload.logInActionSource,
       ))
   ) {
     return state;
   }
 
   if (action.type === setCustomServer) {
     return {
       ...state,
       customServer: action.payload,
     };
   } else if (action.type === updateDimensionsActiveType) {
     return {
       ...state,
       dimensions: {
         ...state.dimensions,
         ...action.payload,
       },
     };
   } else if (action.type === updateConnectivityActiveType) {
     return {
       ...state,
       connectivity: action.payload,
     };
   } else if (action.type === updateDeviceCameraInfoActionType) {
     return {
       ...state,
       deviceCameraInfo: {
         ...state.deviceCameraInfo,
         ...action.payload,
       },
     };
   } else if (action.type === updateDeviceOrientationActionType) {
     return {
       ...state,
       deviceOrientation: action.payload,
     };
   } else if (action.type === setLocalSettingsActionType) {
     return {
       ...state,
       localSettings: { ...state.localSettings, ...action.payload },
     };
   } else if (
     action.type === logOutActionTypes.started ||
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success
+    action.type === deleteKeyserverAccountActionTypes.success
   ) {
     state = {
       ...state,
       localSettings: {
         isBackupEnabled: false,
       },
     };
   }
 
   if (action.type === setNewSessionActionType) {
     sessionInvalidationAlert(action.payload);
   }
   if (action.type === setStoreLoadedActionType) {
     return {
       ...state,
       storeLoaded: true,
     };
   }
   if (action.type === setClientDBStoreActionType) {
     state = {
       ...state,
       storeLoaded: true,
     };
     const currentLoggedInUserID = state.currentUserInfo?.anonymous
       ? undefined
       : state.currentUserInfo?.id;
     const actionCurrentLoggedInUserID = action.payload.currentUserID;
     if (
       !currentLoggedInUserID ||
       !actionCurrentLoggedInUserID ||
       actionCurrentLoggedInUserID !== currentLoggedInUserID
     ) {
       // If user is logged out now, was logged out at the time action was
       // dispatched or their ID changed between action dispatch and a
       // call to reducer we ignore the SQLite data since it is not valid
       return state;
     }
   }
 
   const baseReducerResult = baseReducer(
     state,
     (action: BaseAction),
     onStateDifference,
   );
   state = baseReducerResult.state;
 
   const { storeOperations } = baseReducerResult;
   const {
     draftStoreOperations,
     threadStoreOperations,
     messageStoreOperations,
     reportStoreOperations,
     userStoreOperations,
   } = storeOperations;
 
   const fixUnreadActiveThreadResult = fixUnreadActiveThread(state, action);
   state = fixUnreadActiveThreadResult.state;
 
   const threadStoreOperationsWithUnreadFix = [
     ...threadStoreOperations,
     ...fixUnreadActiveThreadResult.threadStoreOperations,
   ];
 
   processDBStoreOperations({
     draftStoreOperations,
     messageStoreOperations,
     threadStoreOperations: threadStoreOperationsWithUnreadFix,
     reportStoreOperations,
     userStoreOperations,
   });
 
   return state;
 }
 
 function sessionInvalidationAlert(payload: SetSessionPayload) {
   if (
     !payload.sessionChange.cookieInvalidated ||
     !payload.preRequestUserState ||
     !payload.preRequestUserState.currentUserInfo ||
     payload.preRequestUserState.currentUserInfo.anonymous
   ) {
     return;
   }
   if (payload.error === 'client_version_unsupported') {
     Alert.alert(
       AppOutOfDateAlertDetails.title,
       AppOutOfDateAlertDetails.message,
       [{ text: 'OK' }],
       {
         cancelable: true,
       },
     );
   } else {
     Alert.alert(
       'Session invalidated',
       'We’re sorry, but your session was invalidated by the server. ' +
         'Please log in again.',
       [{ text: 'OK' }],
       { cancelable: true },
     );
   }
 }
 
 // Makes sure a currently focused thread is never unread. Note that we consider
 // a backgrounded NativeAppState to actually be active if it last changed to
 // inactive more than 10 seconds ago. This is because there is a delay when
 // NativeAppState is updating in response to a foreground, and actions don't get
 // processed more than 10 seconds after a backgrounding anyways. However we
 // don't consider this for action types that can be expected to happen while the
 // app is backgrounded.
 type FixUnreadActiveThreadResult = {
   +state: AppState,
   +threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 };
 
 function fixUnreadActiveThread(
   state: AppState,
   action: *,
 ): FixUnreadActiveThreadResult {
   const navContext = getGlobalNavContext();
   const activeThread = activeMessageListSelector(navContext);
   if (
     !activeThread ||
     !state.threadStore.threadInfos[activeThread]?.currentUser.unread ||
     (NativeAppState.currentState !== 'active' &&
       (appLastBecameInactive + 10000 >= Date.now() ||
         backgroundActionTypes.has(action.type)))
   ) {
     return { state, threadStoreOperations: [] };
   }
 
   const updatedActiveThreadInfo = {
     ...state.threadStore.threadInfos[activeThread],
     currentUser: {
       ...state.threadStore.threadInfos[activeThread].currentUser,
       unread: false,
     },
   };
 
   const threadStoreOperations = [
     {
       type: 'replace',
       payload: {
         id: activeThread,
         threadInfo: updatedActiveThreadInfo,
       },
     },
   ];
 
   const updatedThreadStore = threadStoreOpsHandlers.processStoreOperations(
     state.threadStore,
     threadStoreOperations,
   );
 
   return {
     state: { ...state, threadStore: updatedThreadStore },
     threadStoreOperations,
   };
 }
 
 let appLastBecameInactive = 0;
 
 function appBecameInactive() {
   appLastBecameInactive = Date.now();
 }
 
 const middleware = applyMiddleware(thunk, reduxLoggerMiddleware);
 
 let composeFunc = compose;
 if (__DEV__ && global.HermesInternal) {
   const { composeWithDevTools } = require('remote-redux-devtools/src/index.js');
   composeFunc = composeWithDevTools({
     name: 'Redux',
     hostname: getDevServerHostname(),
     ...remoteReduxDevServerConfig,
   });
 } else if (global.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) {
   composeFunc = global.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
     name: 'Redux',
   });
 }
 
 let enhancers;
 if (reactotron) {
   enhancers = composeFunc(middleware, reactotron.createEnhancer());
 } else {
   enhancers = composeFunc(middleware);
 }
 
 const store: Store<AppState, *> = createStore(
   persistReducer(persistConfig, reducer),
   defaultState,
   enhancers,
 );
 const persistor = persistStore(store);
 setPersistor(persistor);
 
 const unsafeDispatch: any = store.dispatch;
 const dispatch: Dispatch = unsafeDispatch;
 
 export { store, dispatch, appBecameInactive };
diff --git a/web/redux/crypto-store-reducer.js b/web/redux/crypto-store-reducer.js
index cafc9f905..a5b52c98f 100644
--- a/web/redux/crypto-store-reducer.js
+++ b/web/redux/crypto-store-reducer.js
@@ -1,28 +1,28 @@
 // @flow
 
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
 } from 'lib/actions/user-actions.js';
 import type { CryptoStore } from 'lib/types/crypto-types.js';
 import { setNewSessionActionType } from 'lib/utils/action-utils.js';
 
 import type { Action } from './redux-setup.js';
 
 const setCryptoStore = 'SET_CRYPTO_STORE';
 
 function reduceCryptoStore(state: ?CryptoStore, action: Action): ?CryptoStore {
   if (action.type === setCryptoStore) {
     return action.payload;
   } else if (
     action.type === logOutActionTypes.success ||
-    action.type === deleteAccountActionTypes.success ||
+    action.type === deleteKeyserverAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return null;
   }
   return state;
 }
 
 export { setCryptoStore, reduceCryptoStore };
diff --git a/web/redux/redux-setup.js b/web/redux/redux-setup.js
index d74bf6ee6..af62573af 100644
--- a/web/redux/redux-setup.js
+++ b/web/redux/redux-setup.js
@@ -1,346 +1,346 @@
 // @flow
 
 import invariant from 'invariant';
 import type { PersistState } from 'redux-persist/es/types.js';
 
 import {
   logOutActionTypes,
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
 } from 'lib/actions/user-actions.js';
 import {
   type ThreadStoreOperation,
   threadStoreOpsHandlers,
 } from 'lib/ops/thread-store-ops.js';
 import baseReducer from 'lib/reducers/master-reducer.js';
 import { mostRecentlyReadThreadSelector } from 'lib/selectors/thread-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { invalidSessionDowngrade } from 'lib/shared/session-utils.js';
 import type { CryptoStore } from 'lib/types/crypto-types.js';
 import type { DraftStore } from 'lib/types/draft-types.js';
 import type { EnabledApps } from 'lib/types/enabled-apps.js';
 import type { EntryStore, CalendarQuery } from 'lib/types/entry-types.js';
 import { type CalendarFilter } from 'lib/types/filter-types.js';
 import type { IntegrityStore } from 'lib/types/integrity-types.js';
 import type { KeyserverStore } from 'lib/types/keyserver-types.js';
 import type { LifecycleState } from 'lib/types/lifecycle-state-types.js';
 import type { InviteLinksStore } from 'lib/types/link-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { MessageStore } from 'lib/types/message-types.js';
 import type { UserPolicies } from 'lib/types/policy-types.js';
 import type { BaseAction } from 'lib/types/redux-types.js';
 import type { ReportStore } from 'lib/types/report-types.js';
 import type { StoreOperations } from 'lib/types/store-ops-types.js';
 import type { GlobalThemeInfo } from 'lib/types/theme-types.js';
 import type { ThreadActivityStore } from 'lib/types/thread-activity-types';
 import type { ThreadStore } from 'lib/types/thread-types.js';
 import type { CurrentUserInfo, UserStore } from 'lib/types/user-types.js';
 import { setNewSessionActionType } from 'lib/utils/action-utils.js';
 import type { NotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   updateWindowActiveActionType,
   updateNavInfoActionType,
   updateWindowDimensionsActionType,
   setInitialReduxState,
 } from './action-types.js';
 import { reduceCommunityPickerStore } from './community-picker-reducer.js';
 import { reduceCryptoStore, setCryptoStore } from './crypto-store-reducer.js';
 import reduceNavInfo from './nav-reducer.js';
 import { onStateDifference } from './redux-debug-utils.js';
 import { getVisibility } from './visibility.js';
 import { processDBStoreOperations } from '../database/utils/store.js';
 import { activeThreadSelector } from '../selectors/nav-selectors.js';
 import { type NavInfo } from '../types/nav-types.js';
 import type { InitialReduxState } from '../types/redux-types.js';
 
 export type WindowDimensions = { width: number, height: number };
 
 export type CommunityPickerStore = {
   +chat: ?string,
   +calendar: ?string,
 };
 
 export type AppState = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +communityPickerStore: CommunityPickerStore,
   +windowDimensions: WindowDimensions,
   +notifPermissionAlertInfo: NotifPermissionAlertInfo,
   +actualizedCalendarQuery: CalendarQuery,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +nextLocalID: number,
   +dataLoaded: boolean,
   +windowActive: boolean,
   +userPolicies: UserPolicies,
   +cryptoStore: ?CryptoStore,
   +pushApiPublicKey: ?string,
   +_persist: ?PersistState,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +initialStateLoaded: boolean,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
 };
 
 export type Action =
   | BaseAction
   | { type: 'UPDATE_NAV_INFO', payload: Partial<NavInfo> }
   | {
       type: 'UPDATE_WINDOW_DIMENSIONS',
       payload: WindowDimensions,
     }
   | {
       type: 'UPDATE_WINDOW_ACTIVE',
       payload: boolean,
     }
   | { +type: 'SET_CRYPTO_STORE', payload: CryptoStore }
   | { +type: 'SET_INITIAL_REDUX_STATE', payload: InitialReduxState };
 
 export function reducer(oldState: AppState | void, action: Action): AppState {
   invariant(oldState, 'should be set');
   let state = oldState;
   let storeOperations: StoreOperations = {
     draftStoreOperations: [],
     threadStoreOperations: [],
     messageStoreOperations: [],
     reportStoreOperations: [],
     userStoreOperations: [],
   };
 
   if (action.type === setInitialReduxState) {
     const { userInfos, keyserverInfos, ...rest } = action.payload;
     const newKeyserverInfos = { ...state.keyserverStore.keyserverInfos };
     for (const keyserverID in keyserverInfos) {
       newKeyserverInfos[keyserverID] = {
         ...newKeyserverInfos[keyserverID],
         ...keyserverInfos[keyserverID],
       };
     }
     return validateStateAndProcessDBOperations(
       oldState,
       {
         ...state,
         ...rest,
         userStore: { userInfos },
         keyserverStore: {
           ...state.keyserverStore,
           keyserverInfos: newKeyserverInfos,
         },
         initialStateLoaded: true,
       },
       storeOperations,
     );
   } else if (action.type === updateWindowDimensionsActionType) {
     return validateStateAndProcessDBOperations(
       oldState,
       {
         ...state,
         windowDimensions: action.payload,
       },
       storeOperations,
     );
   } else if (action.type === updateWindowActiveActionType) {
     return validateStateAndProcessDBOperations(
       oldState,
       {
         ...state,
         windowActive: action.payload,
       },
       storeOperations,
     );
   } else if (action.type === setNewSessionActionType) {
     if (
       invalidSessionDowngrade(
         oldState,
         action.payload.sessionChange.currentUserInfo,
         action.payload.preRequestUserState,
       )
     ) {
       return oldState;
     }
 
     state = {
       ...state,
       keyserverStore: {
         ...state.keyserverStore,
         keyserverInfos: {
           ...state.keyserverStore.keyserverInfos,
           [ashoatKeyserverID]: {
             ...state.keyserverStore.keyserverInfos[ashoatKeyserverID],
             sessionID: action.payload.sessionChange.sessionID,
           },
         },
       },
     };
   } else if (
     (action.type === logOutActionTypes.success &&
       invalidSessionDowngrade(
         oldState,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
       )) ||
-    (action.type === deleteAccountActionTypes.success &&
+    (action.type === deleteKeyserverAccountActionTypes.success &&
       invalidSessionDowngrade(
         oldState,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
       ))
   ) {
     return oldState;
   }
 
   if (
     action.type !== updateNavInfoActionType &&
     action.type !== setCryptoStore
   ) {
     const baseReducerResult = baseReducer(state, action, onStateDifference);
     state = baseReducerResult.state;
     storeOperations = baseReducerResult.storeOperations;
   }
 
   const communityPickerStore = reduceCommunityPickerStore(
     state.communityPickerStore,
     action,
   );
 
   state = {
     ...state,
     navInfo: reduceNavInfo(
       state.navInfo,
       action,
       state.threadStore.threadInfos,
     ),
     cryptoStore: reduceCryptoStore(state.cryptoStore, action),
     communityPickerStore,
   };
 
   return validateStateAndProcessDBOperations(oldState, state, storeOperations);
 }
 
 function validateStateAndProcessDBOperations(
   oldState: AppState,
   state: AppState,
   storeOperations: StoreOperations,
 ): AppState {
   const updateActiveThreadOps: ThreadStoreOperation[] = [];
   if (
     (state.navInfo.activeChatThreadID &&
       !state.navInfo.pendingThread &&
       !state.threadStore.threadInfos[state.navInfo.activeChatThreadID]) ||
     (!state.navInfo.activeChatThreadID && isLoggedIn(state))
   ) {
     // Makes sure the active thread always exists
     state = {
       ...state,
       navInfo: {
         ...state.navInfo,
         activeChatThreadID: mostRecentlyReadThreadSelector(state),
       },
     };
   }
 
   const activeThread = activeThreadSelector(state);
   if (
     activeThread &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread &&
     getVisibility().hidden()
   ) {
     console.warn(
       `thread ${activeThread} is active and unread, ` +
         'but visibilityjs reports the window is not visible',
     );
   }
   if (
     activeThread &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread &&
     typeof document !== 'undefined' &&
     document &&
     'hasFocus' in document &&
     !document.hasFocus()
   ) {
     console.warn(
       `thread ${activeThread} is active and unread, ` +
         'but document.hasFocus() is false',
     );
   }
   if (
     activeThread &&
     !getVisibility().hidden() &&
     typeof document !== 'undefined' &&
     document &&
     'hasFocus' in document &&
     document.hasFocus() &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread
   ) {
     // Makes sure a currently focused thread is never unread
     updateActiveThreadOps.push({
       type: 'replace',
       payload: {
         id: activeThread,
         threadInfo: {
           ...state.threadStore.threadInfos[activeThread],
           currentUser: {
             ...state.threadStore.threadInfos[activeThread].currentUser,
             unread: false,
           },
         },
       },
     });
   }
 
   const oldActiveThread = activeThreadSelector(oldState);
   if (
     activeThread &&
     oldActiveThread !== activeThread &&
     state.messageStore.threads[activeThread]
   ) {
     const now = Date.now();
     state = {
       ...state,
       threadActivityStore: {
         ...state.threadActivityStore,
         [(activeThread: string)]: {
           ...state.threadActivityStore[activeThread],
           lastNavigatedTo: now,
         },
       },
     };
   }
 
   if (updateActiveThreadOps.length > 0) {
     state = {
       ...state,
       threadStore: threadStoreOpsHandlers.processStoreOperations(
         state.threadStore,
         updateActiveThreadOps,
       ),
     };
     storeOperations = {
       ...storeOperations,
       threadStoreOperations: [
         ...storeOperations.threadStoreOperations,
         ...updateActiveThreadOps,
       ],
     };
   }
 
   processDBStoreOperations(storeOperations, state.currentUserInfo?.id);
 
   return state;
 }
diff --git a/web/settings/account-delete-modal.react.js b/web/settings/account-delete-modal.react.js
index 520065bd5..caba58148 100644
--- a/web/settings/account-delete-modal.react.js
+++ b/web/settings/account-delete-modal.react.js
@@ -1,90 +1,93 @@
 // @flow
 
 import * as React from 'react';
 
 import {
-  useDeleteAccount,
-  deleteAccountActionTypes,
+  useDeleteKeyserverAccount,
+  deleteKeyserverAccountActionTypes,
 } from 'lib/actions/user-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import { preRequestUserStateSelector } from 'lib/selectors/account-selectors.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import css from './account-delete-modal.css';
 import Button, { buttonThemes } from '../components/button.react.js';
 import Modal from '../modals/modal.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 const deleteAccountLoadingStatusSelector = createLoadingStatusSelector(
-  deleteAccountActionTypes,
+  deleteKeyserverAccountActionTypes,
 );
 
 const AccountDeleteModal: React.ComponentType<{}> = React.memo<{}>(
   function AccountDeleteModal(): React.Node {
     const preRequestUserState = useSelector(preRequestUserStateSelector);
     const inputDisabled = useSelector(
       state => deleteAccountLoadingStatusSelector(state) === 'loading',
     );
-    const callDeleteAccount = useDeleteAccount();
+    const callDeleteAccount = useDeleteKeyserverAccount();
     const dispatchActionPromise = useDispatchActionPromise();
 
     const { popModal } = useModalContext();
 
     const [errorMessage, setErrorMessage] = React.useState('');
 
     let errorMsg;
     if (errorMessage) {
       errorMsg = <div className={css.form_error}>{errorMessage}</div>;
     }
 
     const deleteAction = React.useCallback(async () => {
       try {
         setErrorMessage('');
         const response = await callDeleteAccount(preRequestUserState);
         popModal();
         return response;
       } catch (e) {
         setErrorMessage('unknown error');
         throw e;
       }
     }, [callDeleteAccount, preRequestUserState, popModal]);
 
     const onDelete = React.useCallback(
       (event: SyntheticEvent<HTMLButtonElement>) => {
         event.preventDefault();
-        dispatchActionPromise(deleteAccountActionTypes, deleteAction());
+        dispatchActionPromise(
+          deleteKeyserverAccountActionTypes,
+          deleteAction(),
+        );
       },
       [dispatchActionPromise, deleteAction],
     );
 
     return (
       <Modal name="Delete Account" onClose={popModal} size="large">
         <div className={css.modal_body}>
           <form method="POST">
             <SWMansionIcon icon="warning-circle" size={22} />
             <p className={css.deletion_warning}>
               Your account will be permanently deleted. There is no way to
               reverse this.
             </p>
             <div className={css.form_footer}>
               <Button
                 variant="filled"
                 buttonColor={buttonThemes.danger}
                 type="submit"
                 onClick={onDelete}
                 disabled={inputDisabled}
               >
                 Delete Account
               </Button>
               {errorMsg}
             </div>
           </form>
         </div>
       </Modal>
     );
   },
 );
 
 export default AccountDeleteModal;