diff --git a/keyserver/src/responders/version-responders.js b/keyserver/src/responders/version-responders.js
index 852a3f14b..b79e26f1f 100644
--- a/keyserver/src/responders/version-responders.js
+++ b/keyserver/src/responders/version-responders.js
@@ -1,19 +1,40 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import type { VersionResponse } from 'lib/types/device-types.js';
+import { getCommConfig } from 'lib/utils/comm-config.js';
 import { tShape } from 'lib/utils/validation-utils.js';
 
+import type { UserCredentials } from '../user/checks.js';
+import { fetchIdentityInfo } from '../user/identity.js';
 import { keyserverCodeVersion } from '../version.js';
 
 export const versionResponseValidator: TInterface<VersionResponse> =
-  tShape<VersionResponse>({ codeVersion: t.Number });
-
-const versionResponse = { codeVersion: keyserverCodeVersion };
+  tShape<VersionResponse>({
+    codeVersion: t.Number,
+    ownerUsername: t.maybe(t.String),
+    ownerID: t.maybe(t.String),
+  });
 
 async function versionResponder(): Promise<VersionResponse> {
-  return versionResponse;
+  const userInfoPromise = getCommConfig<UserCredentials>({
+    folder: 'secrets',
+    name: 'user_credentials',
+  });
+
+  const identityInfoPromise = fetchIdentityInfo();
+
+  const [userInfo, identityInfo] = await Promise.all([
+    userInfoPromise,
+    identityInfoPromise,
+  ]);
+
+  return {
+    codeVersion: keyserverCodeVersion,
+    ownerUsername: userInfo?.username,
+    ownerID: identityInfo?.userId,
+  };
 }
 
 export { versionResponder };
diff --git a/keyserver/src/user/checks.js b/keyserver/src/user/checks.js
index cdd1e43d7..e68c64b2b 100644
--- a/keyserver/src/user/checks.js
+++ b/keyserver/src/user/checks.js
@@ -1,31 +1,31 @@
 // @flow
 
 import { getCommConfig } from 'lib/utils/comm-config.js';
-type UserCredentials = { +username: string, +password: string };
+export type UserCredentials = { +username: string, +password: string };
 
 async function ensureUserCredentials() {
   const userCredentials = await getCommConfig<UserCredentials>({
     folder: 'secrets',
     name: 'user_credentials',
   });
 
   if (!userCredentials) {
     console.warn(
       'User credentials for the keyserver owner must be specified. They can be ' +
         'specified either by setting the ' +
         '`COMM_JSONCONFIG_secrets_user_credentials` environmental variable, or by ' +
         'setting a file at keyserver/secrets/user_credentials.json. The contents ' +
         'should be a JSON blob that looks like this:\n' +
         '{\n' +
         '  "username": <user>,\n' +
         '  "password": <pass>\n' +
         '}\n',
     );
 
     // Since we don't want to apply the migration until there are credentials;
     // throw the error and force keyserver to be configured next restart
     throw new Error('missing_keyserver_owner_credentials');
   }
 }
 
 export { ensureUserCredentials };
diff --git a/lib/actions/device-actions.js b/lib/actions/device-actions.js
index b089a1fca..297cc76bf 100644
--- a/lib/actions/device-actions.js
+++ b/lib/actions/device-actions.js
@@ -1,93 +1,123 @@
 // @flow
 
-import type { VersionResponse } from '../types/device-types.js';
-import type { CallServerEndpoint } from '../utils/call-server-endpoint.js';
+import type { GetVersionActionPayload } from '../types/device-types';
 import { getConfig } from '../utils/config.js';
-import type { CallKeyserverEndpoint } from '../utils/keyserver-call.js';
 import { useKeyserverCall } from '../utils/keyserver-call.js';
