diff --git a/lib/actions/user-actions.js b/lib/actions/user-actions.js
index 158960c6e..d7351005f 100644
--- a/lib/actions/user-actions.js
+++ b/lib/actions/user-actions.js
@@ -1,350 +1,353 @@
 // @flow
 
 import threadWatcher from '../shared/thread-watcher.js';
 import type {
   LogOutResult,
   LogInInfo,
   LogInResult,
   RegisterResult,
   RegisterInfo,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
 } from '../types/account-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from '../types/avatar-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 { UserInfo, PasswordUpdate } from '../types/user-types.js';
 import type {
   CallServerEndpoint,
   CallServerEndpointOptions,
 } from '../utils/call-server-endpoint.js';
 import { getConfig } from '../utils/config.js';
 import sleep from '../utils/sleep.js';
 
 const logOutActionTypes = Object.freeze({
   started: 'LOG_OUT_STARTED',
   success: 'LOG_OUT_SUCCESS',
   failed: 'LOG_OUT_FAILED',
 });
 const logOut =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((preRequestUserState: PreRequestUserState) => Promise<LogOutResult>) =>
   async preRequestUserState => {
     let response = null;
     try {
       response = await Promise.race([
         callServerEndpoint('log_out', {}),
         (async () => {
           await sleep(500);
           throw new Error('log_out took more than 500ms');
         })(),
       ]);
     } catch {}
     const currentUserInfo = response ? response.currentUserInfo : null;
     return { currentUserInfo, preRequestUserState };
   };
 
 const deleteAccountActionTypes = Object.freeze({
   started: 'DELETE_ACCOUNT_STARTED',
   success: 'DELETE_ACCOUNT_SUCCESS',
   failed: 'DELETE_ACCOUNT_FAILED',
 });
 const deleteAccount =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     password: ?string,
     preRequestUserState: PreRequestUserState,
   ) => Promise<LogOutResult>) =>
   async (password, preRequestUserState) => {
     const response = await callServerEndpoint('delete_account', { password });
     return { currentUserInfo: response.currentUserInfo, preRequestUserState };
   };
 
 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 response = await callServerEndpoint(
       'create_account',
       {
         ...registerInfo,
         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: UserInfo[][]): UserInfo[] {
   const merged = {};
   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;
 }
 
 const logInActionTypes = Object.freeze({
   started: 'LOG_IN_STARTED',
   success: 'LOG_IN_SUCCESS',
   failed: 'LOG_IN_FAILED',
 });
 const logInCallServerEndpointOptions = { timeout: 60000 };
 const logIn =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((logInInfo: LogInInfo) => Promise<LogInResult>) =>
   async logInInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
     const { logInActionSource, ...restLogInInfo } = logInInfo;
 
     const response = await callServerEndpoint(
       'log_in',
       {
         ...restLogInInfo,
         source: logInActionSource,
         watchedIDs,
         platformDetails: getConfig().platformDetails,
       },
       logInCallServerEndpointOptions,
     );
     const userInfos = mergeUserInfos(
       response.userInfos,
       response.cookieChange.userInfos,
     );
     return {
       threadInfos: response.cookieChange.threadInfos,
       currentUserInfo: response.currentUserInfo,
       calendarResult: {
         calendarQuery: logInInfo.calendarQuery,
         rawEntryInfos: response.rawEntryInfos,
       },
       messagesResult: {
         messageInfos: response.rawMessageInfos,
         truncationStatus: response.truncationStatuses,
         watchedIDsAtRequestTime: watchedIDs,
         currentAsOf: response.serverTime,
       },
       userInfos,
       updatesCurrentAsOf: response.serverTime,
       logInActionSource: logInInfo.logInActionSource,
       notAcknowledgedPolicies: response.notAcknowledgedPolicies,
     };
   };
 
 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 =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     subscriptionUpdate: SubscriptionUpdateRequest,
   ) => Promise<SubscriptionUpdateResult>) =>
   async subscriptionUpdate => {
     const response = await callServerEndpoint(
       'update_user_subscription',
       subscriptionUpdate,
     );
     return {
       threadID: subscriptionUpdate.threadID,
       subscription: response.threadSubscription,
     };
   };
 
 const setUserSettingsActionTypes = Object.freeze({
   started: 'SET_USER_SETTINGS_STARTED',
   success: 'SET_USER_SETTINGS_SUCCESS',
   failed: 'SET_USER_SETTINGS_FAILED',
 });
 
 const setUserSettings =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((userSettingsRequest: UpdateUserSettingsRequest) => Promise<void>) =>
   async userSettingsRequest => {
     await callServerEndpoint('update_user_settings', userSettingsRequest);
   };
 
 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';
+
 export {
   changeUserPasswordActionTypes,
   changeUserPassword,
   deleteAccount,
   deleteAccountActionTypes,
   getSessionPublicKeys,
   getOlmSessionInitializationDataActionTypes,
   getOlmSessionInitializationData,
   mergeUserInfos,
   logIn,
   logInActionTypes,
   logOut,
   logOutActionTypes,
   register,
   registerActionTypes,
   searchUsers,
   searchUsersActionTypes,
   exactSearchUser,
   exactSearchUserActionTypes,
   setUserSettings,
   setUserSettingsActionTypes,
   updateSubscription,
   updateSubscriptionActionTypes,
   policyAcknowledgment,
   policyAcknowledgmentActionTypes,
   updateUserAvatarActionTypes,
   updateUserAvatar,
+  resetUserStateActionType,
 };
diff --git a/lib/reducers/user-reducer.js b/lib/reducers/user-reducer.js
index dc5ecc155..f0b9a285c 100644
--- a/lib/reducers/user-reducer.js
+++ b/lib/reducers/user-reducer.js
@@ -1,264 +1,267 @@
 // @flow
 
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   joinThreadActionTypes,
   newThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
   setUserSettingsActionTypes,
   updateUserAvatarActionTypes,
