diff --git a/lib/actions/user-actions.js b/lib/actions/user-actions.js
index 50cc98c67..5dbaf5258 100644
--- a/lib/actions/user-actions.js
+++ b/lib/actions/user-actions.js
@@ -1,688 +1,703 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   extractKeyserverIDFromID,
   sortThreadIDsPerKeyserver,
   sortCalendarQueryPerKeyserver,
 } from '../keyserver-conn/keyserver-call-utils.js';
 import { preRequestUserStateSelector } from '../selectors/account-selectors.js';
 import { IdentityClientContext } from '../shared/identity-client-context.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type {
   LogOutResult,
   LogInInfo,
   LogInResult,
   RegisterResult,
   RegisterInfo,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
   ClaimUsernameResponse,
   LogInRequest,
   KeyserverAuthResult,
   KeyserverAuthInfo,
   KeyserverAuthRequest,
   ClientLogInResponse,
 } 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 { MinimallyEncodedRawThreadInfos } from '../types/thread-types';
 import type {
+  CurrentUserInfo,
   UserInfo,
   PasswordUpdate,
   LoggedOutUserInfo,
 } from '../types/user-types.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 { useSelector } from '../utils/redux-utils.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(): () => Promise<LogOutResult> {
   const preRequestUserState = useSelector(preRequestUserStateSelector);
   const callKeyserverLogOut = useKeyserverCall(logOut);
 
   return React.useCallback(
     () => callKeyserverLogOut(preRequestUserState),
     [callKeyserverLogOut, preRequestUserState],
   );
 }
 
 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 deleteKeyserverAccountActionTypes = Object.freeze({
   started: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
   success: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
   failed: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
 });
 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 useDeleteKeyserverAccount(): (
   input: PreRequestUserState,
 ) => Promise<LogOutResult> {
   return useKeyserverCall(deleteKeyserverAccount);
 }
 
 const deleteIdentityAccountActionTypes = Object.freeze({
   started: 'DELETE_IDENTITY_ACCOUNT_STARTED',
   success: 'DELETE_IDENTITY_ACCOUNT_SUCCESS',
   failed: 'DELETE_IDENTITY_ACCOUNT_FAILED',
 });
 
 function useDeleteIdentityAccount(): () => Promise<void> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   return React.useCallback(() => {
     if (!identityClient) {
       throw new Error('Identity service client is not initialized');
     }
     return identityClient.deleteUser();
   }, [identityClient]);
 }
 
 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,
     };
   };
 
+export type KeyserverAuthInput = $ReadOnly<{
+  ...KeyserverAuthInfo,
+  +preRequestUserInfo: ?CurrentUserInfo,
+}>;
+
 const keyserverAuthActionTypes = Object.freeze({
   started: 'KEYSERVER_AUTH_STARTED',
   success: 'KEYSERVER_AUTH_SUCCESS',
   failed: 'KEYSERVER_AUTH_FAILED',
 });
 const keyserverAuthCallServerEndpointOptions = { timeout: 60000 };
 const keyserverAuth =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