+import type {
+  CallKeyserverEndpoint,
+  KeyserverCallParamOverride,
+} from '../utils/keyserver-call.js';
 
 export type DeviceTokens = {
   +[keyserverID: string]: ?string,
 };
 export type SetDeviceTokenActionPayload = {
   +deviceTokens: DeviceTokens,
 };
 
 const setDeviceTokenActionTypes = Object.freeze({
   started: 'SET_DEVICE_TOKEN_STARTED',
   success: 'SET_DEVICE_TOKEN_SUCCESS',
   failed: 'SET_DEVICE_TOKEN_FAILED',
 });
 const setDeviceToken =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: DeviceTokens) => Promise<SetDeviceTokenActionPayload>) =>
   async input => {
     const requests = {};
     for (const keyserverID in input) {
       requests[keyserverID] = {
         deviceToken: input[keyserverID],
         platformDetails: getConfig().platformDetails,
       };
     }
     await callKeyserverEndpoint('update_device_token', requests);
     return { deviceTokens: input };
   };
 
 function useSetDeviceToken(): (
   input: DeviceTokens,
 ) => Promise<SetDeviceTokenActionPayload> {
   return useKeyserverCall(setDeviceToken);
 }
 
 const setDeviceTokenFanout =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: ?string) => Promise<SetDeviceTokenActionPayload>) =>
   async input => {
     const requests = {};
     const deviceTokens = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = {
         deviceToken: input,
         platformDetails: getConfig().platformDetails,
       };
       deviceTokens[keyserverID] = input;
     }
 
     await callKeyserverEndpoint('update_device_token', requests);
     return { deviceTokens };
   };
 
 function useSetDeviceTokenFanout(): (
   input: ?string,
 ) => Promise<SetDeviceTokenActionPayload> {
   return useKeyserverCall(setDeviceTokenFanout);
 }
 
 const getVersionActionTypes = Object.freeze({
   started: 'GET_VERSION_STARTED',
   success: 'GET_VERSION_SUCCESS',
   failed: 'GET_VERSION_FAILED',
 });
+// useGetVersion should be passed paramOverride containing keyserverInfos
+// with entries for the keyservers we want to connect to.
+// They should contain the urlPrefix of the keyserver.
+// The key should also be the urlPrefix,
+// since the id of the keyserver is not yet known.
 const getVersion =
-  (callServerEndpoint: CallServerEndpoint): (() => Promise<VersionResponse>) =>
+  (
+    callKeyserverEndpoint: CallKeyserverEndpoint,
+    allKeyserverIDs: $ReadOnlyArray<string>,
+  ): (() => Promise<GetVersionActionPayload>) =>
   async () => {
-    const response = await callServerEndpoint('version');
-    return {
-      codeVersion: response.codeVersion,
-    };
+    const requests = {};
+    for (const keyserverID of allKeyserverIDs) {
+      requests[keyserverID] = {};
+    }
+
+    const responses = await callKeyserverEndpoint('version', requests);
+
+    const result = { versionResponses: {} };
+    for (const keyserverID in responses) {
+      const { codeVersion, ownerUsername, ownerID } = responses[keyserverID];
+      result.versionResponses[ownerID] = {
+        codeVersion,
+        ownerUsername,
+        ownerID,
+      };
+    }
+
+    return result;
   };
 
+function useGetVersion(
+  paramOverride?: ?KeyserverCallParamOverride,
+): () => Promise<GetVersionActionPayload> {
+  return useKeyserverCall(getVersion, paramOverride);
+}
+
 const updateLastCommunicatedPlatformDetailsActionType =
   'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS';
 
 export {
   setDeviceTokenActionTypes,
   useSetDeviceToken,
   useSetDeviceTokenFanout,
   getVersionActionTypes,
-  getVersion,
+  useGetVersion,
   updateLastCommunicatedPlatformDetailsActionType,
 };