+  resetUserStateActionType,
 } from '../actions/user-actions.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   type UserInconsistencyReportCreationRequest,
   reportTypes,
 } 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 {
   CurrentUserInfo,
   UserStore,
   UserInfos,
 } from '../types/user-types.js';
 import { actionLogger } from '../utils/action-logger.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { getConfig } from '../utils/config.js';
 import { generateReportID } from '../utils/report-utils.js';
 import { sanitizeActionSecrets } from '../utils/sanitization.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
   ) {
     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
   ) {
     for (const update of action.payload.updatesResult.newUpdates) {
       if (
         update.type === updateTypes.UPDATE_CURRENT_USER &&
         !_isEqual(update.currentUserInfo)(state)
       ) {
         return update.currentUserInfo;
       }
     }
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (
       checkStateRequest &&
       checkStateRequest.stateChanges &&
       checkStateRequest.stateChanges.currentUserInfo &&
       !_isEqual(checkStateRequest.stateChanges.currentUserInfo)(state)
     ) {
       return checkStateRequest.stateChanges.currentUserInfo;
     }
   } 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 findInconsistencies(
   action: BaseAction,
   beforeStateCheck: UserInfos,
   afterStateCheck: UserInfos,
 ): UserInconsistencyReportCreationRequest[] {
   if (_isEqual(beforeStateCheck)(afterStateCheck)) {
     return [];
   }
   return [
     {
       type: reportTypes.USER_INCONSISTENCY,
       platformDetails: getConfig().platformDetails,
       action: sanitizeActionSecrets(action),
       beforeStateCheck,
       afterStateCheck,
       lastActions: actionLogger.interestingActionSummaries,
       time: Date.now(),
       id: generateReportID(),
     },
   ];
 }
 
 function reduceUserInfos(state: UserStore, action: BaseAction): UserStore {
   if (
     action.type === joinThreadActionTypes.success ||
     action.type === newThreadActionTypes.success
   ) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     const updated = { ...state.userInfos, ...newUserInfos };
     if (!_isEqual(state.userInfos)(updated)) {
       return {
         ...state,
         userInfos: updated,
       };
     }
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     if (Object.keys(state.userInfos).length === 0) {
       return state;
     }
     return {
       userInfos: {},
       inconsistencyReports: state.inconsistencyReports,
     };
   } 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,
     );
     if (!_isEqual(state.userInfos)(newUserInfos)) {
       return {
         userInfos: newUserInfos,
         inconsistencyReports: state.inconsistencyReports,
       };
     }
   } else if (
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType
   ) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     const updated = { ...state.userInfos, ...newUserInfos };
     for (const update of action.payload.updatesResult.newUpdates) {
       if (update.type === updateTypes.DELETE_ACCOUNT) {
         delete updated[update.deletedUserID];
       }
     }
     if (!_isEqual(state.userInfos)(updated)) {
       return {
         userInfos: updated,
         inconsistencyReports: state.inconsistencyReports,
       };
     }
   } 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 newUserInfos = { ...state.userInfos };
     if (userInfos) {
       for (const userInfo of userInfos) {
         newUserInfos[userInfo.id] = userInfo;
       }
     }
     if (deleteUserInfoIDs) {
       for (const deleteUserInfoID of deleteUserInfoIDs) {
         delete newUserInfos[deleteUserInfoID];
       }
     }
 
     const newInconsistencies = findInconsistencies(
       action,
       state.userInfos,
       newUserInfos,
     );
     return {
       userInfos: newUserInfos,
       inconsistencyReports: [
         ...state.inconsistencyReports,
         ...newInconsistencies,
       ],
     };
   } else if (action.type === updateUserAvatarActionTypes.success) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.updates.userInfos,
     );
     const updated = { ...state.userInfos, ...newUserInfos };
     return !_isEqual(state.userInfos)(updated)
       ? {
           ...state,
           userInfos: updated,
         }
       : state;
   }
 
   return state;
 }
 
 export { reduceCurrentUserInfo, reduceUserInfos };
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index cf7709d5e..abd107e3e 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1188 +1,1189 @@
 // @flow
 
 import type {
   LogOutResult,
   LogInStartingPayload,
   LogInResult,
   RegisterResult,
   DefaultNotificationPayload,
 } 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 {
   VersionResponse,
   LastCommunicatedPlatformDetails,
 } from './device-types.js';
 import type { ClientDBDraftInfo, DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-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,
   ClientDBMessageInfo,
   SimpleMessagesPayload,
   ClientDBThreadMessageInfo,
   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,
   ClientReportCreationRequest,
 } from './report-types.js';
 import type {
   ProcessServerRequestsPayload,
   GetOlmSessionInitializationDataResponse,
 } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   ConnectionInfo,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateDisconnectedBarPayload,
 } from './socket-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
 } from './thread-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type { CurrentUserInfo, UserStore } from './user-types.js';
 import type { Shape } from '../types/core.js';
 import type { NotifPermissionAlertInfo } from '../utils/push-alerts.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo> = {
   navInfo: NavInfo,
   currentUserInfo: ?CurrentUserInfo,
   draftStore: DraftStore,
   entryStore: EntryStore,
   threadStore: ThreadStore,
   userStore: UserStore,
   messageStore: MessageStore,
   updatesCurrentAsOf: number, // millisecond timestamp
   loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   calendarFilters: $ReadOnlyArray<CalendarFilter>,
   urlPrefix: string,
   notifPermissionAlertInfo: NotifPermissionAlertInfo,
   connection: ConnectionInfo,
   watchedThreadIDs: $ReadOnlyArray<string>,
   lifecycleState: LifecycleState,
   enabledApps: EnabledApps,
   reportStore: ReportStore,
   nextLocalID: number,
   dataLoaded: boolean,
   userPolicies: UserPolicies,
   deviceToken: ?string,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +lastCommunicatedPlatformDetails: LastCommunicatedPlatformDetails,
   ...
 };
 
 // Web JS runtime doesn't have access to the cookie for security reasons.
 // Native JS doesn't have a sessionID because the cookieID is used instead.
 export type NativeAppState = BaseAppState<*> & {
   sessionID?: void,
   cookie: ?string,
   ...
 };
 export type WebAppState = BaseAppState<*> & {
   sessionID: ?string,
   cookie?: void,
   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: 'DELETE_ACCOUNT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_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: {
         +entryID: string,
         +text: string,
         +deleted: boolean,
       },
       +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: {
         +currentUserID: ?string,
         +drafts: $ReadOnlyArray<ClientDBDraftInfo>,
         +messages: ?$ReadOnlyArray<ClientDBMessageInfo>,
         +threadStore: ?ThreadStore,
         +messageStoreThreads: ?$ReadOnlyArray<ClientDBThreadMessageInfo>,
         +reports: ?$ReadOnlyArray<ClientReportCreationRequest>,
       },
     }
   | {
       +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: ?string,
       +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,
     }
   | {
       +type: 'PROCESS_SERVER_REQUESTS',
       +payload: ProcessServerRequestsPayload,
     }
   | {
       +type: 'UPDATE_CONNECTION_STATUS',
       +payload: UpdateConnectionStatusPayload,
     }
   | {
       +type: 'QUEUE_ACTIVITY_UPDATES',
       +payload: QueueActivityUpdatesPayload,
     }
   | {
       +type: 'UNSUPERVISED_BACKGROUND',
       +payload?: void,
     }
   | {
       +type: 'UPDATE_LIFECYCLE_STATE',
       +payload: LifecycleState,
     }
   | {
       +type: 'ENABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'DISABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'UPDATE_REPORTS_ENABLED',
       +payload: Shape<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: VersionResponse,
       +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 };
 
 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/account/logged-out-modal.react.js b/native/account/logged-out-modal.react.js