-  ): ((input: KeyserverAuthInfo) => Promise<KeyserverAuthResult>) =>
+  ): ((input: KeyserverAuthInput) => Promise<KeyserverAuthResult>) =>
   async keyserverAuthInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
 
     const {
       logInActionSource,
       calendarQuery,
       keyserverData,
       deviceTokenUpdateInput,
+      preRequestUserInfo,
       ...restLogInInfo
     } = keyserverAuthInfo;
 
     const keyserverIDs = Object.keys(keyserverData);
 
     const watchedIDsPerKeyserver = sortThreadIDsPerKeyserver(watchedIDs);
     const calendarQueryPerKeyserver = sortCalendarQueryPerKeyserver(
       calendarQuery,
       keyserverIDs,
     );
 
     const requests: { [string]: KeyserverAuthRequest } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {
         ...restLogInInfo,
         deviceTokenUpdateRequest: deviceTokenUpdateInput[keyserverID],
         watchedIDs: watchedIDsPerKeyserver[keyserverID] ?? [],
         calendarQuery: calendarQueryPerKeyserver[keyserverID],
         platformDetails: getConfig().platformDetails,
         initialContentEncryptedMessage:
           keyserverData[keyserverID].initialContentEncryptedMessage,
         initialNotificationsEncryptedMessage:
           keyserverData[keyserverID].initialNotificationsEncryptedMessage,
         source: logInActionSource,
       };
     }
 
     const responses: { +[string]: ClientLogInResponse } =
       await callKeyserverEndpoint(
         'keyserver_auth',
         requests,
         keyserverAuthCallServerEndpointOptions,
       );
 
     const userInfosArrays = [];
 
     let threadInfos: MinimallyEncodedRawThreadInfos = {};
     const calendarResult: WritableCalendarResult = {
       calendarQuery: keyserverAuthInfo.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: keyserverAuthInfo.logInActionSource,
       notAcknowledgedPolicies:
         responses[ashoatKeyserverID].notAcknowledgedPolicies,
+      preRequestUserInfo,
     };
   };
 
 function useKeyserverAuth(): (
   input: KeyserverAuthInfo,
 ) => Promise<KeyserverAuthResult> {
-  return useKeyserverCall(keyserverAuth);
+  const preRequestUserInfo = useSelector(state => state.currentUserInfo);
+  const callKeyserverAuth = useKeyserverCall(keyserverAuth);
+
+  return React.useCallback(
+    (input: KeyserverAuthInfo) =>
+      callKeyserverAuth({ preRequestUserInfo, ...input }),
+    [callKeyserverAuth, preRequestUserInfo],
+  );
 }
 
 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 tempIdentityLoginActionTypes = Object.freeze({
   started: 'TEMP_IDENTITY_LOG_IN_STARTED',
   success: 'TEMP_IDENTITY_LOG_IN_SUCCESS',
   failed: 'TEMP_IDENTITY_LOG_IN_FAILED',
 });
 
 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]: ClientLogInResponse } =
       await callKeyserverEndpoint(
         'log_in',
         requests,
         logInCallServerEndpointOptions,
       );
 
     const userInfosArrays = [];
 
     let threadInfos: MinimallyEncodedRawThreadInfos = {};
     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 changeKeyserverUserPasswordActionTypes = Object.freeze({
   started: 'CHANGE_KEYSERVER_USER_PASSWORD_STARTED',
   success: 'CHANGE_KEYSERVER_USER_PASSWORD_SUCCESS',
   failed: 'CHANGE_KEYSERVER_USER_PASSWORD_FAILED',
 });
 const changeKeyserverUserPassword =
   (
     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 {
   changeKeyserverUserPasswordActionTypes,
   changeKeyserverUserPassword,
   claimUsernameActionTypes,
   useClaimUsername,
   useDeleteKeyserverAccount,
   deleteKeyserverAccountActionTypes,
   getSessionPublicKeys,
   getOlmSessionInitializationDataActionTypes,
   getOlmSessionInitializationData,
   mergeUserInfos,
   logIn as logInRawAction,
   tempIdentityLoginActionTypes,
   useLogIn,
   logInActionTypes,
   useLogOut,
   logOutActionTypes,
   register,
   registerActionTypes,
   searchUsers,
   searchUsersActionTypes,
   exactSearchUser,
   exactSearchUserActionTypes,
   useSetUserSettings,
   setUserSettingsActionTypes,
   useUpdateSubscription,
   updateSubscriptionActionTypes,
   policyAcknowledgment,
   policyAcknowledgmentActionTypes,
   updateUserAvatarActionTypes,
   updateUserAvatar,
   resetUserStateActionType,
   setAccessTokenActionType,
   deleteIdentityAccountActionTypes,
   useDeleteIdentityAccount,
   keyserverAuthActionTypes,
   useKeyserverAuth,
 };
diff --git a/lib/reducers/calendar-filters-reducer.test.js b/lib/reducers/calendar-filters-reducer.test.js
index 5acebcfa9..6106d891f 100644
--- a/lib/reducers/calendar-filters-reducer.test.js
+++ b/lib/reducers/calendar-filters-reducer.test.js
@@ -1,221 +1,222 @@
 // @flow
 
 import reduceCalendarFilters, {
   removeDeletedThreadIDsFromFilterList,
   removeKeyserverThreadIDsFromFilterList,
 } from './calendar-filters-reducer.js';
 import { keyserverAuthActionTypes } from '../actions/user-actions.js';
 import type { RawMessageInfo } from '../types/message-types.js';
 import type { ThreadStore } from '../types/thread-types';
 
 const calendarFilters = [
   { type: 'threads', threadIDs: ['256|1', '256|83815'] },
 ];
 
 const threadStore: ThreadStore = {
   threadInfos: {
     '256|1': {
       id: '256|1',
       type: 12,
       name: 'GENESIS',
       description: '',
       color: '648caa',
       creationTime: 1689091732528,
       parentThreadID: null,
       repliesCount: 0,
       containingThreadID: null,
       community: null,
       pinnedCount: 0,
       minimallyEncoded: true,
       members: [
         {
           id: '256',
           role: '256|83796',
           permissions: '3f73ff',
           isSender: true,
           minimallyEncoded: true,
         },
         {
           id: '83810',
           role: '256|83795',
           permissions: '3',
           isSender: false,
           minimallyEncoded: true,
         },
       ],
       roles: {
         '256|83795': {
           id: '256|83795',
           name: 'Members',
           permissions: ['000', '010', '005', '015', '0a7'],
           isDefault: true,
           minimallyEncoded: true,
         },
         '256|83796': {
           id: '256|83796',
           name: 'Admins',
           permissions: ['000', '010', '005', '015', '0a7'],
           isDefault: false,
           minimallyEncoded: true,
         },
       },
       currentUser: {
         role: '256|83795',
         permissions: '3',
         subscription: {
           home: true,
           pushNotifs: true,
         },
         unread: false,
         minimallyEncoded: true,
       },
     },
     '256|83815': {
       id: '256|83815',
       type: 7,
       name: '',
       description:
         'This is your private chat, where you can set reminders and jot notes in private!',
       color: '57697f',
       creationTime: 1689248242797,
       parentThreadID: '256|1',
       repliesCount: 0,
       containingThreadID: '256|1',
       community: '256|1',
       pinnedCount: 0,
       minimallyEncoded: true,
       members: [
         {
           id: '256',
           role: null,
           permissions: '2c7fff',
           isSender: false,
           minimallyEncoded: true,
         },
         {
           id: '83810',
           role: '256|83816',
           permissions: '3026f',
           isSender: true,
           minimallyEncoded: true,
         },
       ],
       roles: {
         '256|83816': {
           id: '256|83816',
           name: 'Members',
           permissions: ['000', '010', '005', '015', '0a7'],
           isDefault: true,
           minimallyEncoded: true,
         },
       },
       currentUser: {
         role: null,
         permissions: '3026f',
         subscription: {
           home: true,
           pushNotifs: true,
         },
         unread: false,
         minimallyEncoded: true,
       },
     },
   },
 };
 
 describe('removeDeletedThreadIDsFromFilterList', () => {
   it('Removes threads the user is not a member of anymore', () => {
     expect(
       removeDeletedThreadIDsFromFilterList(
         calendarFilters,
         threadStore.threadInfos,
       ),
     ).toEqual([{ type: 'threads', threadIDs: ['256|1'] }]);
   });
 });
 
 const threadIDsToStay = [
   '256|1',
   '256|2',
   '200|4',
   '300|5',
   '300|6',
   '256|100',
 ];
 const keyserverToRemove1 = '100';
 const keyserverToRemove2 = '400';
 const threadIDsToRemove = [
   keyserverToRemove1 + '|3',
   keyserverToRemove1 + '|7',
   keyserverToRemove2 + '|8',
 ];
 const calendarFiltersState = [
   { type: 'not_deleted' },
   {
     type: 'threads',
     threadIDs: [...threadIDsToStay, ...threadIDsToRemove],
   },
 ];
 
 describe('removeKeyserverThreadIDsFromFilterList', () => {
   it('Removes threads from the given keyserver', () => {
     expect(
       removeKeyserverThreadIDsFromFilterList(calendarFiltersState, [
         keyserverToRemove1,
         keyserverToRemove2,
       ]),
     ).toEqual([
       { type: 'not_deleted' },
       {
         type: 'threads',
         threadIDs: threadIDsToStay,
       },
     ]);
   });
 });
 
 describe('reduceCalendarFilters', () => {
   it('Removes from filters thread ids of the keyservers that were logged into', () => {
     const messageInfos: RawMessageInfo[] = [];
     const payload = {
       currentUserInfo: { id: '5', username: 'me' },
+      preRequestUserInfo: { id: '5', username: 'me' },
       threadInfos: {},
       messagesResult: {
         currentAsOf: {},
         messageInfos,
         truncationStatus: {},
         watchedIDsAtRequestTime: [],
       },
       userInfos: [],
       calendarResult: {
         rawEntryInfos: [],
         calendarQuery: { startDate: '0', endDate: '0', filters: [] },
       },
       // only updatesCurrentAsOf is relevant to this test
       updatesCurrentAsOf: { [keyserverToRemove1]: 5, [keyserverToRemove2]: 5 },
       logInActionSource: 'SOCKET_AUTH_ERROR_RESOLUTION_ATTEMPT',
     };
 
     expect(
       reduceCalendarFilters(
         calendarFiltersState,
         {
           type: keyserverAuthActionTypes.success,
           payload,
           loadingInfo: {
             customKeyName: null,
             trackMultipleRequests: false,
             fetchIndex: 1,
           },
         },
         { threadInfos: {} },
       ),
     ).toEqual([
       { type: 'not_deleted' },
       {
         type: 'threads',
         threadIDs: threadIDsToStay,
       },
     ]);
   });
 });
diff --git a/lib/shared/session-utils.js b/lib/shared/session-utils.js
index e28c86f34..6f7d6eb15 100644
--- a/lib/shared/session-utils.js
+++ b/lib/shared/session-utils.js
@@ -1,63 +1,71 @@
 // @flow
 
+import invariant from 'invariant';
+
 import {
   cookieSelector,
   sessionIDSelector,
 } from '../selectors/keyserver-selectors.js';
 import {
   logInActionSources,
   type LogInActionSource,
 } from '../types/account-types.js';
 import type { AppState } from '../types/redux-types.js';
 import type { PreRequestUserState } from '../types/session-types.js';
 import type { CurrentUserInfo } from '../types/user-types.js';
 
 function invalidSessionDowngrade(
   currentReduxState: AppState,
   actionCurrentUserInfo: ?CurrentUserInfo,
   preRequestUserState: ?PreRequestUserState,
   keyserverID: string,
 ): boolean {
   // If this action represents a session downgrade - oldState has a loggedIn
   // currentUserInfo, but the action has an anonymous one - then it is only
   // valid if the currentUserInfo used for the request matches what oldState
   // currently has. If the currentUserInfo in Redux has changed since the
   // request, and is currently loggedIn, then the session downgrade does not
   // apply to it. In this case we will simply swallow the action.
   const currentCurrentUserInfo = currentReduxState.currentUserInfo;
   return !!(
     currentCurrentUserInfo &&
     !currentCurrentUserInfo.anonymous &&
     // Note that an undefined actionCurrentUserInfo represents an action that
     // doesn't affect currentUserInfo, whereas a null one represents an action
     // that sets it to null
     (actionCurrentUserInfo === null ||
       (actionCurrentUserInfo && actionCurrentUserInfo.anonymous)) &&
     preRequestUserState &&
     (preRequestUserState.currentUserInfo?.id !== currentCurrentUserInfo.id ||
       preRequestUserState.cookiesAndSessions[keyserverID].cookie !==
         cookieSelector(keyserverID)(currentReduxState) ||
       preRequestUserState.cookiesAndSessions[keyserverID].sessionID !==
         sessionIDSelector(keyserverID)(currentReduxState))
   );
 }
 
 function invalidSessionRecovery(
   currentReduxState: AppState,
-  actionCurrentUserInfo: CurrentUserInfo,
+  actionCurrentUserInfo: ?CurrentUserInfo,
   logInActionSource: ?LogInActionSource,
 ): boolean {
   if (
     logInActionSource !==
       logInActionSources.cookieInvalidationResolutionAttempt &&
     logInActionSource !== logInActionSources.socketAuthErrorResolutionAttempt
   ) {
     return false;
   }
+  invariant(
+    actionCurrentUserInfo,
+    'currentUserInfo (preRequestUserInfo) should be defined when ' +
+      'COOKIE_INVALIDATION_RESOLUTION_ATTEMPT or ' +
+      'SOCKET_AUTH_ERROR_RESOLUTION_ATTEMPT login is dispatched',
+  );
   return (
     !currentReduxState.dataLoaded ||
     currentReduxState.currentUserInfo?.id !== actionCurrentUserInfo.id
   );
 }
 
 export { invalidSessionDowngrade, invalidSessionRecovery };
diff --git a/lib/types/account-types.js b/lib/types/account-types.js
index 52d801114..a7506dc47 100644
--- a/lib/types/account-types.js
+++ b/lib/types/account-types.js
@@ -1,261 +1,263 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import type { SignedIdentityKeysBlob } from './crypto-types.js';
 import type { PlatformDetails } from './device-types.js';
 import type {
   CalendarQuery,
   CalendarResult,
   RawEntryInfo,
 } from './entry-types.js';
 import {
   type RawMessageInfo,
   type MessageTruncationStatuses,
   type GenericMessagesResult,
 } from './message-types.js';
 import type { PreRequestUserState } from './session-types.js';
 import {
   type RawThreadInfos,
   type MinimallyEncodedRawThreadInfos,
 } from './thread-types.js';
-import {
-  type UserInfo,
-  type LoggedOutUserInfo,
-  type LoggedInUserInfo,
-} from './user-types.js';
+import type {
+  CurrentUserInfo,
+  UserInfo,
+  LoggedOutUserInfo,
+  LoggedInUserInfo,
+} from './user-types';
 import type { PolicyType } from '../facts/policies.js';
 import { values } from '../utils/objects.js';
 import { tShape } from '../utils/validation-utils.js';
 
 export type ResetPasswordRequest = {
   +usernameOrEmail: string,
 };
 
 export type LogOutResult = {
   +currentUserInfo: ?LoggedOutUserInfo,
   +preRequestUserState: PreRequestUserState,
 };
 
 export type LogOutResponse = {
   +currentUserInfo: LoggedOutUserInfo,
 };
 
 export type RegisterInfo = {
   ...LogInExtraInfo,
   +username: string,
   +password: string,
 };
 
 export type DeviceTokenUpdateRequest = {
   +deviceToken: string,
 };
 
 type DeviceTokenUpdateInput = {
   +[keyserverID: string]: DeviceTokenUpdateRequest,
 };
 
 export type RegisterRequest = {
   +username: string,
   +email?: empty,
   +password: string,
   +calendarQuery?: ?CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +platformDetails: PlatformDetails,
   +primaryIdentityPublicKey?: empty,
   +signedIdentityKeysBlob?: SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
 };
 
 export type RegisterResponse = {
   +id: string,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +currentUserInfo: LoggedInUserInfo,
   +cookieChange: {
     +threadInfos: RawThreadInfos,
     +userInfos: $ReadOnlyArray<UserInfo>,
   },
 };
 
 export type RegisterResult = {
   +currentUserInfo: LoggedInUserInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +threadInfos: MinimallyEncodedRawThreadInfos,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarQuery: CalendarQuery,
 };
 
 export const logInActionSources = Object.freeze({
   cookieInvalidationResolutionAttempt: 'COOKIE_INVALIDATION_RESOLUTION_ATTEMPT',
   appStartCookieLoggedInButInvalidRedux:
     'APP_START_COOKIE_LOGGED_IN_BUT_INVALID_REDUX',
   appStartReduxLoggedInButInvalidCookie:
     'APP_START_REDUX_LOGGED_IN_BUT_INVALID_COOKIE',
   socketAuthErrorResolutionAttempt: 'SOCKET_AUTH_ERROR_RESOLUTION_ATTEMPT',
   sqliteOpFailure: 'SQLITE_OP_FAILURE',
   sqliteLoadFailure: 'SQLITE_LOAD_FAILURE',
   logInFromWebForm: 'LOG_IN_FROM_WEB_FORM',
   logInFromNativeForm: 'LOG_IN_FROM_NATIVE_FORM',
   logInFromNativeSIWE: 'LOG_IN_FROM_NATIVE_SIWE',
   corruptedDatabaseDeletion: 'CORRUPTED_DATABASE_DELETION',
   refetchUserDataAfterAcknowledgment: 'REFETCH_USER_DATA_AFTER_ACKNOWLEDGMENT',
   keyserverAuthFromNative: 'KEYSERVER_AUTH_FROM_NATIVE',
   keyserverAuthFromWeb: 'KEYSERVER_AUTH_FROM_WEB',
 });
 
 export type LogInActionSource = $Values<typeof logInActionSources>;
 
 export type LogInStartingPayload = {
   +calendarQuery: CalendarQuery,
   +logInActionSource?: LogInActionSource,
 };
 
 export type LogInExtraInfo = {
   +calendarQuery: CalendarQuery,
   +deviceTokenUpdateRequest: DeviceTokenUpdateInput,
   +signedIdentityKeysBlob?: SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
 };
 
 export type LogInInfo = {
   ...LogInExtraInfo,
   +username: string,
   +password: string,
   +logInActionSource: LogInActionSource,
   +keyserverIDs?: $ReadOnlyArray<string>,
 };
 
 export type LogInRequest = {
   +usernameOrEmail?: ?string,
   +username?: ?string,
   +password: string,
   +calendarQuery?: ?CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +platformDetails: PlatformDetails,
   +watchedIDs: $ReadOnlyArray<string>,
   +source?: LogInActionSource,
   +primaryIdentityPublicKey?: empty,
   +signedIdentityKeysBlob?: SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
 };
 
 export type ServerLogInResponse = {
   +currentUserInfo: LoggedInUserInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +rawEntryInfos?: ?$ReadOnlyArray<RawEntryInfo>,
   +serverTime: number,
   +cookieChange: {
     +threadInfos: RawThreadInfos,
     +userInfos: $ReadOnlyArray<UserInfo>,
   },
   +notAcknowledgedPolicies?: $ReadOnlyArray<PolicyType>,
 };
 
 export type ClientLogInResponse = $ReadOnly<{
   ...ServerLogInResponse,
   +cookieChange: $ReadOnly<{
     ...$PropertyType<ServerLogInResponse, 'cookieChange'>,
     threadInfos: MinimallyEncodedRawThreadInfos,
   }>,
 }>;
 
 export type LogInResult = {
   +threadInfos: MinimallyEncodedRawThreadInfos,
   +currentUserInfo: LoggedInUserInfo,
   +messagesResult: GenericMessagesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarResult: CalendarResult,
   +updatesCurrentAsOf: { +[keyserverID: string]: number },
   +logInActionSource: LogInActionSource,
   +notAcknowledgedPolicies?: $ReadOnlyArray<PolicyType>,
 };
 
 export type KeyserverAuthResult = {
   +threadInfos: RawThreadInfos,
   +currentUserInfo?: ?LoggedInUserInfo,
   +messagesResult: GenericMessagesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarResult: CalendarResult,
   +updatesCurrentAsOf: { +[keyserverID: string]: number },
   +logInActionSource: LogInActionSource,
   +notAcknowledgedPolicies?: ?$ReadOnlyArray<PolicyType>,
+  +preRequestUserInfo: ?CurrentUserInfo,
 };
 
 type KeyserverRequestData = {
   +initialContentEncryptedMessage: string,
   +initialNotificationsEncryptedMessage: string,
 };
 
 export type KeyserverAuthInfo = {
   +userID: string,
   +deviceID: string,
   +doNotRegister: boolean,
   +calendarQuery: CalendarQuery,
   +deviceTokenUpdateInput: DeviceTokenUpdateInput,
   +logInActionSource: LogInActionSource,
   +keyserverData: { +[keyserverID: string]: KeyserverRequestData },
 };
 
 export type KeyserverAuthRequest = $ReadOnly<{
   ...KeyserverRequestData,
   +userID: string,
   +deviceID: string,
   +doNotRegister: boolean,
   +calendarQuery: CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +watchedIDs: $ReadOnlyArray<string>,
   +platformDetails: PlatformDetails,
   +source?: LogInActionSource,
 }>;
 
 export type UpdatePasswordRequest = {
   code: string,
   password: string,
   calendarQuery?: ?CalendarQuery,
   deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   platformDetails: PlatformDetails,
   watchedIDs: $ReadOnlyArray<string>,
 };
 
 export type PolicyAcknowledgmentRequest = {
   +policy: PolicyType,
 };
 
 export type EmailSubscriptionRequest = {
   +email: string,
 };
 export type UpdateUserSettingsRequest = {
   +name: 'default_user_notifications',
   +data: NotificationTypes,
 };
 
 export const userSettingsTypes = Object.freeze({
   DEFAULT_NOTIFICATIONS: 'default_user_notifications',
 });
 
 export const notificationTypes = Object.freeze({
   FOCUSED: 'focused',
   BADGE_ONLY: 'badge_only',
   BACKGROUND: 'background',
 });
 
 export type NotificationTypes = $Values<typeof notificationTypes>;
 
 export const notificationTypeValues: $ReadOnlyArray<NotificationTypes> =
   values(notificationTypes);
 
 export type DefaultNotificationPayload = {
   +default_user_notifications: ?NotificationTypes,
 };
 
 export const defaultNotificationPayloadValidator: TInterface<DefaultNotificationPayload> =
   tShape<DefaultNotificationPayload>({
     default_user_notifications: t.maybe(t.enums.of(notificationTypeValues)),
   });
 
 export type ClaimUsernameResponse = {
   +message: string,
   +signature: string,
 };
diff --git a/native/redux/redux-setup.js b/native/redux/redux-setup.js
index 2c73b0cd3..6086284ff 100644
--- a/native/redux/redux-setup.js
+++ b/native/redux/redux-setup.js
@@ -1,423 +1,430 @@
 // @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,
   deleteKeyserverAccountActionTypes,
   logInActionTypes,
+  keyserverAuthActionTypes,
 } from 'lib/actions/user-actions.js';
 import { setNewSessionActionType } from 'lib/keyserver-conn/keyserver-conn-types.js';
 import type { ThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import { reduceLoadingStatuses } from 'lib/reducers/loading-reducer.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 { ashoatKeyserverID } from 'lib/utils/validation-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 { 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.payload.keyserverID,
       )) ||
     (action.type === logOutActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       )) ||
     (action.type === deleteKeyserverAccountActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       ))
   ) {
     return {
       ...state,
       loadingStatuses: reduceLoadingStatuses(state.loadingStatuses, action),
     };
   }
   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,
+      )) ||
+    (action.type === keyserverAuthActionTypes.success &&
+      invalidSessionRecovery(
+        state,
+        action.payload.preRequestUserInfo,
+        action.payload.logInActionSource,
       ))
   ) {
     return state;
   }
 
   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 === 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,
   ];
 
   void 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 activeThreadInfo = state.threadStore.threadInfos[activeThread];
   // TODO (atul): Try to get rid of this ridiculous branching.
   if (activeThreadInfo.minimallyEncoded) {
     const updatedActiveThreadInfo = {
       ...activeThreadInfo,
       currentUser: {
         ...activeThreadInfo.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,
     };
   } else {
     const updatedActiveThreadInfo = {
       ...activeThreadInfo,
       currentUser: {
         ...activeThreadInfo.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 };