diff --git a/lib/types/device-types.js b/lib/types/device-types.js
index 771e9185f..cf42a32e2 100644
--- a/lib/types/device-types.js
+++ b/lib/types/device-types.js
@@ -1,46 +1,52 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { values } from '../utils/objects.js';
 
 const deviceTypesObj = Object.freeze({
   ios: 'ios',
   android: 'android',
 });
 export type DeviceType = $Values<typeof deviceTypesObj>;
 export type Platform = DeviceType | 'web' | 'windows' | 'macos';
 
 export const deviceTypes: $ReadOnlyArray<DeviceType> = values(deviceTypesObj);
 
 export function isDeviceType(platform: ?string): boolean {
   return platform === 'ios' || platform === 'android';
 }
 
 export function assertDeviceType(deviceType: ?string): DeviceType {
   invariant(
     deviceType === 'ios' || deviceType === 'android',
     'string is not DeviceType enum',
   );
   return deviceType;
 }
 
 export function isWebPlatform(platform: ?string): boolean {
   return platform === 'web' || platform === 'windows' || platform === 'macos';
 }
 
 export type DeviceTokenUpdateRequest = {
   +deviceToken: string,
   +deviceType?: DeviceType,
   +platformDetails?: PlatformDetails,
 };
 
 export type PlatformDetails = {
   +platform: Platform,
   +codeVersion?: number,
   +stateVersion?: number,
 };
 
 export type VersionResponse = {
   +codeVersion: number,
+  +ownerUsername: ?string,
+  +ownerID: ?string,
+};
+
+export type GetVersionActionPayload = {
+  +versionResponses: { +[keyserverId: string]: VersionResponse },
 };
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index e1bdf6ab9..366bb8b80 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1254 +1,1257 @@
 // @flow
 
 import type {
   LogOutResult,
   LogInStartingPayload,
   LogInResult,
   RegisterResult,
   DefaultNotificationPayload,
   ClaimUsernameResponse,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type { CryptoStore } from './crypto-types.js';
-import type { VersionResponse, PlatformDetails } from './device-types.js';
+import type {
+  GetVersionActionPayload,
+  PlatformDetails,
+} from './device-types.js';
 import type { ClientDBDraftInfo, DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
   CalendarQuery,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { IntegrityStore } from './integrity-types.js';
 import type { KeyserverStore, AddKeyserverPayload } from './keyserver-types.js';
 import type { LifecycleState } from './lifecycle-state-types.js';
 import type {
   FetchInviteLinksResponse,
   InviteLink,
   InviteLinksStore,
   InviteLinkVerificationResponse,
   DisableInviteLinkPayload,
 } from './link-types.js';
 import type { LoadingStatus, LoadingInfo } from './loading-types.js';
 import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
 import type { MessageReportCreationResult } from './message-report-types.js';
 import type {
   MessageStore,
   RawMultimediaMessageInfo,
   FetchMessageInfosPayload,
   SendMessagePayload,
   EditMessagePayload,
   SaveMessagesPayload,
   NewMessagesPayload,
   MessageStorePrunePayload,
   LocallyComposedMessageInfo,
   ClientDBMessageInfo,
   SimpleMessagesPayload,
   ClientDBThreadMessageInfo,
   FetchPinnedMessagesResult,
   SearchMessagesResponse,
 } from './message-types.js';
 import type { RawReactionMessageInfo } from './messages/reaction.js';
 import type { RawTextMessageInfo } from './messages/text.js';
 import type { BaseNavInfo } from './nav-types.js';
 import {
   type ForcePolicyAcknowledgmentPayload,
   type PolicyAcknowledgmentPayload,
   type UserPolicies,
 } from './policy-types.js';
 import type { RelationshipErrors } from './relationship-types.js';
 import type {
   EnabledReports,
   ClearDeliveredReportsPayload,
   QueueReportsPayload,
   ReportStore,
   ClientReportCreationRequest,
 } from './report-types.js';
 import type {
   ProcessServerRequestAction,
   GetOlmSessionInitializationDataResponse,
 } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateDisconnectedBarPayload,
 } from './socket-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type { GlobalThemeInfo } from './theme-types.js';
 import type { ThreadActivityStore } from './thread-activity-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
   RoleModificationPayload,
   RoleDeletionPayload,
 } from './thread-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type { CurrentUserInfo, UserStore } from './user-types.js';
 import type { SetDeviceTokenActionPayload } from '../actions/device-actions.js';
 import type { Shape } from '../types/core.js';
 import type { NotifPermissionAlertInfo } from '../utils/push-alerts.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo = BaseNavInfo> = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +notifPermissionAlertInfo: NotifPermissionAlertInfo,
   +actualizedCalendarQuery: CalendarQuery,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +nextLocalID: number,
   +dataLoaded: boolean,
   +userPolicies: UserPolicies,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
   ...
 };
 
 export type NativeAppState = BaseAppState<>;
 export type WebAppState = BaseAppState<> & {
   +cryptoStore: CryptoStore,
   +pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type BaseAction =
   | {
       +type: '@@redux/INIT',
       +payload?: void,
     }
   | {
       +type: 'FETCH_ENTRIES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_SUCCESS',
       +payload: FetchEntryInfosResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_SUCCESS',
       +payload: LogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CLAIM_USERNAME_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CLAIM_USERNAME_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CLAIM_USERNAME_SUCCESS',
       +payload: ClaimUsernameResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_SUCCESS',
       +payload: LogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_LOCAL_ENTRY',
       +payload: RawEntryInfo,
     }
   | {
       +type: 'CREATE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_SUCCESS',
       +payload: CreateEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_SUCCESS',
       +payload: SaveEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CONCURRENT_MODIFICATION_RESET',
       +payload: {
         +id: string,
         +dbText: string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: {
         +localID: ?string,
         +serverID: ?string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ENTRY_SUCCESS',
       +payload: ?DeleteEntryResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'LOG_IN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'REGISTER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_SUCCESS',
       +payload: RegisterResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_SUCCESS',
       +payload: NewThreadResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
       +payload: {
         +entryID: string,
         +text: string,
         +deleted: boolean,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_SUCCESS',
       +payload: RestoreEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_SUCCESS',
       +payload: ThreadJoinPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_NEW_SESSION',
       +payload: SetSessionPayload,
     }
   | {
       +type: 'persist/REHYDRATE',
       +payload: ?BaseAppState<>,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
       +payload: SimpleMessagesPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawTextMessageInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawMultimediaMessageInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawReactionMessageInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
         +targetMessageID: string,
         +reaction: string,
         +action: string,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_SUCCESS',
       +payload: UserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_SUCCESS',
       +payload: ExactUserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_DRAFT',
       +payload: {
         +key: string,
         +text: string,
       },
     }
   | {
       +type: 'MOVE_DRAFT',
       +payload: {
         +oldKey: string,
         +newKey: string,
       },
     }
   | {
       +type: 'SET_CLIENT_DB_STORE',
       +payload: {
         +currentUserID: ?string,
         +drafts: $ReadOnlyArray<ClientDBDraftInfo>,
         +messages: ?$ReadOnlyArray<ClientDBMessageInfo>,
         +threadStore: ?ThreadStore,
         +messageStoreThreads: ?$ReadOnlyArray<ClientDBThreadMessageInfo>,
         +reports: ?$ReadOnlyArray<ClientReportCreationRequest>,
       },
     }
   | {
       +type: 'UPDATE_ACTIVITY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_SUCCESS',
       +payload: ActivityUpdateSuccessPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_SUCCESS',
       +payload: SetDeviceTokenActionPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'QUEUE_REPORTS',
       +payload: QueueReportsPayload,
     }
   | {
       +type: 'SET_URL_PREFIX',
       +payload: string,
     }
   | {
       +type: 'SAVE_MESSAGES',
       +payload: SaveMessagesPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_THREAD_FILTER',
       +payload: CalendarThreadFilter,
     }
   | {
       +type: 'CLEAR_CALENDAR_THREAD_FILTER',
       +payload?: void,
     }
   | {
       +type: 'SET_CALENDAR_DELETED_FILTER',
       +payload: SetCalendarDeletedFilterPayload,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_SUCCESS',
       +payload: SubscriptionUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload?: CalendarQueryUpdateStartingPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
       +payload: CalendarQueryUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FULL_STATE_SYNC',
       +payload: StateSyncFullActionPayload,
     }
   | {
       +type: 'INCREMENTAL_STATE_SYNC',
       +payload: StateSyncIncrementalActionPayload,
     }
   | ProcessServerRequestAction
   | {
       +type: 'UPDATE_CONNECTION_STATUS',
       +payload: UpdateConnectionStatusPayload,
     }
   | {
       +type: 'QUEUE_ACTIVITY_UPDATES',
       +payload: QueueActivityUpdatesPayload,
     }
   | {
       +type: 'UNSUPERVISED_BACKGROUND',
       +payload?: void,
     }
   | {
       +type: 'UPDATE_LIFECYCLE_STATE',
       +payload: LifecycleState,
     }
   | {
       +type: 'ENABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'DISABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'UPDATE_REPORTS_ENABLED',
       +payload: Shape<EnabledReports>,
     }
   | {
       +type: 'PROCESS_UPDATES',
       +payload: ClientUpdatesResultWithUserInfos,
     }
   | {
       +type: 'PROCESS_MESSAGES',
       +payload: NewMessagesPayload,
     }
   | {
       +type: 'MESSAGE_STORE_PRUNE',
       +payload: MessageStorePrunePayload,
     }
   | {
       +type: 'SET_LATE_RESPONSE',
       +payload: SetLateResponsePayload,
     }
   | {
       +type: 'UPDATE_DISCONNECTED_BAR',
       +payload: UpdateDisconnectedBarPayload,
     }
   | {
       +type: 'REQUEST_ACCESS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
       +payload: UpdateMultimediaMessageMediaPayload,
     }
   | {
       +type: 'CREATE_LOCAL_MESSAGE',
       +payload: LocallyComposedMessageInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_SUCCESS',
       +payload: RelationshipErrors,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_STARTED',
       +payload: {
         +threadID: string,
         +unread: boolean,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
       +payload: SetThreadUnreadStatusPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_USER_SETTINGS_SUCCESS',
       +payload: DefaultNotificationPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_FAILED',
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_SUCCESS',
       +payload: MessageReportCreationResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FORCE_POLICY_ACKNOWLEDGMENT',
       +payload: ForcePolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
       +payload: PolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_STARTED',
       +payload: LogInStartingPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RECORD_NOTIF_PERMISSION_ALERT',
       +payload: { +time: number },
     }
   | {
       +type: 'UPDATE_USER_AVATAR_STARTED',
       +payload: UpdateUserAvatarRequest,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_SUCCESS',
       +payload: UpdateUserAvatarResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_SUCCESS',
       +payload: EditMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
       +payload: ToggleMessagePinResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_SUCCESS',
       +payload: FetchPinnedMessagesResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_SUCCESS',
       +payload: InviteLinkVerificationResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
       +payload: FetchInviteLinksResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'UPDATE_CHAT_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CHAT_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'SEARCH_MESSAGES_STARTED',
       +payload: void,
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_SUCCESS',
       +payload: SearchMessagesResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
       +payload: InviteLink,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_SUCCESS',
       +payload: DisableInviteLinkPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
       +payload: GetOlmSessionInitializationDataResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DATA_LOADED',
       +payload: {
         +dataLoaded: boolean,
       },
     }
   | {
       +type: 'GET_VERSION_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'GET_VERSION_SUCCESS',
-      +payload: VersionResponse,
+      +payload: GetVersionActionPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_VERSION_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS',
       +payload: PlatformDetails,
     }
   | { +type: 'RESET_USER_STATE', +payload?: void }
   | {
       +type: 'MODIFY_COMMUNITY_ROLE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
       +payload: RoleModificationPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'MODIFY_COMMUNITY_ROLE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_COMMUNITY_ROLE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'DELETE_COMMUNITY_ROLE_SUCCESS',
       +payload: RoleDeletionPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_COMMUNITY_ROLE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_ACCESS_TOKEN',
       +payload: string,
     }
   | {
       +type: 'UPDATE_THREAD_LAST_NAVIGATED',
       +payload: { +threadID: string, +time: number },
     }
   | {
       +type: 'UPDATE_INTEGRITY_STORE',
       +payload: {
         +threadIDsToHash?: $ReadOnlyArray<string>,
         +threadHashingStatus?: 'starting' | 'running' | 'completed',
       },
     }
   | {
       +type: 'UPDATE_THEME_INFO',
       +payload: Shape<GlobalThemeInfo>,
     }
   | {
       +type: 'ADD_KEYSERVER',
       +payload: AddKeyserverPayload,
     };
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type SuperAction = {
   type: string,
   payload?: ActionPayload,
   loadingInfo?: LoadingInfo,
   error?: boolean,
 };
 type ThunkedAction = (dispatch: Dispatch) => void;
 export type PromisedAction = (dispatch: Dispatch) => Promise<void>;
 export type Dispatch = ((promisedAction: PromisedAction) => Promise<void>) &
   ((thunkedAction: ThunkedAction) => void) &
   ((action: SuperAction) => boolean);
 
 // This is lifted from redux-persist/lib/constants.js
 // I don't want to add redux-persist to the web/server bundles...
 // import { REHYDRATE } from 'redux-persist';
 export const rehydrateActionType = 'persist/REHYDRATE';
diff --git a/lib/utils/keyserver-call.js b/lib/utils/keyserver-call.js
index 8871fbebe..69178335e 100644
--- a/lib/utils/keyserver-call.js
+++ b/lib/utils/keyserver-call.js
@@ -1,163 +1,167 @@
 // @flow
 
 import _memoize from 'lodash/memoize.js';
 import * as React from 'react';
 import { useDispatch } from 'react-redux';
 import { createSelector } from 'reselect';
 
 import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';
 import type { BindServerCallsParams } from './action-utils.js';
 import type {
   CallServerEndpoint,
   CallServerEndpointOptions,
 } from './call-server-endpoint.js';
 import { promiseAll } from './promises.js';
 import { useSelector } from './redux-utils.js';
 import type { PlatformDetails } from '../types/device-types.js';
 import type { Endpoint } from '../types/endpoints.js';
 import type { KeyserverInfo } from '../types/keyserver-types.js';
 import type { Dispatch } from '../types/redux-types.js';
 import type { ConnectionStatus } from '../types/socket-types.js';
 import type { CurrentUserInfo } from '../types/user-types.js';
 
 export type CallKeyserverEndpoint = (
   endpoint: Endpoint,
   requests: { +[keyserverID: string]: ?{ +[string]: mixed } },
   options?: ?CallServerEndpointOptions,
 ) => Promise<{ +[keyserverID: string]: any }>;
 
 export type ActionFunc<Args: mixed, Return> = (
   callServerEndpoint: CallKeyserverEndpoint,
   // The second argument is only used in actions that call all keyservers,
   // and the request to all keyservers are exactly the same.
   // An example of such action is fetchEntries.
   allKeyserverIDs: $ReadOnlyArray<string>,
 ) => Args => Promise<Return>;
 
 // _memoize memoizes the function by caching the result.
 // The first argument of the memoized function is used as the map cache key.
 const baseCreateBoundServerCallsSelector = (
   // eslint-disable-next-line no-unused-vars
   keyserverID: string,
 ): (BindServerCallsParams => CallServerEndpoint) =>
   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,
     (
       dispatch: Dispatch,
       cookie: ?string,
       urlPrefix: string,
       sessionID: ?string,
       currentUserInfo: ?CurrentUserInfo,
       connectionStatus: ConnectionStatus,
       lastCommunicatedPlatformDetails: ?PlatformDetails,
     ) =>
       bindCookieAndUtilsIntoCallServerEndpoint({
         dispatch,
         cookie,
         urlPrefix,
         sessionID,
         currentUserInfo,
         connectionStatus,
         lastCommunicatedPlatformDetails,
       }),
   );
 
 type CreateBoundServerCallsSelectorType = (
   keyserverID: string,
 ) => BindServerCallsParams => CallServerEndpoint;
 const createBoundServerCallsSelector: CreateBoundServerCallsSelectorType =
   (_memoize(baseCreateBoundServerCallsSelector): any);
 
+export type KeyserverInfoPartial = $Shape<KeyserverInfo>;
+
 export type BindKeyserverCallParams = {
   +dispatch: Dispatch,
   +currentUserInfo: ?CurrentUserInfo,
-  +keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
+  +keyserverInfos: { +[keyserverID: string]: KeyserverInfoPartial },
 };
 
 const bindCallKeyserverEndpointSelector = createSelector(
   (state: BindKeyserverCallParams) => state.dispatch,
   (state: BindKeyserverCallParams) => state.currentUserInfo,
   (state: BindKeyserverCallParams) => state.keyserverInfos,
   (
     dispatch: Dispatch,
     currentUserInfo: ?CurrentUserInfo,
     keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
   ) => {
     return _memoize(
       <Args: mixed, Return>(
         keyserverCall: ActionFunc<Args, Return>,
       ): (Args => Promise<Return>) => {
         const callKeyserverEndpoint = (
           endpoint: Endpoint,
           requests: { +[keyserverID: string]: ?{ +[string]: mixed } },
           options?: ?CallServerEndpointOptions,
         ) => {
           const bindCallKeyserverEndpoint = (keyserverID: string) => {
             const {
               cookie,
               urlPrefix,
               sessionID,
               connection,
               lastCommunicatedPlatformDetails,
             } = keyserverInfos[keyserverID];
 
             const boundCallServerEndpoint = createBoundServerCallsSelector(
               keyserverID,
             )({
               dispatch,
               currentUserInfo,
               cookie,
               urlPrefix,
               sessionID,
-              connectionStatus: connection.status,
+              connectionStatus: connection?.status,
               lastCommunicatedPlatformDetails,
             });
 
             return boundCallServerEndpoint(
               endpoint,
               requests[keyserverID],
               options,
             );
           };
 
           const promises = {};
           for (const keyserverID in requests) {
             promises[keyserverID] = bindCallKeyserverEndpoint(keyserverID);
           }
           return promiseAll(promises);
         };
         const keyserverIDs = Object.keys(keyserverInfos);
         return keyserverCall(callKeyserverEndpoint, keyserverIDs);
       },
     );
   },
 );
 
+export type KeyserverCallParamOverride = $Shape<BindKeyserverCallParams>;
+
 function useKeyserverCall<Args: mixed, Return>(
   keyserverCall: ActionFunc<Args, Return>,
-  paramOverride?: ?$Shape<BindKeyserverCallParams>,
+  paramOverride?: ?KeyserverCallParamOverride,
 ): Args => Promise<Return> {
   const dispatch = useDispatch();
   const keyserverInfos = useSelector(
     state => state.keyserverStore.keyserverInfos,
   );
   const currentUserInfo = useSelector(state => state.currentUserInfo);
   const bindCallKeyserverEndpointToAction = bindCallKeyserverEndpointSelector({
     dispatch,
     keyserverInfos,
     currentUserInfo,
     ...paramOverride,
   });
   return React.useMemo(
     () => bindCallKeyserverEndpointToAction(keyserverCall),
     [bindCallKeyserverEndpointToAction, keyserverCall],
   );
 }
 
 export { useKeyserverCall };
diff --git a/native/account/registration/keyserver-selection.react.js b/native/account/registration/keyserver-selection.react.js
index 70e15b7c1..8592771c5 100644
--- a/native/account/registration/keyserver-selection.react.js
+++ b/native/account/registration/keyserver-selection.react.js
@@ -1,267 +1,268 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import {
-  getVersion,
+  useGetVersion,
   getVersionActionTypes,
 } from 'lib/actions/device-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
-import {
-  useServerCall,
-  useDispatchActionPromise,
-} from 'lib/utils/action-utils.js';
+import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import RegistrationButtonContainer from './registration-button-container.react.js';
 import RegistrationButton from './registration-button.react.js';
 import RegistrationContainer from './registration-container.react.js';
 import RegistrationContentContainer from './registration-content-container.react.js';
 import { RegistrationContext } from './registration-context.js';
 import type { RegistrationNavigationProp } from './registration-navigator.react.js';
 import RegistrationTextInput from './registration-text-input.react.js';
 import {
   RegistrationTile,
   RegistrationTileHeader,
 } from './registration-tile.react.js';
 import type { CoolOrNerdMode } from './registration-types.js';
 import CommIcon from '../../components/comm-icon.react.js';
 import {
   type NavigationRoute,
   ConnectEthereumRouteName,
 } from '../../navigation/route-names.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { useStyles, useColors } from '../../themes/colors.js';
 import { defaultURLPrefix } from '../../utils/url-utils.js';
 
 type Selection = 'ashoat' | 'custom';
 
 export type KeyserverSelectionParams = {
   +userSelections: {
     +coolOrNerdMode: CoolOrNerdMode,
   },
 };
 
 const getVersionLoadingStatusSelector = createLoadingStatusSelector(
   getVersionActionTypes,
 );
 
 type KeyserverSelectionError = 'cant_reach_keyserver';
 
 type Props = {
   +navigation: RegistrationNavigationProp<'KeyserverSelection'>,
   +route: NavigationRoute<'KeyserverSelection'>,
 };
 function KeyserverSelection(props: Props): React.Node {
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const { cachedSelections, setCachedSelections } = registrationContext;
 
   const initialKeyserverURL = cachedSelections.keyserverURL;
   const [customKeyserver, setCustomKeyserver] = React.useState(
     initialKeyserverURL === defaultURLPrefix ? '' : initialKeyserverURL,
   );
   const customKeyserverTextInputRef = React.useRef();
 
   let initialSelection;
   if (initialKeyserverURL === defaultURLPrefix) {
     initialSelection = 'ashoat';
   } else if (initialKeyserverURL) {
     initialSelection = 'custom';
   }
 
   const [error, setError] = React.useState<?KeyserverSelectionError>();
 
   const [currentSelection, setCurrentSelection] =
     React.useState<?Selection>(initialSelection);
   const selectAshoat = React.useCallback(() => {
     setCurrentSelection('ashoat');
     customKeyserverTextInputRef.current?.blur();
     if (currentSelection !== 'ashoat') {
       setError(undefined);
     }
   }, [currentSelection]);
   const customKeyserverEmpty = !customKeyserver;
   const selectCustom = React.useCallback(() => {
     setCurrentSelection('custom');
     if (customKeyserverEmpty) {
       customKeyserverTextInputRef.current?.focus();
     }
     if (currentSelection !== 'custom') {
       setError(undefined);
     }
   }, [customKeyserverEmpty, currentSelection]);
   const onCustomKeyserverFocus = React.useCallback(() => {
     setCurrentSelection('custom');
     setError(undefined);
   }, []);
 
   let keyserverURL;
   if (currentSelection === 'ashoat') {
     keyserverURL = defaultURLPrefix;
   } else if (currentSelection === 'custom' && customKeyserver) {
     keyserverURL = customKeyserver;
   }
 
   const versionLoadingStatus = useSelector(getVersionLoadingStatusSelector);
   let buttonState = keyserverURL ? 'enabled' : 'disabled';
   if (versionLoadingStatus === 'loading') {
     buttonState = 'loading';
   }
 
   const serverCallParamOverride = React.useMemo(
     () => ({
-      urlPrefix: keyserverURL,
+      keyserverInfos: {
+        [keyserverURL]: {
+          urlPrefix: keyserverURL,
+        },
+      },
     }),
     [keyserverURL],
   );
-  const getVersionCall = useServerCall(getVersion, serverCallParamOverride);
+  const getVersionCall = useGetVersion(serverCallParamOverride);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const { navigate } = props.navigation;
   const { coolOrNerdMode } = props.route.params.userSelections;
   const onSubmit = React.useCallback(async () => {
     setError(undefined);
     if (!keyserverURL) {
       return;
     }
 
     const getVersionPromise = getVersionCall();
     dispatchActionPromise(getVersionActionTypes, getVersionPromise);
 
     // We don't care about the result; just need to make sure this doesn't throw
     try {
       await getVersionPromise;
     } catch {
       setError('cant_reach_keyserver');
       return;
     }
 
     setCachedSelections(oldUserSelections => ({
       ...oldUserSelections,
       keyserverURL,
     }));
     navigate<'ConnectEthereum'>({
       name: ConnectEthereumRouteName,
       params: { userSelections: { coolOrNerdMode, keyserverURL } },
     });
   }, [
     navigate,
     coolOrNerdMode,
     keyserverURL,
     setCachedSelections,
     dispatchActionPromise,
     getVersionCall,
   ]);
 
   const styles = useStyles(unboundStyles);
   let errorText;
   if (error === 'cant_reach_keyserver') {
     errorText = (
       <Text style={styles.errorText}>Can&rsquo;t reach that keyserver :(</Text>
     );
   }
 
   const colors = useColors();
   return (
     <RegistrationContainer>
       <RegistrationContentContainer>
         <Text style={styles.header}>Select a keyserver to join</Text>
         <Text style={styles.body}>
           Chat communities on Comm are hosted on keyservers, which are
           user-operated backends.
         </Text>
         <Text style={styles.body}>
           Keyservers allow Comm to offer strong privacy guarantees without
           sacrificing functionality.
         </Text>
         <RegistrationTile
           selected={currentSelection === 'ashoat'}
           onSelect={selectAshoat}
         >
           <RegistrationTileHeader>
             <CommIcon
               name="cloud-filled"
               size={16}
               color={colors.panelForegroundLabel}
               style={styles.cloud}
             />
             <Text style={styles.tileTitleText}>ashoat</Text>
           </RegistrationTileHeader>
           <Text style={styles.tileBody}>
             Ashoat is Comm’s founder, and his keyserver currently hosts most of
             the communities on Comm.
           </Text>
         </RegistrationTile>
         <RegistrationTile
           selected={currentSelection === 'custom'}
           onSelect={selectCustom}
         >
           <RegistrationTileHeader>
             <Text style={styles.tileTitleText}>Enter a keyserver</Text>
           </RegistrationTileHeader>
           <RegistrationTextInput
             value={customKeyserver}
             onChangeText={setCustomKeyserver}
             placeholder="Keyserver URL"
             onFocus={onCustomKeyserverFocus}
             returnKeyType="go"
             onSubmitEditing={onSubmit}
             keyboardType="url"
             autoCorrect={false}
             autoCapitalize="none"
             ref={customKeyserverTextInputRef}
           />
         </RegistrationTile>
         <View style={styles.error}>{errorText}</View>
       </RegistrationContentContainer>
       <RegistrationButtonContainer>
         <RegistrationButton
           onPress={onSubmit}
           label="Next"
           variant={buttonState}
         />
       </RegistrationButtonContainer>
     </RegistrationContainer>
   );
 }
 
 const unboundStyles = {
   header: {
     fontSize: 24,
     color: 'panelForegroundLabel',
     paddingBottom: 16,
   },
   body: {
     fontFamily: 'Arial',
     fontSize: 15,
     lineHeight: 20,
     color: 'panelForegroundSecondaryLabel',
     paddingBottom: 16,
   },
   tileTitleText: {
     flex: 1,
     fontSize: 18,
     color: 'panelForegroundLabel',
   },
   tileBody: {
     fontFamily: 'Arial',
     fontSize: 13,
     color: 'panelForegroundSecondaryLabel',
   },
   cloud: {
     marginRight: 8,
   },
   error: {
     marginTop: 16,
   },
   errorText: {
     fontFamily: 'Arial',
     fontSize: 15,
     lineHeight: 20,
     color: 'redText',
   },
 };
 
 export default KeyserverSelection;