index 1f082b16c..58e3ca188 100644
--- a/native/account/logged-out-modal.react.js
+++ b/native/account/logged-out-modal.react.js
@@ -1,807 +1,807 @@
 // @flow
 
 import Icon from '@expo/vector-icons/FontAwesome.js';
 import _isEqual from 'lodash/fp/isEqual.js';
 import * as React from 'react';
 import {
   View,
   Text,
   TouchableOpacity,
   Image,
   Keyboard,
   Platform,
   BackHandler,
   ActivityIndicator,
 } from 'react-native';
 import Animated, { EasingNode } from 'react-native-reanimated';
 import { SafeAreaView } from 'react-native-safe-area-context';
 import { useDispatch } from 'react-redux';
 
+import { resetUserStateActionType } from 'lib/actions/user-actions.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { logInActionSources } from 'lib/types/account-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { fetchNewCookieFromNativeCredentials } from 'lib/utils/action-utils.js';
 
 import { splashBackgroundURI } from './background-info.js';
 import FullscreenSIWEPanel from './fullscreen-siwe-panel.react.js';
 import LogInPanel from './log-in-panel.react.js';
 import type { LogInState } from './log-in-panel.react.js';
 import LoggedOutStaffInfo from './logged-out-staff-info.react.js';
 import RegisterPanel from './register-panel.react.js';
 import type { RegisterState } from './register-panel.react.js';
 import KeyboardAvoidingView from '../components/keyboard-avoiding-view.react.js';
 import ConnectedStatusBar from '../connected-status-bar.react.js';
 import {
   addKeyboardShowListener,
   addKeyboardDismissListener,
   removeKeyboardListener,
 } from '../keyboard/keyboard.js';
 import { createIsForegroundSelector } from '../navigation/nav-selectors.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import type { RootNavigationProp } from '../navigation/root-navigator.react.js';
 import {
   type NavigationRoute,
   LoggedOutModalRouteName,
   RegistrationRouteName,
 } from '../navigation/route-names.js';
