diff --git a/lib/selectors/account-selectors.js b/lib/selectors/account-selectors.js
index 37b6ab73f..4aef2fdcc 100644
--- a/lib/selectors/account-selectors.js
+++ b/lib/selectors/account-selectors.js
@@ -1,59 +1,97 @@
 // @flow
 
+import _memoize from 'lodash/memoize.js';
 import { createSelector } from 'reselect';
 
 import {
   cookieSelector,
   sessionIDSelector,
   deviceTokensSelector,
 } from './keyserver-selectors.js';
 import { currentCalendarQuery } from './nav-selectors.js';
 import type { LogInExtraInfo } from '../types/account-types.js';
 import type { CalendarQuery } from '../types/entry-types.js';
+import type { KeyserverInfos } from '../types/keyserver-types.js';
 import type { AppState } from '../types/redux-types.js';
-import type { PreRequestUserState } from '../types/session-types.js';
+import type {
+  PreRequestUserState,
+  PreRequestUserKeyserverSessionInfo,
+} from '../types/session-types.js';
 import type { CurrentUserInfo } from '../types/user-types.js';
 
 const logInExtraInfoSelector: (
   state: AppState,
 ) => (calendarActive: boolean) => LogInExtraInfo = createSelector(
   deviceTokensSelector,
   currentCalendarQuery,
   (
     deviceTokens: { +[keyserverID: string]: ?string },
     calendarQuery: (calendarActive: boolean) => CalendarQuery,
   ) => {
     const deviceTokenUpdateRequest = {};
 
     for (const keyserverID in deviceTokens) {
       if (deviceTokens[keyserverID]) {
         deviceTokenUpdateRequest[keyserverID] = {
           deviceToken: deviceTokens[keyserverID],
         };
       }
     }
     // Return a function since we depend on the time of evaluation
     return (calendarActive: boolean): LogInExtraInfo => ({
       calendarQuery: calendarQuery(calendarActive),
       deviceTokenUpdateRequest,
     });
   },
 );
 
-const preRequestUserStateSelector: (state: AppState) => PreRequestUserState =
+const basePreRequestUserStateForSingleKeyserverSelector: (
+  keyserverID: string,
+  // eslint-disable-next-line no-unused-vars
+) => (state: AppState) => PreRequestUserState = keyserverID =>
   createSelector(
     (state: AppState) => state.currentUserInfo,
     cookieSelector,
     sessionIDSelector,
     (
       currentUserInfo: ?CurrentUserInfo,
       cookie: ?string,
       sessionID: ?string,
     ) => ({
       currentUserInfo,
-      cookie,
-      sessionID,
+      cookiesAndSessions: { [keyserverID]: { cookie, sessionID } },
     }),
   );
 
-export { logInExtraInfoSelector, preRequestUserStateSelector };
+const preRequestUserStateForSingleKeyserverSelector: (
+  keyserverID: string,
+) => (state: AppState) => PreRequestUserState = _memoize(
+  basePreRequestUserStateForSingleKeyserverSelector,
+);
+
+const preRequestUserStateSelector: (state: AppState) => PreRequestUserState =
+  createSelector(
+    (state: AppState) => state.currentUserInfo,
+    (state: AppState) => state.keyserverStore.keyserverInfos,
+    (currentUserInfo: ?CurrentUserInfo, keyserverInfos: KeyserverInfos) => {
+      const cookiesAndSessions: {
+        [string]: PreRequestUserKeyserverSessionInfo,
+      } = {};
+      for (const keyserverID in keyserverInfos) {
+        cookiesAndSessions[keyserverID] = {
+          cookie: keyserverInfos[keyserverID].cookie,
+          sessionID: keyserverInfos[keyserverID].sessionID,
+        };
+      }
+      return {
+        currentUserInfo,
+        cookiesAndSessions,
+      };
+    },
+  );
+
+export {
+  logInExtraInfoSelector,
+  preRequestUserStateForSingleKeyserverSelector,
+  preRequestUserStateSelector,
+};
diff --git a/lib/shared/session-utils.js b/lib/shared/session-utils.js
index 1f4c1d09f..1d91b443b 100644
--- a/lib/shared/session-utils.js
+++ b/lib/shared/session-utils.js
@@ -1,60 +1,63 @@
 // @flow
 
 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';
+import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 function invalidSessionDowngrade(
   currentReduxState: AppState,
   actionCurrentUserInfo: ?CurrentUserInfo,
   preRequestUserState: ?PreRequestUserState,
 ): 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.cookie !== cookieSelector(currentReduxState) ||