-import { resetUserStateActionType } from '../redux/action-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { usePersistedStateLoaded } from '../selectors/app-state-selectors.js';
 import {
   type DerivedDimensionsInfo,
   derivedDimensionsInfoSelector,
 } from '../selectors/dimensions-selectors.js';
 import { splashStyleSelector } from '../splash.js';
 import { useStyles } from '../themes/colors.js';
 import type {
   EventSubscription,
   KeyboardEvent,
 } from '../types/react-native.js';
 import type { ImageStyle } from '../types/styles.js';
 import {
   runTiming,
   ratchetAlongWithKeyboardHeight,
 } from '../utils/animation-utils.js';
 import { useInitialNotificationsEncryptedMessage } from '../utils/crypto-utils.js';
 import {
   type StateContainer,
   type StateChange,
   setStateForContainer,
 } from '../utils/state-container.js';
 import EthereumLogo from '../vectors/ethereum-logo.react.js';
 
 let initialAppLoad = true;
 const safeAreaEdges = ['top', 'bottom'];
 
 /* eslint-disable import/no-named-as-default-member */
 const {
   Value,
   Node,
   Clock,
   block,
   set,
   call,
   cond,
   not,
   and,
   eq,
   neq,
   lessThan,
   greaterOrEq,
   add,
   sub,
   divide,
   max,
   stopClock,
   clockRunning,
 } = Animated;
 /* eslint-enable import/no-named-as-default-member */
 
 export type LoggedOutMode =
   | 'loading'
   | 'prompt'
   | 'log-in'
   | 'register'
   | 'siwe';
 const modeNumbers: { [LoggedOutMode]: number } = {
   'loading': 0,
   'prompt': 1,
   'log-in': 2,
   'register': 3,
   'siwe': 4,
 };
 function isPastPrompt(modeValue: Node) {
   return and(
     neq(modeValue, modeNumbers['loading']),
     neq(modeValue, modeNumbers['prompt']),
   );
 }
 
 type BaseProps = {
   +navigation: RootNavigationProp<'LoggedOutModal'>,
   +route: NavigationRoute<'LoggedOutModal'>,
 };
 
 type Props = {
   ...BaseProps,
   // Navigation state
   +isForeground: boolean,
   // Redux state
   +persistedStateLoaded: boolean,
   +rehydrateConcluded: boolean,
   +cookie: ?string,
   +urlPrefix: string,
   +loggedIn: boolean,
   +dimensions: DerivedDimensionsInfo,
   +splashStyle: ImageStyle,
   +styles: typeof unboundStyles,
   // Redux dispatch functions
   +dispatch: Dispatch,
   // Keyserver olm sessions functions
   +getInitialNotificationsEncryptedMessage: () => Promise<string>,
 };
 type State = {
   +mode: LoggedOutMode,
   +nextMode: LoggedOutMode,
   +logInState: StateContainer<LogInState>,
   +registerState: StateContainer<RegisterState>,
 };
 class LoggedOutModal extends React.PureComponent<Props, State> {
   keyboardShowListener: ?EventSubscription;
   keyboardHideListener: ?EventSubscription;
 
   mounted = false;
   nextMode: LoggedOutMode = 'loading';
   activeAlert = false;
 
   contentHeight: Value;
   keyboardHeightValue = new Value(0);
   modeValue: Value;
 
   buttonOpacity: Value;
   panelPaddingTopValue: Node;
   panelOpacityValue: Node;
 
   constructor(props: Props) {
     super(props);
 
     // Man, this is a lot of boilerplate just to containerize some state.
     // Mostly due to Flow typing requirements...
     const setLogInState = setStateForContainer(
       this.guardedSetState,
       (change: $Shape<LogInState>) => (fullState: State) => ({
         logInState: {
           ...fullState.logInState,
           state: { ...fullState.logInState.state, ...change },
         },
       }),
     );
     const setRegisterState = setStateForContainer(
       this.guardedSetState,
       (change: $Shape<RegisterState>) => (fullState: State) => ({
         registerState: {
           ...fullState.registerState,
           state: { ...fullState.registerState.state, ...change },
         },
       }),
     );
 
     const initialMode = props.persistedStateLoaded ? 'prompt' : 'loading';
     this.state = {
       mode: initialMode,
       nextMode: initialMode,
       logInState: {
         state: {
           usernameInputText: null,
           passwordInputText: null,
         },
         setState: setLogInState,
       },
       registerState: {
         state: {
           usernameInputText: '',
           passwordInputText: '',
           confirmPasswordInputText: '',
         },
         setState: setRegisterState,
       },
     };
     this.nextMode = initialMode;
 
     this.contentHeight = new Value(props.dimensions.safeAreaHeight);
     this.modeValue = new Value(modeNumbers[this.nextMode]);
 
     this.buttonOpacity = new Value(props.persistedStateLoaded ? 1 : 0);
     this.panelPaddingTopValue = this.panelPaddingTop();
     this.panelOpacityValue = this.panelOpacity();
   }
 
   guardedSetState = (change: StateChange<State>, callback?: () => mixed) => {
     if (this.mounted) {
       this.setState(change, callback);
     }
   };
 
   setMode(newMode: LoggedOutMode) {
     this.nextMode = newMode;
     this.guardedSetState({ mode: newMode, nextMode: newMode });
     this.modeValue.setValue(modeNumbers[newMode]);
   }
 
   proceedToNextMode = () => {
     this.guardedSetState({ mode: this.nextMode });
   };
 
   componentDidMount() {
     this.mounted = true;
     if (this.props.rehydrateConcluded) {
       this.onInitialAppLoad();
     }
     if (this.props.isForeground) {
       this.onForeground();
     }
   }
 
   componentWillUnmount() {
     this.mounted = false;
     if (this.props.isForeground) {
       this.onBackground();
     }
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (!prevProps.persistedStateLoaded && this.props.persistedStateLoaded) {
       this.setMode('prompt');
     }
     if (!prevProps.rehydrateConcluded && this.props.rehydrateConcluded) {
       this.onInitialAppLoad();
     }
     if (!prevProps.isForeground && this.props.isForeground) {
       this.onForeground();
     } else if (prevProps.isForeground && !this.props.isForeground) {
       this.onBackground();
     }
 
     if (this.state.mode === 'prompt' && prevState.mode !== 'prompt') {
       this.buttonOpacity.setValue(0);
       Animated.timing(this.buttonOpacity, {
         easing: EasingNode.out(EasingNode.ease),
         duration: 250,
         toValue: 1.0,
       }).start();
     }
 
     const newContentHeight = this.props.dimensions.safeAreaHeight;
     const oldContentHeight = prevProps.dimensions.safeAreaHeight;
     if (newContentHeight !== oldContentHeight) {
       this.contentHeight.setValue(newContentHeight);
     }
   }
 
   onForeground() {
     this.keyboardShowListener = addKeyboardShowListener(this.keyboardShow);
     this.keyboardHideListener = addKeyboardDismissListener(this.keyboardHide);
     BackHandler.addEventListener('hardwareBackPress', this.hardwareBack);
   }
 
   onBackground() {
     if (this.keyboardShowListener) {
       removeKeyboardListener(this.keyboardShowListener);
       this.keyboardShowListener = null;
     }
     if (this.keyboardHideListener) {
       removeKeyboardListener(this.keyboardHideListener);
       this.keyboardHideListener = null;
     }
     BackHandler.removeEventListener('hardwareBackPress', this.hardwareBack);
   }
 
   // This gets triggered when an app is killed and restarted
   // Not when it is returned from being backgrounded
   async onInitialAppLoad() {
     if (!initialAppLoad) {
       return;
     }
     initialAppLoad = false;
 
     const { loggedIn, cookie, urlPrefix, dispatch } = this.props;
     const hasUserCookie = cookie && cookie.startsWith('user=');
     if (loggedIn === !!hasUserCookie) {
       return;
     }
     if (!__DEV__) {
       const actionSource = loggedIn
         ? logInActionSources.appStartReduxLoggedInButInvalidCookie
         : logInActionSources.appStartCookieLoggedInButInvalidRedux;
       const sessionChange = await fetchNewCookieFromNativeCredentials(
         dispatch,
         cookie,
         urlPrefix,
         actionSource,
         this.props.getInitialNotificationsEncryptedMessage,
       );
       if (
         sessionChange &&
         sessionChange.cookie &&
         sessionChange.cookie.startsWith('user=')
       ) {
         // success! we can expect subsequent actions to fix up the state
         return;
       }
     }
     this.props.dispatch({ type: resetUserStateActionType });
   }
 
   hardwareBack = () => {
     if (this.nextMode !== 'prompt') {
       this.goBackToPrompt();
       return true;
     }
     return false;
   };
 
   panelPaddingTop() {
     const headerHeight = Platform.OS === 'ios' ? 62.33 : 58.54;
     const promptButtonsSize = Platform.OS === 'ios' ? 40 : 61;
     const logInContainerSize = 140;
     const registerPanelSize = Platform.OS === 'ios' ? 181 : 180;
     const siwePanelSize = 250;
 
     const containerSize = add(
       headerHeight,
       cond(not(isPastPrompt(this.modeValue)), promptButtonsSize, 0),
       cond(eq(this.modeValue, modeNumbers['log-in']), logInContainerSize, 0),
       cond(eq(this.modeValue, modeNumbers['register']), registerPanelSize, 0),
       cond(eq(this.modeValue, modeNumbers['siwe']), siwePanelSize, 0),
     );
     const potentialPanelPaddingTop = divide(
       max(sub(this.contentHeight, this.keyboardHeightValue, containerSize), 0),
       2,
     );
 
     const panelPaddingTop = new Value(-1);
     const targetPanelPaddingTop = new Value(-1);
     const prevModeValue = new Value(modeNumbers[this.nextMode]);
     const clock = new Clock();
     const keyboardTimeoutClock = new Clock();
     return block([
       cond(lessThan(panelPaddingTop, 0), [
         set(panelPaddingTop, potentialPanelPaddingTop),
         set(targetPanelPaddingTop, potentialPanelPaddingTop),
       ]),
       cond(
         lessThan(this.keyboardHeightValue, 0),
         [
           runTiming(keyboardTimeoutClock, 0, 1, true, { duration: 500 }),
           cond(
             not(clockRunning(keyboardTimeoutClock)),
             set(this.keyboardHeightValue, 0),
           ),
         ],
         stopClock(keyboardTimeoutClock),
       ),
       cond(
         and(
           greaterOrEq(this.keyboardHeightValue, 0),
           neq(prevModeValue, this.modeValue),
         ),
         [
           stopClock(clock),
           cond(
             neq(isPastPrompt(prevModeValue), isPastPrompt(this.modeValue)),
             set(targetPanelPaddingTop, potentialPanelPaddingTop),
           ),
           set(prevModeValue, this.modeValue),
         ],
       ),
       ratchetAlongWithKeyboardHeight(this.keyboardHeightValue, [
         stopClock(clock),
         set(targetPanelPaddingTop, potentialPanelPaddingTop),
       ]),
       cond(
         neq(panelPaddingTop, targetPanelPaddingTop),
         set(
           panelPaddingTop,
           runTiming(clock, panelPaddingTop, targetPanelPaddingTop),
         ),
       ),
       panelPaddingTop,
     ]);
   }
 
   panelOpacity() {
     const targetPanelOpacity = isPastPrompt(this.modeValue);
 
     const panelOpacity = new Value(-1);
     const prevPanelOpacity = new Value(-1);
     const prevTargetPanelOpacity = new Value(-1);
     const clock = new Clock();
     return block([
       cond(lessThan(panelOpacity, 0), [
         set(panelOpacity, targetPanelOpacity),
         set(prevPanelOpacity, targetPanelOpacity),
         set(prevTargetPanelOpacity, targetPanelOpacity),
       ]),
       cond(greaterOrEq(this.keyboardHeightValue, 0), [
         cond(neq(targetPanelOpacity, prevTargetPanelOpacity), [
           stopClock(clock),
           set(prevTargetPanelOpacity, targetPanelOpacity),
         ]),
         cond(
           neq(panelOpacity, targetPanelOpacity),
           set(panelOpacity, runTiming(clock, panelOpacity, targetPanelOpacity)),
         ),
       ]),
       cond(
         and(eq(panelOpacity, 0), neq(prevPanelOpacity, 0)),
         call([], this.proceedToNextMode),
       ),
       set(prevPanelOpacity, panelOpacity),
       panelOpacity,
     ]);
   }
 
   keyboardShow = (event: KeyboardEvent) => {
     if (
       event.startCoordinates &&
       _isEqual(event.startCoordinates)(event.endCoordinates)
     ) {
       return;
     }
     const keyboardHeight = Platform.select({
       // Android doesn't include the bottomInset in this height measurement
       android: event.endCoordinates.height,
       default: Math.max(
         event.endCoordinates.height - this.props.dimensions.bottomInset,
         0,
       ),
     });
     this.keyboardHeightValue.setValue(keyboardHeight);
   };
 
   keyboardHide = () => {
     if (!this.activeAlert) {
       this.keyboardHeightValue.setValue(0);
     }
   };
 
   setActiveAlert = (activeAlert: boolean) => {
     this.activeAlert = activeAlert;
   };
 
   goBackToPrompt = () => {
     this.nextMode = 'prompt';
     this.guardedSetState({ nextMode: 'prompt' });
     this.keyboardHeightValue.setValue(0);
     this.modeValue.setValue(modeNumbers['prompt']);
     Keyboard.dismiss();
   };
 
   render() {
     const { styles } = this.props;
 
     const siweButton = (
       <>
         <TouchableOpacity
           onPress={this.onPressSIWE}
           style={[styles.button, styles.siweButton]}
           activeOpacity={0.6}
         >
           <View style={styles.siweIcon}>
             <EthereumLogo />
           </View>
           <Text style={[styles.buttonText, styles.siweButtonText]}>
             Sign in with Ethereum
           </Text>
         </TouchableOpacity>
         <View style={styles.siweOr}>
           <View style={styles.siweOrLeftHR} />
           <Text style={styles.siweOrText}>or</Text>
           <View style={styles.siweOrRightHR} />
         </View>
       </>
     );
 
     let panel = null;
     let buttons = null;
     if (this.state.mode === 'log-in') {
       panel = (
         <LogInPanel
           setActiveAlert={this.setActiveAlert}
           opacityValue={this.panelOpacityValue}
           logInState={this.state.logInState}
         />
       );
     } else if (this.state.mode === 'register') {
       panel = (
         <RegisterPanel
           setActiveAlert={this.setActiveAlert}
           opacityValue={this.panelOpacityValue}
           registerState={this.state.registerState}
         />
       );
     } else if (this.state.mode === 'prompt') {
       const opacityStyle = { opacity: this.buttonOpacity };
 
       const registerButtons = [];
       registerButtons.push(
         <TouchableOpacity
           onPress={this.onPressRegister}
           style={[styles.button, styles.classicAuthButton]}
           activeOpacity={0.6}
           key="old"
         >
           <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
             Register
           </Text>
         </TouchableOpacity>,
       );
       if (__DEV__) {
         registerButtons.push(
           <TouchableOpacity
             onPress={this.onPressNewRegister}
             style={[styles.button, styles.classicAuthButton]}
             activeOpacity={0.6}
             key="new"
           >
             <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
               Register (new)
             </Text>
           </TouchableOpacity>,
         );
       }
 
       buttons = (
         <Animated.View style={[styles.buttonContainer, opacityStyle]}>
           <LoggedOutStaffInfo />
           {siweButton}
           <TouchableOpacity
             onPress={this.onPressLogIn}
             style={[styles.button, styles.classicAuthButton]}
             activeOpacity={0.6}
           >
             <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
               Sign in
             </Text>
           </TouchableOpacity>
           <View style={styles.registerButtons}>{registerButtons}</View>
         </Animated.View>
       );
     } else if (this.state.mode === 'loading') {
       panel = (
         <ActivityIndicator
           color="white"
           size="large"
           style={styles.loadingIndicator}
         />
       );
     }
 
     const windowWidth = this.props.dimensions.width;
     const buttonStyle = {
       opacity: this.panelOpacityValue,
       left: windowWidth < 360 ? 28 : 40,
     };
     const padding = { paddingTop: this.panelPaddingTopValue };
 
     const animatedContent = (
       <Animated.View style={[styles.animationContainer, padding]}>
         <View>
           <Text style={styles.header}>Comm</Text>
           <Animated.View style={[styles.backButton, buttonStyle]}>
             <TouchableOpacity activeOpacity={0.6} onPress={this.hardwareBack}>
               <Icon name="arrow-circle-o-left" size={36} color="#FFFFFFAA" />
             </TouchableOpacity>
           </Animated.View>
         </View>
         {panel}
       </Animated.View>
     );
 
     let siwePanel;
     if (this.state.mode === 'siwe') {
       siwePanel = (
         <FullscreenSIWEPanel
           goBackToPrompt={this.goBackToPrompt}
           closing={this.state.nextMode === 'prompt'}
         />
       );
     }
 
     const backgroundSource = { uri: splashBackgroundURI };
     return (
       <React.Fragment>
         <ConnectedStatusBar barStyle="light-content" />
         <Image
           source={backgroundSource}
           style={[styles.modalBackground, this.props.splashStyle]}
         />
         <SafeAreaView style={styles.container} edges={safeAreaEdges}>
           <KeyboardAvoidingView behavior="padding" style={styles.container}>
             {animatedContent}
             {buttons}
           </KeyboardAvoidingView>
         </SafeAreaView>
         {siwePanel}
       </React.Fragment>
     );
   }
 
   onPressSIWE = () => {
     this.setMode('siwe');
   };
 
   onPressLogIn = () => {
     if (Platform.OS !== 'ios') {
       // For some strange reason, iOS's password management logic doesn't
       // realize that the username and password fields in LogInPanel are related
       // if the username field gets focused on mount. To avoid this issue we
       // need the username and password fields to both appear on-screen before
       // we focus the username field. However, when we set keyboardHeightValue
       // to -1 here, we are telling our Reanimated logic to wait until the
       // keyboard appears before showing LogInPanel. Since we need LogInPanel
       // to appear before the username field is focused, we need to avoid this
       // behavior on iOS.
       this.keyboardHeightValue.setValue(-1);
     }
     this.setMode('log-in');
   };
 
   onPressRegister = () => {
     this.keyboardHeightValue.setValue(-1);
     this.setMode('register');
   };
 
   onPressNewRegister = () => {
     this.props.navigation.navigate(RegistrationRouteName);
   };
 }
 
 const unboundStyles = {
   animationContainer: {
     flex: 1,
   },
   backButton: {
     position: 'absolute',
     top: 13,
   },
   button: {
     borderRadius: 4,
     marginBottom: 4,
     marginTop: 4,
     marginLeft: 4,
     marginRight: 4,
     paddingBottom: 14,
     paddingLeft: 18,
     paddingRight: 18,
     paddingTop: 14,
     flex: 1,
   },
   buttonContainer: {
     bottom: 0,
     left: 0,
     marginLeft: 26,
     marginRight: 26,
     paddingBottom: 20,
     position: 'absolute',
     right: 0,
   },
   buttonText: {
     fontFamily: 'OpenSans-Semibold',
     fontSize: 17,
     textAlign: 'center',
   },
   classicAuthButton: {
     backgroundColor: 'purpleButton',
   },
   classicAuthButtonText: {
     color: 'whiteText',
   },
   registerButtons: {
     flexDirection: 'row',
   },
   container: {
     backgroundColor: 'transparent',
     flex: 1,
   },
   header: {
     color: 'white',
     fontFamily: Platform.OS === 'ios' ? 'IBMPlexSans' : 'IBMPlexSans-Medium',
     fontSize: 56,
     fontWeight: '500',
     lineHeight: 66,
     textAlign: 'center',
   },
   loadingIndicator: {
     paddingTop: 15,
   },
   modalBackground: {
     bottom: 0,
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
   siweButton: {
     backgroundColor: 'siweButton',
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'center',
   },
   siweButtonText: {
     color: 'siweButtonText',
   },
   siweOr: {
     flex: 1,
     flexDirection: 'row',
     marginBottom: 18,
     marginTop: 14,
   },
   siweOrLeftHR: {
     borderColor: 'logInSpacer',
     borderTopWidth: 1,
     flex: 1,
     marginRight: 18,
     marginTop: 10,
   },
   siweOrRightHR: {
     borderColor: 'logInSpacer',
     borderTopWidth: 1,
     flex: 1,
     marginLeft: 18,
     marginTop: 10,
   },
   siweOrText: {
     color: 'whiteText',
     fontSize: 17,
     textAlign: 'center',
   },
   siweIcon: {
     paddingRight: 10,
   },
 };
 
 const isForegroundSelector = createIsForegroundSelector(
   LoggedOutModalRouteName,
 );
 
 const ConnectedLoggedOutModal: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedLoggedOutModal(props: BaseProps) {
     const navContext = React.useContext(NavContext);
     const isForeground = isForegroundSelector(navContext);
 
     const rehydrateConcluded = useSelector(
       state => !!(state._persist && state._persist.rehydrated && navContext),
     );
     const persistedStateLoaded = usePersistedStateLoaded();
     const cookie = useSelector(state => state.cookie);
     const urlPrefix = useSelector(state => state.urlPrefix);
     const loggedIn = useSelector(isLoggedIn);
     const dimensions = useSelector(derivedDimensionsInfoSelector);
     const splashStyle = useSelector(splashStyleSelector);
     const styles = useStyles(unboundStyles);
 
     const dispatch = useDispatch();
     const getInitialNotificationsEncryptedMessage =
       useInitialNotificationsEncryptedMessage();
     return (
       <LoggedOutModal
         {...props}
         isForeground={isForeground}
         persistedStateLoaded={persistedStateLoaded}
         rehydrateConcluded={rehydrateConcluded}
         cookie={cookie}
         urlPrefix={urlPrefix}
         loggedIn={loggedIn}
         dimensions={dimensions}
         splashStyle={splashStyle}
         styles={styles}
         dispatch={dispatch}
         getInitialNotificationsEncryptedMessage={
           getInitialNotificationsEncryptedMessage
         }
       />
     );
   });
 
 export default ConnectedLoggedOutModal;
diff --git a/native/redux/action-types.js b/native/redux/action-types.js
index f2a45e514..21ce408c0 100644
--- a/native/redux/action-types.js
+++ b/native/redux/action-types.js
@@ -1,67 +1,65 @@
 // @flow
 
 import type { Orientations } from 'react-native-orientation-locker';
 
 import { saveMessagesActionType } from 'lib/actions/message-actions.js';
 import type { Shape } from 'lib/types/core.js';
 import type { BaseAction } from 'lib/types/redux-types.js';
 
 import type { DimensionsInfo } from './dimensions-updater.react.js';
 import type { AppState } from './state-types.js';
 import type { DeviceCameraInfo } from '../types/camera.js';
 import type { ConnectivityInfo } from '../types/connectivity.js';
 import type { GlobalThemeInfo } from '../types/themes.js';
 
-export const resetUserStateActionType = 'RESET_USER_STATE';
 export const updateDimensionsActiveType = 'UPDATE_DIMENSIONS';
 export const updateConnectivityActiveType = 'UPDATE_CONNECTIVITY';
 export const updateThemeInfoActionType = 'UPDATE_THEME_INFO';
 export const updateDeviceCameraInfoActionType = 'UPDATE_DEVICE_CAMERA_INFO';
 export const updateDeviceOrientationActionType = 'UPDATE_DEVICE_ORIENTATION';
 export const updateThreadLastNavigatedActionType =
   'UPDATE_THREAD_LAST_NAVIGATED';
 export const setStoreLoadedActionType = 'SET_STORE_LOADED';
 export const setReduxStateActionType = 'SET_REDUX_STATE';
 
 export const backgroundActionTypes: Set<string> = new Set([
   saveMessagesActionType,
 ]);
 
 export type Action =
   | BaseAction
   | {
       +type: 'SET_REDUX_STATE',
       +payload: { +state: AppState, +hideFromMonitor: boolean },
     }
   | {
       +type: 'SET_CUSTOM_SERVER',
       +payload: string,
     }