-      preRequestUserState.sessionID !== sessionIDSelector(currentReduxState))
+      preRequestUserState.cookiesAndSessions[ashoatKeyserverID].cookie !==
+        cookieSelector(currentReduxState) ||
+      preRequestUserState.cookiesAndSessions[ashoatKeyserverID].sessionID !==
+        sessionIDSelector(currentReduxState))
   );
 }
 
 function invalidSessionRecovery(
   currentReduxState: AppState,
   actionCurrentUserInfo: CurrentUserInfo,
   logInActionSource: ?LogInActionSource,
 ): boolean {
   if (
     logInActionSource !==
       logInActionSources.cookieInvalidationResolutionAttempt &&
     logInActionSource !== logInActionSources.socketAuthErrorResolutionAttempt
   ) {
     return false;
   }
   return (
     !currentReduxState.dataLoaded ||
     currentReduxState.currentUserInfo?.id !== actionCurrentUserInfo.id
   );
 }
 
 export { invalidSessionDowngrade, invalidSessionRecovery };
diff --git a/lib/types/session-types.js b/lib/types/session-types.js
index bb0ecad6c..dacb8dda0 100644
--- a/lib/types/session-types.js
+++ b/lib/types/session-types.js
@@ -1,118 +1,124 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import type { LogInActionSource } from './account-types.js';
 import type { Shape } from './core.js';
 import type { CalendarQuery } from './entry-types.js';
 import type { RawThreadInfo } from './thread-types.js';
 import {
   type UserInfo,
   type CurrentUserInfo,
   type LoggedOutUserInfo,
 } from './user-types.js';
 import { tShape } from '../utils/validation-utils.js';
 
 export const cookieLifetime = 30 * 24 * 60 * 60 * 1000; // in milliseconds
 // Interval the server waits after a state check before starting a new one
 export const sessionCheckFrequency = 3 * 60 * 1000; // in milliseconds
 // How long the server debounces after activity before initiating a state check
 export const stateCheckInactivityActivationInterval = 3 * 1000; // in milliseconds
 
 // On native, we specify the cookie directly in the request and response body.
 // We do this because:
 // (1) We don't have the same XSS risks as we do on web, so there is no need to
 //     prevent JavaScript from knowing the cookie password.
 // (2) In the past the internal cookie logic on Android has been buggy.
 //     https://github.com/facebook/react-native/issues/12956 is an example
 //     issue. By specifying the cookie in the body we retain full control of how
 //     that data is passed, without necessitating any native modules like
 //     react-native-cookies.
 export const cookieSources = Object.freeze({
   BODY: 0,
   HEADER: 1,
 });
 export type CookieSource = $Values<typeof cookieSources>;
 
 // On native, we use the cookieID as a unique session identifier. This is
 // because there is no way to have two instances of an app running. On the other
 // hand, on web it is possible to have two sessions open using the same cookie,
 // so we have a unique sessionID specified in the request body.
 export const sessionIdentifierTypes = Object.freeze({
   COOKIE_ID: 0,
   BODY_SESSION_ID: 1,
 });
 export type SessionIdentifierType = $Values<typeof sessionIdentifierTypes>;
 
 export const cookieTypes = Object.freeze({
   USER: 'user',
   ANONYMOUS: 'anonymous',
 });
 export type CookieType = $Values<typeof cookieTypes>;
 
 export type ServerSessionChange =
   | {
       cookieInvalidated: false,
       threadInfos: { +[id: string]: RawThreadInfo },
       userInfos: $ReadOnlyArray<UserInfo>,
       sessionID?: null | string,
       cookie?: string,
     }
   | {
       cookieInvalidated: true,
       threadInfos: { +[id: string]: RawThreadInfo },
       userInfos: $ReadOnlyArray<UserInfo>,
       currentUserInfo: LoggedOutUserInfo,
       sessionID?: null | string,
       cookie?: string,
     };
 
 export type ClientSessionChange =
   | {
       +cookieInvalidated: false,
       +currentUserInfo?: ?CurrentUserInfo,
       +sessionID?: null | string,
       +cookie?: string,
     }
   | {
       +cookieInvalidated: true,
       +currentUserInfo: LoggedOutUserInfo,
       +sessionID?: null | string,
       +cookie?: string,
     };
 