-  | { +type: 'RESET_USER_STATE' }
   | {
       +type: 'UPDATE_DIMENSIONS',
       +payload: Shape<DimensionsInfo>,
     }
   | {
       +type: 'UPDATE_CONNECTIVITY',
       +payload: ConnectivityInfo,
     }
   | {
       +type: 'UPDATE_THEME_INFO',
       +payload: Shape<GlobalThemeInfo>,
     }
   | {
       +type: 'UPDATE_DEVICE_CAMERA_INFO',
       +payload: Shape<DeviceCameraInfo>,
     }
   | {
       +type: 'UPDATE_DEVICE_ORIENTATION',
       +payload: Orientations,
     }
   | {
       +type: 'UPDATE_THREAD_LAST_NAVIGATED',
       +payload: { +threadID: string, +time: number },
     }
   | {
       +type: 'SET_STORE_LOADED',
     };
diff --git a/native/redux/redux-setup.js b/native/redux/redux-setup.js
index 340fe7bce..386394e50 100644
--- a/native/redux/redux-setup.js
+++ b/native/redux/redux-setup.js
@@ -1,502 +1,498 @@
 // @flow
 
 import { AppState as NativeAppState, Platform, Alert } from 'react-native';
 import Orientation from 'react-native-orientation-locker';
 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,
   logInActionTypes,
+  resetUserStateActionType,
 } from 'lib/actions/user-actions.js';
 import baseReducer from 'lib/reducers/master-reducer.js';
 import { processThreadStoreOperations } from 'lib/reducers/thread-reducer.js';
 import {
   invalidSessionDowngrade,
   invalidSessionRecovery,
 } from 'lib/shared/session-utils.js';
 import { isStaff } from 'lib/shared/staff-utils.js';
 import { defaultEnabledApps } from 'lib/types/enabled-apps.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.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 { defaultConnectionInfo } from 'lib/types/socket-types.js';
 import type { ThreadStoreOperation } from 'lib/types/thread-types.js';
 import { reduxLoggerMiddleware } from 'lib/utils/action-logger.js';
 import { setNewSessionActionType } from 'lib/utils/action-utils.js';
 import { defaultNotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 
 import {
-  resetUserStateActionType,
   updateDimensionsActiveType,
   updateConnectivityActiveType,
   updateThemeInfoActionType,
   updateDeviceCameraInfoActionType,
   updateDeviceOrientationActionType,
   updateThreadLastNavigatedActionType,
   backgroundActionTypes,
   setReduxStateActionType,
   setStoreLoadedActionType,
   type Action,
 } from './action-types.js';
 import { remoteReduxDevServerConfig } from './dev-tools.js';
 import { defaultDimensionsInfo } from './dimensions-updater.react.js';
 import { persistConfig, setPersistor } from './persist.js';
 import { processDBStoreOperations } from './redux-utils.js';
 import type { AppState } from './state-types.js';
 import reduceGlobalThemeInfo from './theme-reducer.js';
 import { defaultNavInfo } from '../navigation/default-state.js';
 import { getGlobalNavContext } from '../navigation/icky-global.js';
 import { activeMessageListSelector } from '../navigation/nav-selectors.js';
 import reactotron from '../reactotron.js';
 import { defaultDeviceCameraInfo } from '../types/camera.js';
 import { defaultConnectivityInfo } from '../types/connectivity.js';
 import { defaultGlobalThemeInfo } from '../types/themes.js';
 import { isStaffRelease } from '../utils/staff-utils.js';
 import {
   defaultURLPrefix,
   natNodeServer,
   setCustomServer,
   getDevServerHostname,
 } from '../utils/url-utils.js';
 
 const defaultState = ({
   navInfo: defaultNavInfo,
   currentUserInfo: null,
   draftStore: { drafts: {} },
   entryStore: {
     entryInfos: {},
     daysToEntries: {},
     lastUserInteractionCalendar: 0,
   },
   threadStore: {
     threadInfos: {},
   },
   userStore: {
     userInfos: {},
     inconsistencyReports: [],
   },
   messageStore: {
     messages: {},
     threads: {},
     local: {},
     currentAsOf: 0,
   },
   storeLoaded: false,
   updatesCurrentAsOf: 0,
   loadingStatuses: {},
   calendarFilters: defaultCalendarFilters,
   cookie: null,
   deviceToken: null,
   dataLoaded: false,
   urlPrefix: defaultURLPrefix,
   customServer: natNodeServer,
   notifPermissionAlertInfo: defaultNotifPermissionAlertInfo,
   connection: defaultConnectionInfo(Platform.OS),
   watchedThreadIDs: [],
   lifecycleState: 'active',
   enabledApps: defaultEnabledApps,
   reportStore: {
     enabledReports: {
       crashReports: __DEV__,
       inconsistencyReports: __DEV__,
       mediaReports: __DEV__,
     },
     queuedReports: [],
   },
   nextLocalID: 0,
   _persist: null,
   dimensions: defaultDimensionsInfo,
   connectivity: defaultConnectivityInfo,
   globalThemeInfo: defaultGlobalThemeInfo,
   deviceCameraInfo: defaultDeviceCameraInfo,
   deviceOrientation: Orientation.getInitialOrientation(),
   frozen: false,
   userPolicies: {},
   commServicesAccessToken: null,
   inviteLinksStore: {
     links: {},
   },
   lastCommunicatedPlatformDetails: {},
 }: AppState);
 
 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 = 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 = 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 &&
       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;
   }
 
   state = {
     ...state,
     globalThemeInfo: reduceGlobalThemeInfo(state.globalThemeInfo, action),
   };
 
   if (action.type === setCustomServer) {
     return {
       ...state,
       customServer: action.payload,
     };
-  } else if (action.type === resetUserStateActionType) {
-    const cookie =
-      state.cookie && state.cookie.startsWith('anonymous=')
-        ? state.cookie
-        : null;
-    const currentUserInfo =
-      state.currentUserInfo && state.currentUserInfo.anonymous
-        ? state.currentUserInfo
-        : null;
-    return {
-      ...state,
-      currentUserInfo,
-      cookie,
-    };
   } 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 === updateThemeInfoActionType) {
     // Handled above by reduceGlobalThemeInfo
     return state;
   } 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 === updateThreadLastNavigatedActionType) {
     const { threadID, time } = action.payload;
     if (state.messageStore.threads[threadID]) {
       const updatedThreads = {
         [threadID]: {
           ...state.messageStore.threads[threadID],
           lastNavigatedTo: time,
         },
       };
 
       state = {
         ...state,
         messageStore: {
           ...state.messageStore,
           threads: {
             ...state.messageStore.threads,
             ...updatedThreads,
           },
         },
       };
 
       processDBStoreOperations({
         draftStoreOperations: [],
         messageStoreOperations: [
           {
             type: 'replace_threads',
             payload: {
               threads: updatedThreads,
             },
           },
         ],
         threadStoreOperations: [],
         reportStoreOperations: [],
       });
     }
     return state;
   }
 
   if (action.type === setNewSessionActionType) {
     sessionInvalidationAlert(action.payload);
     state = {
       ...state,
       cookie: action.payload.sessionChange.cookie,
     };
   }
   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;
     }
   }