-export type PreRequestUserState = {
-  +currentUserInfo: ?CurrentUserInfo,
+export type PreRequestUserKeyserverSessionInfo = {
   +cookie: ?string,
   +sessionID: ?string,
 };
 
+export type PreRequestUserState = {
+  +currentUserInfo: ?CurrentUserInfo,
+  +cookiesAndSessions: {
+    +[keyserverID: string]: PreRequestUserKeyserverSessionInfo,
+  },
+};
+
 export type SetSessionPayload = {
   sessionChange: ClientSessionChange,
   preRequestUserState: ?PreRequestUserState,
   error: ?string,
   logInActionSource: ?LogInActionSource,
 };
 
 export type SessionState = {
   calendarQuery: CalendarQuery,
   messagesCurrentAsOf: number,
   updatesCurrentAsOf: number,
   watchedIDs: $ReadOnlyArray<string>,
 };
 
 export type SessionIdentification = Shape<{
   cookie: ?string,
   sessionID: ?string,
 }>;
 
 export type SessionPublicKeys = {
   +identityKey: string,
   +oneTimeKey?: string,
 };
 
 export const sessionPublicKeysValidator: TInterface<SessionPublicKeys> =
   tShape<SessionPublicKeys>({
     identityKey: t.String,
     oneTimeKey: t.maybe(t.String),
   });
diff --git a/lib/utils/action-utils.js b/lib/utils/action-utils.js
index c3a078d99..38004dd67 100644
--- a/lib/utils/action-utils.js
+++ b/lib/utils/action-utils.js
@@ -1,567 +1,570 @@
 // @flow
 
 import invariant from 'invariant';
 import _memoize from 'lodash/memoize.js';
 import * as React from 'react';
 import { useSelector, useDispatch } from 'react-redux';
 import { createSelector } from 'reselect';
 
 import callServerEndpoint from './call-server-endpoint.js';
 import type {
   CallServerEndpoint,
   CallServerEndpointOptions,
 } from './call-server-endpoint.js';
 import { getConfig } from './config.js';
 import { promiseAll } from './promises.js';
 import { ashoatKeyserverID } from './validation-utils.js';
 import { serverCallStateSelector } from '../selectors/server-calls.js';
 import {
   logInActionSources,
   type LogInActionSource,
   type LogInStartingPayload,
   type LogInResult,
 } from '../types/account-types.js';
 import type { PlatformDetails } from '../types/device-types.js';
 import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js';
 import type { CalendarQuery } from '../types/entry-types.js';
 import type { LoadingOptions, LoadingInfo } from '../types/loading-types.js';
 import type {
   ActionPayload,
   Dispatch,
   PromisedAction,
   BaseAction,
 } from '../types/redux-types.js';
 import type {
   ClientSessionChange,
   PreRequestUserState,
 } from '../types/session-types.js';
 import type { ConnectionStatus } from '../types/socket-types.js';
 import type { CurrentUserInfo } from '../types/user-types.js';
 
 function extractKeyserverIDFromID(id: string): string {
   return id.split('|')[0];
 }
 
 let nextPromiseIndex = 0;
 
 export type ActionTypes<
   STARTED_ACTION_TYPE: string,
   SUCCESS_ACTION_TYPE: string,
   FAILED_ACTION_TYPE: string,
 > = {
   started: STARTED_ACTION_TYPE,
   success: SUCCESS_ACTION_TYPE,
   failed: FAILED_ACTION_TYPE,
 };
 
 function wrapActionPromise<
   STARTED_ACTION_TYPE: string,
   STARTED_PAYLOAD: ActionPayload,
   SUCCESS_ACTION_TYPE: string,
   SUCCESS_PAYLOAD: ActionPayload,
   FAILED_ACTION_TYPE: string,
 >(
   actionTypes: ActionTypes<
     STARTED_ACTION_TYPE,
     SUCCESS_ACTION_TYPE,
     FAILED_ACTION_TYPE,
   >,
   promise: Promise<SUCCESS_PAYLOAD>,
   loadingOptions: ?LoadingOptions,
   startingPayload: ?STARTED_PAYLOAD,
 ): PromisedAction {
   const loadingInfo: LoadingInfo = {
     fetchIndex: nextPromiseIndex++,
     trackMultipleRequests: !!loadingOptions?.trackMultipleRequests,
     customKeyName: loadingOptions?.customKeyName || null,
   };
   return async (dispatch: Dispatch): Promise<void> => {
     const startAction = startingPayload
       ? {
           type: (actionTypes.started: STARTED_ACTION_TYPE),
           loadingInfo,
           payload: (startingPayload: STARTED_PAYLOAD),
         }
       : {
           type: (actionTypes.started: STARTED_ACTION_TYPE),
           loadingInfo,
         };
     dispatch(startAction);
     try {
       const result = await promise;
       dispatch({
         type: (actionTypes.success: SUCCESS_ACTION_TYPE),
         payload: (result: SUCCESS_PAYLOAD),
         loadingInfo,
       });
     } catch (e) {
       console.log(e);
       dispatch({
         type: (actionTypes.failed: FAILED_ACTION_TYPE),
         error: true,
         payload: (e: Error),
         loadingInfo,
       });
     }
   };
 }
 
 export type DispatchActionPromise = <
   STARTED: BaseAction,
   SUCCESS: BaseAction,
   FAILED: BaseAction,
 >(
   actionTypes: ActionTypes<
     $PropertyType<STARTED, 'type'>,
     $PropertyType<SUCCESS, 'type'>,
     $PropertyType<FAILED, 'type'>,
   >,
   promise: Promise<$PropertyType<SUCCESS, 'payload'>>,
   loadingOptions?: LoadingOptions,
   startingPayload?: $PropertyType<STARTED, 'payload'>,
 ) => Promise<void>;
 
 function useDispatchActionPromise(): DispatchActionPromise {
   const dispatch = useDispatch();
   return React.useMemo(() => createDispatchActionPromise(dispatch), [dispatch]);
 }
 
 function createDispatchActionPromise(dispatch: Dispatch) {
   const dispatchActionPromise = function <
     STARTED: BaseAction,
     SUCCESS: BaseAction,
     FAILED: BaseAction,
   >(
     actionTypes: ActionTypes<
       $PropertyType<STARTED, 'type'>,
       $PropertyType<SUCCESS, 'type'>,
       $PropertyType<FAILED, 'type'>,
     >,
     promise: Promise<$PropertyType<SUCCESS, 'payload'>>,
     loadingOptions?: LoadingOptions,
     startingPayload?: $PropertyType<STARTED, 'payload'>,
   ): Promise<void> {
     return dispatch(
       wrapActionPromise(actionTypes, promise, loadingOptions, startingPayload),
     );
   };
   return dispatchActionPromise;
 }
 
 export type DispatchFunctions = {
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
 };
 
 let currentlyWaitingForNewCookie = false;
 let serverEndpointCallsWaitingForNewCookie: ((
   callServerEndpoint: ?CallServerEndpoint,
 ) => void)[] = [];
 
 export type DispatchRecoveryAttempt = (
   actionTypes: ActionTypes<'LOG_IN_STARTED', 'LOG_IN_SUCCESS', 'LOG_IN_FAILED'>,
   promise: Promise<LogInResult>,
   startingPayload: LogInStartingPayload,
 ) => Promise<boolean>;
 
 const setNewSessionActionType = 'SET_NEW_SESSION';
 function setNewSession(
   dispatch: Dispatch,
   sessionChange: ClientSessionChange,
   preRequestUserState: ?PreRequestUserState,
   error: ?string,
   logInActionSource: ?LogInActionSource,
 ) {
   dispatch({
     type: setNewSessionActionType,
     payload: { sessionChange, preRequestUserState, error, logInActionSource },
   });
 }
 
 // This function calls resolveInvalidatedCookie, which dispatchs a log in action
 // using the native credentials. Note that we never actually specify a sessionID
 // here, on the assumption that only native clients will call this. (Native
 // clients don't specify a sessionID, indicating to the server that it should
 // use the cookieID as the sessionID.)
 async function fetchNewCookieFromNativeCredentials(
   dispatch: Dispatch,
   cookie: ?string,
   urlPrefix: string,
   logInActionSource: LogInActionSource,
   keyserverID: string,
   getInitialNotificationsEncryptedMessage?: () => Promise<string>,
 ): Promise<?ClientSessionChange> {
   const resolveInvalidatedCookie = getConfig().resolveInvalidatedCookie;
   if (!resolveInvalidatedCookie) {
     return null;
   }
   let newSessionChange = null;
   let callServerEndpointCallback = null;
   const boundCallServerEndpoint = async (
     endpoint: Endpoint,
     data: { +[key: string]: mixed },
     options?: ?CallServerEndpointOptions,
   ) => {
     const innerBoundSetNewSession = (
       sessionChange: ClientSessionChange,
       error: ?string,
     ) => {
       newSessionChange = sessionChange;
       setNewSession(dispatch, sessionChange, null, error, logInActionSource);
     };
     try {
       const result = await callServerEndpoint(
         cookie,
         innerBoundSetNewSession,
         () => new Promise(r => r(null)),
         () => new Promise(r => r(null)),
         urlPrefix,
         null,
         'disconnected',
         null,
         null,
         endpoint,
         data,
         dispatch,
         options,
         false,
       );
       if (callServerEndpointCallback) {
         callServerEndpointCallback(!!newSessionChange);
       }
       return result;
     } catch (e) {
       if (callServerEndpointCallback) {
         callServerEndpointCallback(!!newSessionChange);
       }
       throw e;
     }
   };
 
   const boundCallKeyserverEndpoint = (
     endpoint: Endpoint,
     requests: { +[keyserverID: string]: ?{ +[string]: mixed } },
     options?: ?CallServerEndpointOptions,
   ) => {
     if (requests[keyserverID]) {
       const promises = {
         [keyserverID]: boundCallServerEndpoint(
           endpoint,
           requests[keyserverID],
           options,
         ),
       };
       return promiseAll(promises);
     }
     return Promise.resolve({});
   };
 
   const dispatchRecoveryAttempt = (
     actionTypes: ActionTypes<
       'LOG_IN_STARTED',
       'LOG_IN_SUCCESS',
       'LOG_IN_FAILED',
     >,
     promise: Promise<LogInResult>,
     inputStartingPayload: LogInStartingPayload,
   ) => {
     const startingPayload = { ...inputStartingPayload, logInActionSource };
     dispatch(wrapActionPromise(actionTypes, promise, null, startingPayload));
     return new Promise(r => (callServerEndpointCallback = r));
   };
   await resolveInvalidatedCookie(
     boundCallServerEndpoint,
     boundCallKeyserverEndpoint,
     dispatchRecoveryAttempt,
     logInActionSource,
     keyserverID,
     getInitialNotificationsEncryptedMessage,
   );
   return newSessionChange;
 }
 
 // Third param is optional and gets called with newCookie if we get a new cookie
 // Necessary to propagate cookie in cookieInvalidationRecovery below
 function bindCookieAndUtilsIntoCallServerEndpoint(
   params: BindServerCallsParams,
 ): CallServerEndpoint {
   const {
     dispatch,
     cookie,
     urlPrefix,
     sessionID,
     currentUserInfo,
     connectionStatus,
     lastCommunicatedPlatformDetails,
     keyserverID,
   } = params;
   const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true);
   const boundSetNewSession = (
     sessionChange: ClientSessionChange,
     error: ?string,
   ) =>
     setNewSession(
       dispatch,
       sessionChange,
-      { currentUserInfo, cookie, sessionID },
+      {
+        currentUserInfo,
+        cookiesAndSessions: { [keyserverID]: { cookie, sessionID } },
+      },
       error,
       undefined,
     );
   // This function gets called before callServerEndpoint sends a request,
   // to make sure that we're not in the middle of trying to recover
   // an invalidated cookie
   const waitIfCookieInvalidated = () => {
     if (!getConfig().resolveInvalidatedCookie) {
       // If there is no resolveInvalidatedCookie function, just let the caller
       // callServerEndpoint instance continue
       return Promise.resolve(null);
     }
     if (!currentlyWaitingForNewCookie) {
       // Our cookie seems to be valid
       return Promise.resolve(null);
     }
     // Wait to run until we get our new cookie
     return new Promise(r => serverEndpointCallsWaitingForNewCookie.push(r));
   };
   // This function is a helper for the next function defined below
   const attemptToResolveInvalidation = async (
     sessionChange: ClientSessionChange,
   ) => {
     const newAnonymousCookie = sessionChange.cookie;
     const newSessionChange = await fetchNewCookieFromNativeCredentials(
       dispatch,
       newAnonymousCookie,
       urlPrefix,
       logInActionSources.cookieInvalidationResolutionAttempt,
       keyserverID,
     );
 
     currentlyWaitingForNewCookie = false;
     const currentWaitingCalls = serverEndpointCallsWaitingForNewCookie;
     serverEndpointCallsWaitingForNewCookie = [];
 
     const newCallServerEndpoint = newSessionChange
       ? bindCookieAndUtilsIntoCallServerEndpoint({
           ...params,
           cookie: newSessionChange.cookie,
           sessionID: newSessionChange.sessionID,
           currentUserInfo: newSessionChange.currentUserInfo,
         })
       : null;
     for (const func of currentWaitingCalls) {
       func(newCallServerEndpoint);
     }
     return newCallServerEndpoint;
   };
   // If this function is called, callServerEndpoint got a response invalidating
   // its cookie, and is wondering if it should just like... give up?
   // Or if there's a chance at redemption
   const cookieInvalidationRecovery = (sessionChange: ClientSessionChange) => {
     if (!getConfig().resolveInvalidatedCookie) {
       // If there is no resolveInvalidatedCookie function, just let the caller
       // callServerEndpoint instance continue
       return Promise.resolve(null);
     }
     if (!loggedIn) {
       // We don't want to attempt any use native credentials of a logged out
       // user to log-in after a cookieInvalidation while logged out
       return Promise.resolve(null);
     }
     if (currentlyWaitingForNewCookie) {
       return new Promise(r => serverEndpointCallsWaitingForNewCookie.push(r));
     }
     currentlyWaitingForNewCookie = true;
     return attemptToResolveInvalidation(sessionChange);
   };
 
   return (
     endpoint: Endpoint,
     data: Object,
     options?: ?CallServerEndpointOptions,
   ) =>
     callServerEndpoint(
       cookie,
       boundSetNewSession,
       waitIfCookieInvalidated,
       cookieInvalidationRecovery,
       urlPrefix,
       sessionID,
       connectionStatus,
       lastCommunicatedPlatformDetails,
       socketAPIHandler,
       endpoint,
       data,
       dispatch,
       options,
       loggedIn,
     );
 }
 
 export type ActionFunc<F> = (callServerEndpoint: CallServerEndpoint) => F;
 export type BindServerCall = <F>(serverCall: ActionFunc<F>) => F;
 export type BindServerCallsParams = {
   +dispatch: Dispatch,
   +cookie: ?string,
   +urlPrefix: string,
   +sessionID: ?string,
   +currentUserInfo: ?CurrentUserInfo,
   +connectionStatus: ConnectionStatus,
   +lastCommunicatedPlatformDetails: ?PlatformDetails,
   +keyserverID: string,
 };
 
 // All server calls needs to include some information from the Redux state
 // (namely, the cookie). This information is used deep in the server call,
 // at the point where callServerEndpoint is called. We don't want to bother
 // propagating the cookie (and any future config info that callServerEndpoint
 // needs) through to the server calls so they can pass it to callServerEndpoint.
 // Instead, we "curry" the cookie onto callServerEndpoint within react-redux's
 // connect's mapStateToProps function, and then pass that "bound"
 // callServerEndpoint that no longer needs the cookie as a parameter on to
 // the server call.
 const baseCreateBoundServerCallsSelector = <F>(
   actionFunc: ActionFunc<F>,
 ): (BindServerCallsParams => F) =>
   createSelector(
     (state: BindServerCallsParams) => state.dispatch,
     (state: BindServerCallsParams) => state.cookie,
     (state: BindServerCallsParams) => state.urlPrefix,
     (state: BindServerCallsParams) => state.sessionID,
     (state: BindServerCallsParams) => state.currentUserInfo,
     (state: BindServerCallsParams) => state.connectionStatus,
     (state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
     (state: BindServerCallsParams) => state.keyserverID,
     (
       dispatch: Dispatch,
       cookie: ?string,
       urlPrefix: string,
       sessionID: ?string,
       currentUserInfo: ?CurrentUserInfo,
       connectionStatus: ConnectionStatus,
       lastCommunicatedPlatformDetails: ?PlatformDetails,
       keyserverID: string,
     ) => {
       const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({
         dispatch,
         cookie,
         urlPrefix,
         sessionID,
         currentUserInfo,
         connectionStatus,
         lastCommunicatedPlatformDetails,
         keyserverID,
       });
       return actionFunc(boundCallServerEndpoint);
     },
   );
 
 type CreateBoundServerCallsSelectorType = <F>(
   ActionFunc<F>,
 ) => BindServerCallsParams => F;
 const createBoundServerCallsSelector: CreateBoundServerCallsSelectorType =
   (_memoize(baseCreateBoundServerCallsSelector): any);
 
 function useServerCall<F>(
   serverCall: ActionFunc<F>,
   paramOverride?: ?$Shape<BindServerCallsParams>,
 ): F {
   const dispatch = useDispatch();
   const serverCallState = useSelector(
     serverCallStateSelector(ashoatKeyserverID),
   );
   return React.useMemo(() => {
     const { urlPrefix, connectionStatus } = serverCallState;
     invariant(
       !!urlPrefix && !!connectionStatus,
       'keyserver missing from keyserverStore',
     );
 
     return createBoundServerCallsSelector(serverCall)({
       ...serverCallState,
       urlPrefix,
       connectionStatus,
       dispatch,
       ...paramOverride,
       keyserverID: ashoatKeyserverID,
     });
   }, [serverCall, serverCallState, dispatch, paramOverride]);
 }
 
 let socketAPIHandler: ?SocketAPIHandler = null;
 function registerActiveSocket(passedSocketAPIHandler: ?SocketAPIHandler) {
   socketAPIHandler = passedSocketAPIHandler;
 }
 
 function sortThreadIDsPerKeyserver(threadIDs: $ReadOnlyArray<string>): {
   +[keyserverID: string]: $ReadOnlyArray<string>,
 } {
   const results = {};
   for (const threadID of threadIDs) {
     const keyserverID = extractKeyserverIDFromID(threadID);
     invariant(keyserverID, 'keyserver data missing from thread id');
     if (results[keyserverID] === undefined) {
       results[keyserverID] = [];
     }
     results[keyserverID].push(threadID);
   }
   return results;
 }
 
 function sortCalendarQueryPerKeyserver(
   calendarQuery: CalendarQuery,
   keyserverIDs: $ReadOnlyArray<string>,
 ): {
   +[keyserverID: string]: CalendarQuery,
 } {
   const { startDate, endDate, filters } = calendarQuery;
   const results = {};
 
   for (const keyserverID of keyserverIDs) {
     results[keyserverID] = {
       startDate,
       endDate,
       filters: [],
     };
   }
 
   for (const filter of filters) {
     if (filter.type === 'not_deleted') {
       for (const keyserverID in results) {
         results[keyserverID].filters.push({ type: 'not_deleted' });
       }
     } else if (filter.type === 'threads') {
       for (const threadID of filter.threadIDs) {
         const keyserverID = extractKeyserverIDFromID(threadID);
         if (results[keyserverID] === undefined) {
           continue;
         }
         let threadFilter = results[keyserverID].filters.find(
           flt => flt.type === 'threads',
         );
         if (!threadFilter) {
           threadFilter = { type: 'threads', threadIDs: [] };
           results[keyserverID].filters.push(threadFilter);
         }
 
         threadFilter.threadIDs.push(threadID);
       }
     } else {
       console.warn('unhandled filter in sortCalendarQueryPerKeyserver');
     }
   }
 
   return results;
 }
 
 export {
   useDispatchActionPromise,
   setNewSessionActionType,
   fetchNewCookieFromNativeCredentials,
   createBoundServerCallsSelector,
   registerActiveSocket,
   useServerCall,
   bindCookieAndUtilsIntoCallServerEndpoint,
   extractKeyserverIDFromID,
   sortThreadIDsPerKeyserver,
   sortCalendarQueryPerKeyserver,
 };
diff --git a/native/socket.react.js b/native/socket.react.js
index a9c2f20cc..a41704c8d 100644
--- a/native/socket.react.js
+++ b/native/socket.react.js
@@ -1,175 +1,177 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { useDispatch } from 'react-redux';
 
 import { useLogOut, logOutActionTypes } from 'lib/actions/user-actions.js';
-import { preRequestUserStateSelector } from 'lib/selectors/account-selectors.js';
+import { preRequestUserStateForSingleKeyserverSelector } from 'lib/selectors/account-selectors.js';
 import {
   cookieSelector,
   urlPrefixSelector,
   connectionSelector,
   lastCommunicatedPlatformDetailsSelector,
 } from 'lib/selectors/keyserver-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { accountHasPassword } from 'lib/shared/account-utils.js';
 import Socket, { type BaseSocketProps } from 'lib/socket/socket.react.js';
 import { logInActionSources } from 'lib/types/account-types.js';
 import {
   useDispatchActionPromise,
   fetchNewCookieFromNativeCredentials,
 } from 'lib/utils/action-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import { InputStateContext } from './input/input-state.js';
 import {
   activeMessageListSelector,
   nativeCalendarQuery,
 } from './navigation/nav-selectors.js';
 import { NavContext } from './navigation/navigation-context.js';
 import { useSelector } from './redux/redux-utils.js';
 import { noDataAfterPolicyAcknowledgmentSelector } from './selectors/account-selectors.js';
 import {
   openSocketSelector,
   sessionIdentificationSelector,
   nativeGetClientResponsesSelector,
   nativeSessionStateFuncSelector,
 } from './selectors/socket-selectors.js';
 import Alert from './utils/alert.js';
 import { useInitialNotificationsEncryptedMessage } from './utils/crypto-utils.js';
 import { decompressMessage } from './utils/decompress.js';
 
 const NativeSocket: React.ComponentType<BaseSocketProps> =
   React.memo<BaseSocketProps>(function NativeSocket(props: BaseSocketProps) {
     const inputState = React.useContext(InputStateContext);
     const navContext = React.useContext(NavContext);
 
     const cookie = useSelector(cookieSelector);
     const urlPrefix = useSelector(urlPrefixSelector(ashoatKeyserverID));
     invariant(urlPrefix, 'missing urlPrefix for given keyserver id');
     const connection = useSelector(connectionSelector(ashoatKeyserverID));
     invariant(connection, 'keyserver missing from keyserverStore');
     const frozen = useSelector(state => state.frozen);
     const active = useSelector(
       state => isLoggedIn(state) && state.lifecycleState !== 'background',
     );
     const noDataAfterPolicyAcknowledgment = useSelector(
       noDataAfterPolicyAcknowledgmentSelector(ashoatKeyserverID),
     );
     const currentUserInfo = useSelector(state => state.currentUserInfo);
 
     const openSocket = useSelector(openSocketSelector(ashoatKeyserverID));
     invariant(openSocket, 'openSocket failed to be created');
     const sessionIdentification = useSelector(sessionIdentificationSelector);
-    const preRequestUserState = useSelector(preRequestUserStateSelector);
+    const preRequestUserState = useSelector(
+      preRequestUserStateForSingleKeyserverSelector(ashoatKeyserverID),
+    );
 
     const getInitialNotificationsEncryptedMessage =
       useInitialNotificationsEncryptedMessage();
 
     const getClientResponses = useSelector(state =>
       nativeGetClientResponsesSelector({
         redux: state,
         navContext,
         getInitialNotificationsEncryptedMessage,
       }),
     );
     const sessionStateFunc = useSelector(state =>
       nativeSessionStateFuncSelector(ashoatKeyserverID)({
         redux: state,
         navContext,
       }),
     );
     const currentCalendarQuery = useSelector(state =>
       nativeCalendarQuery({
         redux: state,
         navContext,
       }),
     );
 
     const canSendReports = useSelector(
       state =>
         !state.frozen &&
         state.connectivity.hasWiFi &&
         (!inputState || !inputState.uploadInProgress()),
     );
 
     const activeThread = React.useMemo(() => {
       if (!active) {
         return null;
       }
       return activeMessageListSelector(navContext);
     }, [active, navContext]);
 
     const lastCommunicatedPlatformDetails = useSelector(
       lastCommunicatedPlatformDetailsSelector(ashoatKeyserverID),
     );
 
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const callLogOut = useLogOut();
 
     const socketCrashLoopRecovery = React.useCallback(async () => {
       if (!accountHasPassword(currentUserInfo)) {
         dispatchActionPromise(
           logOutActionTypes,
           callLogOut(preRequestUserState),
         );
         Alert.alert(
           'Log in needed',
           'After acknowledging the policies, we need you to log in to your account again',
           [{ text: 'OK' }],
         );
         return;
       }
 
       await fetchNewCookieFromNativeCredentials(
         dispatch,
         cookie,
         urlPrefix,
         logInActionSources.refetchUserDataAfterAcknowledgment,
         ashoatKeyserverID,
         getInitialNotificationsEncryptedMessage,
       );
     }, [
       callLogOut,
       cookie,
       currentUserInfo,
       dispatch,
       dispatchActionPromise,
       preRequestUserState,
       urlPrefix,
       getInitialNotificationsEncryptedMessage,
     ]);
 
     return (
       <Socket
         {...props}
         active={active}
         openSocket={openSocket}
         getClientResponses={getClientResponses}
         activeThread={activeThread}
         sessionStateFunc={sessionStateFunc}
         sessionIdentification={sessionIdentification}
         cookie={cookie}
         urlPrefix={urlPrefix}
         connection={connection}
         currentCalendarQuery={currentCalendarQuery}
         canSendReports={canSendReports}
         frozen={frozen}
         preRequestUserState={preRequestUserState}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         logOut={callLogOut}
         noDataAfterPolicyAcknowledgment={noDataAfterPolicyAcknowledgment}
         socketCrashLoopRecovery={socketCrashLoopRecovery}
         getInitialNotificationsEncryptedMessage={
           getInitialNotificationsEncryptedMessage
         }
         lastCommunicatedPlatformDetails={lastCommunicatedPlatformDetails}
         decompressSocketMessage={decompressMessage}
       />
     );
   });
 
 export default NativeSocket;
diff --git a/web/socket.react.js b/web/socket.react.js
index 4be55225c..426ecbb25 100644
--- a/web/socket.react.js
+++ b/web/socket.react.js
@@ -1,98 +1,100 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { useDispatch } from 'react-redux';
 
 import { useLogOut } from 'lib/actions/user-actions.js';
-import { preRequestUserStateSelector } from 'lib/selectors/account-selectors.js';
+import { preRequestUserStateForSingleKeyserverSelector } from 'lib/selectors/account-selectors.js';
 import {
   cookieSelector,
   urlPrefixSelector,
   connectionSelector,
   lastCommunicatedPlatformDetailsSelector,
 } from 'lib/selectors/keyserver-selectors.js';
 import Socket, { type BaseSocketProps } from 'lib/socket/socket.react.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import { useSelector } from './redux/redux-utils.js';
 import {
   activeThreadSelector,
   webCalendarQuery,
 } from './selectors/nav-selectors.js';
 import {
   openSocketSelector,
   sessionIdentificationSelector,
   webGetClientResponsesSelector,
   webSessionStateFuncSelector,
 } from './selectors/socket-selectors.js';
 import { decompressMessage } from './utils/decompress.js';
 
 const WebSocket: React.ComponentType<BaseSocketProps> =
   React.memo<BaseSocketProps>(function WebSocket(props) {
     const cookie = useSelector(cookieSelector);
     const urlPrefix = useSelector(urlPrefixSelector(ashoatKeyserverID));
     invariant(urlPrefix, 'missing urlPrefix for given keyserver id');
     const connection = useSelector(connectionSelector(ashoatKeyserverID));
     invariant(connection, 'keyserver missing from keyserverStore');
     const active = useSelector(
       state =>
         !!state.currentUserInfo &&
         !state.currentUserInfo.anonymous &&
         state.lifecycleState !== 'background',
     );
 
     const openSocket = useSelector(openSocketSelector(ashoatKeyserverID));
     invariant(openSocket, 'openSocket failed to be created');
     const sessionIdentification = useSelector(sessionIdentificationSelector);
-    const preRequestUserState = useSelector(preRequestUserStateSelector);
+    const preRequestUserState = useSelector(
+      preRequestUserStateForSingleKeyserverSelector(ashoatKeyserverID),
+    );
     const getClientResponses = useSelector(webGetClientResponsesSelector);
     const sessionStateFunc = useSelector(
       webSessionStateFuncSelector(ashoatKeyserverID),
     );
     const currentCalendarQuery = useSelector(webCalendarQuery);
 
     const reduxActiveThread = useSelector(activeThreadSelector);
     const windowActive = useSelector(state => state.windowActive);
     const activeThread = React.useMemo(() => {
       if (!active || !windowActive) {
         return null;
       }
       return reduxActiveThread;
     }, [active, windowActive, reduxActiveThread]);
 
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const callLogOut = useLogOut();
 
     const lastCommunicatedPlatformDetails = useSelector(
       lastCommunicatedPlatformDetailsSelector(ashoatKeyserverID),
     );
 
     return (
       <Socket
         {...props}
         active={active}
         openSocket={openSocket}
         getClientResponses={getClientResponses}
         activeThread={activeThread}
         sessionStateFunc={sessionStateFunc}
         sessionIdentification={sessionIdentification}
         cookie={cookie}
         urlPrefix={urlPrefix}
         connection={connection}
         currentCalendarQuery={currentCalendarQuery}
         canSendReports={true}
         frozen={false}
         preRequestUserState={preRequestUserState}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         logOut={callLogOut}
         lastCommunicatedPlatformDetails={lastCommunicatedPlatformDetails}
         decompressSocketMessage={decompressMessage}
       />
     );
   });
 
 export default WebSocket;