+  if (action.type === resetUserStateActionType) {
+    const cookie =
+      state.cookie && state.cookie.startsWith('anonymous=')
+        ? state.cookie
+        : null;
+    state = {
+      ...state,
+      cookie,
+    };
+  }
 
   const baseReducerResult = baseReducer(state, (action: BaseAction));
   state = baseReducerResult.state;
 
   const { storeOperations } = baseReducerResult;
   const {
     draftStoreOperations,
     threadStoreOperations,
     messageStoreOperations,
     reportStoreOperations,
   } = storeOperations;
 
   const fixUnreadActiveThreadResult = fixUnreadActiveThread(state, action);
   state = fixUnreadActiveThreadResult.state;
 
   const threadStoreOperationsWithUnreadFix = [
     ...threadStoreOperations,
     ...fixUnreadActiveThreadResult.threadStoreOperations,
   ];
 
   processDBStoreOperations({
     draftStoreOperations,
     messageStoreOperations,
     threadStoreOperations: threadStoreOperationsWithUnreadFix,
     reportStoreOperations,
   });
 
   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') {
     const app = Platform.select({
       ios: 'App Store',
       android: 'Play Store',
     });
     Alert.alert(
       'App out of date',
       'Your app version is pretty old, and the server doesn’t know how to ' +
         `speak to it anymore. Please use the ${app} app to update!`,
       [{ 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 = processThreadStoreOperations(
     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 };