diff --git a/lib/actions/activity-actions.js b/lib/actions/activity-actions.js
index 48bc4646d..cd68f8897 100644
--- a/lib/actions/activity-actions.js
+++ b/lib/actions/activity-actions.js
@@ -1,103 +1,103 @@
 // @flow
 
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
+import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import type {
   ActivityUpdate,
   ActivityUpdateSuccessPayload,
   SetThreadUnreadStatusPayload,
   SetThreadUnreadStatusRequest,
 } from '../types/activity-types.js';
-import { useKeyserverCall } from '../utils/keyserver-call.js';
 
 export type UpdateActivityInput = {
   +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
 };
 
 const updateActivityActionTypes = Object.freeze({
   started: 'UPDATE_ACTIVITY_STARTED',
   success: 'UPDATE_ACTIVITY_SUCCESS',
   failed: 'UPDATE_ACTIVITY_FAILED',
 });
 const updateActivity =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: UpdateActivityInput) => Promise<ActivityUpdateSuccessPayload>) =>
   async input => {
     const { activityUpdates } = input;
     const requests: { [string]: { +updates: ActivityUpdate[] } } = {};
     for (const update of activityUpdates) {
       const keyserverID = extractKeyserverIDFromID(update.threadID);
       if (!requests[keyserverID]) {
         requests[keyserverID] = { updates: [] };
       }
       requests[keyserverID].updates.push(update);
     }
 
     const responses = await callKeyserverEndpoint('update_activity', requests);
 
     let unfocusedToUnread: $ReadOnlyArray<string> = [];
     for (const keyserverID in responses) {
       unfocusedToUnread = unfocusedToUnread.concat(
         responses[keyserverID].unfocusedToUnread,
       );
     }
 
     const sortedActivityUpdates: {
       [keyserverID: string]: $ReadOnlyArray<ActivityUpdate>,
     } = {};
     for (const keyserverID in requests) {
       sortedActivityUpdates[keyserverID] = requests[keyserverID].updates;
     }
 
     return {
       activityUpdates: sortedActivityUpdates,
       result: {
         unfocusedToUnread,
       },
     };
   };
 
 function useUpdateActivity(): (
   input: UpdateActivityInput,
 ) => Promise<ActivityUpdateSuccessPayload> {
   return useKeyserverCall(updateActivity);
 }
 
 const setThreadUnreadStatusActionTypes = Object.freeze({
   started: 'SET_THREAD_UNREAD_STATUS_STARTED',
   success: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
   failed: 'SET_THREAD_UNREAD_STATUS_FAILED',
 });
 const setThreadUnreadStatus =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: SetThreadUnreadStatusRequest,
   ) => Promise<SetThreadUnreadStatusPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'set_thread_unread_status',
       requests,
     );
     return {
       resetToUnread: responses[keyserverID].resetToUnread,
       threadID: input.threadID,
     };
   };
 
 function useSetThreadUnreadStatus(): (
   request: SetThreadUnreadStatusRequest,
 ) => Promise<SetThreadUnreadStatusPayload> {
   return useKeyserverCall(setThreadUnreadStatus);
 }
 
 export {
   updateActivityActionTypes,
   useUpdateActivity,
   setThreadUnreadStatusActionTypes,
   useSetThreadUnreadStatus,
 };
diff --git a/lib/actions/device-actions.js b/lib/actions/device-actions.js
index d1e09d224..afcace736 100644
--- a/lib/actions/device-actions.js
+++ b/lib/actions/device-actions.js
@@ -1,124 +1,126 @@
 // @flow
 
+import {
+  useKeyserverCall,
+  type KeyserverCallParamOverride,
+} from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import type {
   GetVersionActionPayload,
   DeviceTokenUpdateRequest,
 } from '../types/device-types';
 import { getConfig } from '../utils/config.js';
-import { useKeyserverCall } from '../utils/keyserver-call.js';
-import type { 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: { [string]: DeviceTokenUpdateRequest } = {};
     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: { [string]: DeviceTokenUpdateRequest } = {};
     const deviceTokens: { [string]: ?string } = {};
     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 =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): (() => Promise<GetVersionActionPayload>) =>
   async () => {
     const requests: { [string]: {} } = {};
     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,
   useGetVersion,
   updateLastCommunicatedPlatformDetailsActionType,
 };
diff --git a/lib/actions/entry-actions.js b/lib/actions/entry-actions.js
index 1de17c9d2..502c456d8 100644
--- a/lib/actions/entry-actions.js
+++ b/lib/actions/entry-actions.js
@@ -1,348 +1,348 @@
 // @flow
 
 import {
   extractKeyserverIDFromID,
   sortCalendarQueryPerKeyserver,
 } from '../keyserver-conn/keyserver-call-utils.js';
+import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import { getNextLocalID } from '../shared/message-utils.js';
 import type {
   RawEntryInfo,
   CalendarQuery,
   SaveEntryInfo,
   SaveEntryResult,
   CreateEntryInfo,
   CreateEntryPayload,
   DeleteEntryInfo,
   DeleteEntryResult,
   RestoreEntryInfo,
   RestoreEntryResult,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
 } from '../types/entry-types.js';
 import type { HistoryRevisionInfo } from '../types/history-types.js';
 import { dateFromString } from '../utils/date-utils.js';
-import { useKeyserverCall } from '../utils/keyserver-call.js';
 
 const fetchEntriesActionTypes = Object.freeze({
   started: 'FETCH_ENTRIES_STARTED',
   success: 'FETCH_ENTRIES_SUCCESS',
   failed: 'FETCH_ENTRIES_FAILED',
 });
 const fetchEntries =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((calendarQuery: CalendarQuery) => Promise<FetchEntryInfosResult>) =>
   async calendarQuery => {
     const calendarQueries = sortCalendarQueryPerKeyserver(
       calendarQuery,
       allKeyserverIDs,
     );
     const requests: { [string]: CalendarQuery } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = calendarQueries[keyserverID];
     }
 
     const responses = await callKeyserverEndpoint('fetch_entries', requests);
     let rawEntryInfos: $ReadOnlyArray<RawEntryInfo> = [];
     for (const keyserverID in responses) {
       rawEntryInfos = rawEntryInfos.concat(
         responses[keyserverID].rawEntryInfos,
       );
     }
     return {
       rawEntryInfos,
     };
   };
 
 function useFetchEntries(): (
   calendarQuery: CalendarQuery,
 ) => Promise<FetchEntryInfosResult> {
   return useKeyserverCall(fetchEntries);
 }
 
 export type UpdateCalendarQueryInput = {
   +calendarQuery: CalendarQuery,
   +reduxAlreadyUpdated?: boolean,
   +keyserverIDs?: $ReadOnlyArray<string>,
 };
 
 const updateCalendarQueryActionTypes = Object.freeze({
   started: 'UPDATE_CALENDAR_QUERY_STARTED',
   success: 'UPDATE_CALENDAR_QUERY_SUCCESS',
   failed: 'UPDATE_CALENDAR_QUERY_FAILED',
 });
 const updateCalendarQuery =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((
     input: UpdateCalendarQueryInput,
   ) => Promise<CalendarQueryUpdateResult>) =>
   async input => {
     const { calendarQuery, reduxAlreadyUpdated = false } = input;
 
     const keyserverIDs = input.keyserverIDs ?? allKeyserverIDs;
 
     const calendarQueries = sortCalendarQueryPerKeyserver(
       calendarQuery,
       keyserverIDs,
     );
 
     const requests: { [string]: CalendarQuery } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = calendarQueries[keyserverID];
     }
 
     const responses = await callKeyserverEndpoint(
       'update_calendar_query',
       requests,
     );
     let rawEntryInfos: $ReadOnlyArray<RawEntryInfo> = [];
     let deletedEntryIDs: $ReadOnlyArray<string> = [];
     for (const keyserverID in responses) {
       rawEntryInfos = rawEntryInfos.concat(
         responses[keyserverID].rawEntryInfos,
       );
       deletedEntryIDs = deletedEntryIDs.concat(
         responses[keyserverID].deletedEntryIDs,
       );
     }
     return {
       rawEntryInfos,
       deletedEntryIDs,
       calendarQuery,
       calendarQueryAlreadyUpdated: reduxAlreadyUpdated,
       keyserverIDs,
     };
   };
 
 function useUpdateCalendarQuery(): (
   input: UpdateCalendarQueryInput,
 ) => Promise<CalendarQueryUpdateResult> {
   return useKeyserverCall(updateCalendarQuery);
 }
 
 const createLocalEntryActionType = 'CREATE_LOCAL_ENTRY';
 function createLocalEntry(
   threadID: string,
   dateString: string,
   creatorID: string,
 ): RawEntryInfo {
   const date = dateFromString(dateString);
   const localID = getNextLocalID();
   const newEntryInfo: RawEntryInfo = {
     localID,
     threadID,
     text: '',
     year: date.getFullYear(),
     month: date.getMonth() + 1,
     day: date.getDate(),
     creationTime: Date.now(),
     creatorID,
     deleted: false,
   };
   return newEntryInfo;
 }
 
 const createEntryActionTypes = Object.freeze({
   started: 'CREATE_ENTRY_STARTED',
   success: 'CREATE_ENTRY_SUCCESS',
   failed: 'CREATE_ENTRY_FAILED',
 });
 const createEntry =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: CreateEntryInfo) => Promise<CreateEntryPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const calendarQueries = sortCalendarQueryPerKeyserver(input.calendarQuery, [
       keyserverID,
     ]);
 
     const requests = {
       [keyserverID]: {
         ...input,
         calendarQuery: calendarQueries[keyserverID],
       },
     };
 
     const response = await callKeyserverEndpoint('create_entry', requests);
     return {
       entryID: response[keyserverID].entryID,
       newMessageInfos: response[keyserverID].newMessageInfos,
       threadID: response[keyserverID].threadID,
       localID: response[keyserverID].localID,
       updatesResult: response[keyserverID].updatesResult,
     };
   };
 
 function useCreateEntry(): (
   request: CreateEntryInfo,
 ) => Promise<CreateEntryPayload> {
   return useKeyserverCall(createEntry);
 }
 
 const saveEntryActionTypes = Object.freeze({
   started: 'SAVE_ENTRY_STARTED',
   success: 'SAVE_ENTRY_SUCCESS',
   failed: 'SAVE_ENTRY_FAILED',
 });
 const concurrentModificationResetActionType = 'CONCURRENT_MODIFICATION_RESET';
 const saveEntry =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: SaveEntryInfo) => Promise<SaveEntryResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.entryID);
     const calendarQueries = sortCalendarQueryPerKeyserver(input.calendarQuery, [
       keyserverID,
     ]);
 
     const requests = {
       [keyserverID]: {
         ...input,
         calendarQuery: calendarQueries[keyserverID],
       },
     };
 
     const response = await callKeyserverEndpoint('update_entry', requests);
     return {
       entryID: response[keyserverID].entryID,
       newMessageInfos: response[keyserverID].newMessageInfos,
       updatesResult: response[keyserverID].updatesResult,
     };
   };
 
 function useSaveEntry(): (input: SaveEntryInfo) => Promise<SaveEntryResult> {
   return useKeyserverCall(saveEntry);
 }
 
 const deleteEntryActionTypes = Object.freeze({
   started: 'DELETE_ENTRY_STARTED',
   success: 'DELETE_ENTRY_SUCCESS',
   failed: 'DELETE_ENTRY_FAILED',
 });
 const deleteEntry =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((info: DeleteEntryInfo) => Promise<DeleteEntryResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.entryID);
     const calendarQueries = sortCalendarQueryPerKeyserver(input.calendarQuery, [
       keyserverID,
     ]);
 
     const requests = {
       [keyserverID]: {
         ...input,
         calendarQuery: calendarQueries[keyserverID],
         timestamp: Date.now(),
       },
     };
 
     const response = await callKeyserverEndpoint('delete_entry', requests);
     return {
       newMessageInfos: response[keyserverID].newMessageInfos,
       threadID: response[keyserverID].threadID,
       updatesResult: response[keyserverID].updatesResult,
     };
   };
 
 function useDeleteEntry(): (
   info: DeleteEntryInfo,
 ) => Promise<DeleteEntryResult> {
   return useKeyserverCall(deleteEntry);
 }
 
 export type FetchRevisionsForEntryInput = {
   +entryID: string,
 };
 const fetchRevisionsForEntryActionTypes = Object.freeze({
   started: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
   success: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
   failed: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
 });
 const fetchRevisionsForEntry =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: FetchRevisionsForEntryInput,
   ) => Promise<$ReadOnlyArray<HistoryRevisionInfo>>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.entryID);
     const requests = {
       [keyserverID]: {
         id: input.entryID,
       },
     };
 
     const response = await callKeyserverEndpoint(
       'fetch_entry_revisions',
       requests,
     );
     return response[keyserverID].result;
   };
 
 function useFetchRevisionsForEntry(): (
   input: FetchRevisionsForEntryInput,
 ) => Promise<$ReadOnlyArray<HistoryRevisionInfo>> {
   return useKeyserverCall(fetchRevisionsForEntry);
 }
 
 const restoreEntryActionTypes = Object.freeze({
   started: 'RESTORE_ENTRY_STARTED',
   success: 'RESTORE_ENTRY_SUCCESS',
   failed: 'RESTORE_ENTRY_FAILED',
 });
 const restoreEntry =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: RestoreEntryInfo) => Promise<RestoreEntryResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.entryID);
     const calendarQueries = sortCalendarQueryPerKeyserver(input.calendarQuery, [
       keyserverID,
     ]);
 
     const requests = {
       [keyserverID]: {
         ...input,
         calendarQuery: calendarQueries[keyserverID],
         timestamp: Date.now(),
       },
     };
 
     const response = await callKeyserverEndpoint('restore_entry', requests);
     return {
       newMessageInfos: response[keyserverID].newMessageInfos,
       updatesResult: response[keyserverID].updatesResult,
     };
   };
 
 function useRestoreEntry(): (
   input: RestoreEntryInfo,
 ) => Promise<RestoreEntryResult> {
   return useKeyserverCall(restoreEntry);
 }
 
 export {
   fetchEntriesActionTypes,
   useFetchEntries,
   updateCalendarQueryActionTypes,
   useUpdateCalendarQuery,
   createLocalEntryActionType,
   createLocalEntry,
   createEntryActionTypes,
   useCreateEntry,
   saveEntryActionTypes,
   concurrentModificationResetActionType,
   useSaveEntry,
   deleteEntryActionTypes,
   useDeleteEntry,
   fetchRevisionsForEntryActionTypes,
   useFetchRevisionsForEntry,
   restoreEntryActionTypes,
   useRestoreEntry,
 };
diff --git a/lib/actions/link-actions.js b/lib/actions/link-actions.js
index b0379d55c..e9d89e774 100644
--- a/lib/actions/link-actions.js
+++ b/lib/actions/link-actions.js
@@ -1,194 +1,194 @@
 // @flow
 import * as React from 'react';
 
 import type { CallSingleKeyserverEndpoint } from '../keyserver-conn/call-single-keyserver-endpoint.js';
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
+import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import type {
   FetchInviteLinksResponse,
   InviteLinkVerificationRequest,
   InviteLinkVerificationResponse,
   CreateOrUpdatePublicLinkRequest,
   InviteLink,
   DisableInviteLinkRequest,
   DisableInviteLinkPayload,
 } from '../types/link-types.js';
 import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
-import { useKeyserverCall } from '../utils/keyserver-call.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 const verifyInviteLinkActionTypes = Object.freeze({
   started: 'VERIFY_INVITE_LINK_STARTED',
   success: 'VERIFY_INVITE_LINK_SUCCESS',
   failed: 'VERIFY_INVITE_LINK_FAILED',
 });
 const verifyInviteLink =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((input: {
     +request: InviteLinkVerificationRequest,
     +keyserverID: string,
   }) => Promise<InviteLinkVerificationResponse>) =>
   async input => {
     const { request, keyserverID } = input;
     const requests = {
       [keyserverID]: request,
     };
     const responses = await callSingleKeyserverEndpoint(
       'verify_invite_link',
       requests,
     );
     const response = responses[keyserverID];
     if (response.status === 'valid' || response.status === 'already_joined') {
       return {
         status: response.status,
         community: response.community,
       };
     }
     return {
       status: response.status,
     };
   };
 
 function useVerifyInviteLink(
   keyserverOverride?: ?{
     +keyserverID: string,
     +keyserverURL: string,
   },
 ): (
   request: InviteLinkVerificationRequest,
 ) => Promise<InviteLinkVerificationResponse> {
   const keyserverID =
     keyserverOverride?.keyserverID ?? authoritativeKeyserverID();
   const isKeyserverKnown = useSelector(
     state => !!state.keyserverStore.keyserverInfos[keyserverID],
   );
 
   let paramOverride = null;
   if (keyserverOverride && !isKeyserverKnown) {
     paramOverride = {
       keyserverInfos: {
         [keyserverOverride.keyserverID]: {
           urlPrefix: keyserverOverride.keyserverURL,
         },
       },
     };
   }
   const callVerifyInviteLink = useKeyserverCall(
     verifyInviteLink,
     paramOverride,
   );
   return React.useCallback(
     (request: InviteLinkVerificationRequest) =>
       callVerifyInviteLink({ request, keyserverID }),
     [callVerifyInviteLink, keyserverID],
   );
 }
 
 const fetchPrimaryInviteLinkActionTypes = Object.freeze({
   started: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
   success: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
   failed: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
 });
 const fetchPrimaryInviteLinks =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): (() => Promise<FetchInviteLinksResponse>) =>
   async () => {
     const requests: { [string]: void } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = undefined;
     }
     const responses = await callKeyserverEndpoint(
       'fetch_primary_invite_links',
       requests,
     );
     let links: $ReadOnlyArray<InviteLink> = [];
     for (const keyserverID in responses) {
       links = links.concat(responses[keyserverID].links);
     }
     return {
       links,
     };
   };
 
 function useFetchPrimaryInviteLinks(): () => Promise<FetchInviteLinksResponse> {
   return useKeyserverCall(fetchPrimaryInviteLinks);
 }
 
 const createOrUpdatePublicLinkActionTypes = Object.freeze({
   started: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
   success: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
   failed: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
 });
 
 const createOrUpdatePublicLink =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: CreateOrUpdatePublicLinkRequest) => Promise<InviteLink>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.communityID);
     const requests = {
       [keyserverID]: {
         name: input.name,
         communityID: input.communityID,
       },
     };
 
     const responses = await callKeyserverEndpoint(
       'create_or_update_public_link',
       requests,
     );
     const response = responses[keyserverID];
     return {
       name: response.name,
       primary: response.primary,
       role: response.role,
       communityID: response.communityID,
       expirationTime: response.expirationTime,
       limitOfUses: response.limitOfUses,
       numberOfUses: response.numberOfUses,
     };
   };
 
 function useCreateOrUpdatePublicLink(): (
   input: CreateOrUpdatePublicLinkRequest,
 ) => Promise<InviteLink> {
   return useKeyserverCall(createOrUpdatePublicLink);
 }
 
 const disableInviteLinkLinkActionTypes = Object.freeze({
   started: 'DISABLE_INVITE_LINK_STARTED',
   success: 'DISABLE_INVITE_LINK_SUCCESS',
   failed: 'DISABLE_INVITE_LINK_FAILED',
 });
 
 const disableInviteLink =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: DisableInviteLinkRequest) => Promise<DisableInviteLinkPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.communityID);
     const requests = { [keyserverID]: input };
 
     await callKeyserverEndpoint('disable_invite_link', requests);
     return input;
   };
 
 function useDisableInviteLink(): (
   input: DisableInviteLinkRequest,
 ) => Promise<DisableInviteLinkPayload> {
   return useKeyserverCall(disableInviteLink);
 }
 
 export {
   verifyInviteLinkActionTypes,
   useVerifyInviteLink,
   fetchPrimaryInviteLinkActionTypes,
   useFetchPrimaryInviteLinks,
   createOrUpdatePublicLinkActionTypes,
   useCreateOrUpdatePublicLink,
   disableInviteLinkLinkActionTypes,
   useDisableInviteLink,
 };
diff --git a/lib/actions/message-actions.js b/lib/actions/message-actions.js
index a758a6a20..dafe51d24 100644
--- a/lib/actions/message-actions.js
+++ b/lib/actions/message-actions.js
@@ -1,530 +1,530 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { CallSingleKeyserverEndpointResultInfo } from '../keyserver-conn/call-single-keyserver-endpoint.js';
 import {
   extractKeyserverIDFromID,
   sortThreadIDsPerKeyserver,
 } from '../keyserver-conn/keyserver-call-utils.js';
+import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import type {
   FetchMessageInfosPayload,
   SendMessageResult,
   SendEditMessageResult,
   SendReactionMessageRequest,
   SimpleMessagesPayload,
   SendEditMessageRequest,
   FetchPinnedMessagesRequest,
   FetchPinnedMessagesResult,
   SearchMessagesRequest,
   SearchMessagesResponse,
   FetchMessageInfosRequest,
   RawMessageInfo,
   MessageTruncationStatuses,
 } from '../types/message-types.js';
 import type { MediaMessageServerDBContent } from '../types/messages/media.js';
 import type {
   ToggleMessagePinRequest,
   ToggleMessagePinResult,
 } from '../types/thread-types.js';
-import { useKeyserverCall } from '../utils/keyserver-call.js';
 
 const fetchMessagesBeforeCursorActionTypes = Object.freeze({
   started: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
   success: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
   failed: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
 });
 export type FetchMessagesBeforeCursorInput = {
   +threadID: string,
   +beforeMessageID: string,
 };
 const fetchMessagesBeforeCursor =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: FetchMessagesBeforeCursorInput,
   ) => Promise<FetchMessageInfosPayload>) =>
   async input => {
     const { threadID, beforeMessageID } = input;
 
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = {
       [keyserverID]: {
         cursors: {
           [threadID]: beforeMessageID,
         },
       },
     };
 
     const responses = await callKeyserverEndpoint('fetch_messages', requests);
     return {
       threadID,
       rawMessageInfos: responses[keyserverID].rawMessageInfos,
       truncationStatus: responses[keyserverID].truncationStatuses[threadID],
     };
   };
 
 function useFetchMessagesBeforeCursor(): (
   input: FetchMessagesBeforeCursorInput,
 ) => Promise<FetchMessageInfosPayload> {
   return useKeyserverCall(fetchMessagesBeforeCursor);
 }
 
 export type FetchMostRecentMessagesInput = {
   +threadID: string,
 };
 
 const fetchMostRecentMessagesActionTypes = Object.freeze({
   started: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
   success: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
   failed: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
 });
 const fetchMostRecentMessages =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: FetchMostRecentMessagesInput,
   ) => Promise<FetchMessageInfosPayload>) =>
   async input => {
     const { threadID } = input;
 
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = {
       [keyserverID]: {
         cursors: {
           [threadID]: null,
         },
       },
     };
 
     const responses = await callKeyserverEndpoint('fetch_messages', requests);
     return {
       threadID,
       rawMessageInfos: responses[keyserverID].rawMessageInfos,
       truncationStatus: responses[keyserverID].truncationStatuses[threadID],
     };
   };
 
 function useFetchMostRecentMessages(): (
   input: FetchMostRecentMessagesInput,
 ) => Promise<FetchMessageInfosPayload> {
   return useKeyserverCall(fetchMostRecentMessages);
 }
 
 const fetchSingleMostRecentMessagesFromThreadsActionTypes = Object.freeze({
   started: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
   success: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
   failed: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
 });
 const fetchSingleMostRecentMessagesFromThreads =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((threadIDs: $ReadOnlyArray<string>) => Promise<SimpleMessagesPayload>) =>
   async threadIDs => {
     const sortedThreadIDs = sortThreadIDsPerKeyserver(threadIDs);
 
     const requests: { [string]: FetchMessageInfosRequest } = {};
     for (const keyserverID in sortedThreadIDs) {
       const cursors = Object.fromEntries(
         sortedThreadIDs[keyserverID].map(threadID => [threadID, null]),
       );
       requests[keyserverID] = {
         cursors,
         numberPerThread: 1,
       };
     }
 
     const responses = await callKeyserverEndpoint('fetch_messages', requests);
     let rawMessageInfos: $ReadOnlyArray<RawMessageInfo> = [];
     let truncationStatuses: MessageTruncationStatuses = {};
     for (const keyserverID in responses) {
       rawMessageInfos = rawMessageInfos.concat(
         responses[keyserverID].rawMessageInfos,
       );
       truncationStatuses = {
         ...truncationStatuses,
         ...responses[keyserverID].truncationStatuses,
       };
     }
 
     return {
       rawMessageInfos,
       truncationStatuses,
     };
   };
 
 function useFetchSingleMostRecentMessagesFromThreads(): (
   threadIDs: $ReadOnlyArray<string>,
 ) => Promise<SimpleMessagesPayload> {
   return useKeyserverCall(fetchSingleMostRecentMessagesFromThreads);
 }
 
 export type SendTextMessageInput = {
   +threadID: string,
   +localID: string,
   +text: string,
   +sidebarCreation?: boolean,
 };
 
 const sendTextMessageActionTypes = Object.freeze({
   started: 'SEND_TEXT_MESSAGE_STARTED',
   success: 'SEND_TEXT_MESSAGE_SUCCESS',
   failed: 'SEND_TEXT_MESSAGE_FAILED',
 });
 const sendTextMessage =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: SendTextMessageInput) => Promise<SendMessageResult>) =>
   async input => {
     let resultInfo;
     const getResultInfo = (
       passedResultInfo: CallSingleKeyserverEndpointResultInfo,
     ) => {
       resultInfo = passedResultInfo;
     };
     const { threadID, localID, text, sidebarCreation } = input;
     let payload = { threadID, localID, text };
     if (sidebarCreation) {
       payload = { ...payload, sidebarCreation };
     }
 
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: payload };
 
     const responses = await callKeyserverEndpoint(
       'create_text_message',
       requests,
       {
         getResultInfo,
       },
     );
     const resultInterface = resultInfo?.interface;
     invariant(
       resultInterface,
       'getResultInfo not called before callKeyserverEndpoint resolves',
     );
     return {
       id: responses[keyserverID].newMessageInfo.id,
       time: responses[keyserverID].newMessageInfo.time,
       interface: resultInterface,
     };
   };
 
 function useSendTextMessage(): (
   input: SendTextMessageInput,
 ) => Promise<SendMessageResult> {
   return useKeyserverCall(sendTextMessage);
 }
 
 const createLocalMessageActionType = 'CREATE_LOCAL_MESSAGE';
 
 export type SendMultimediaMessageInput = {
   +threadID: string,
   +localID: string,
   +mediaMessageContents: $ReadOnlyArray<MediaMessageServerDBContent>,
   +sidebarCreation?: boolean,
 };
 
 const sendMultimediaMessageActionTypes = Object.freeze({
   started: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
   success: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
   failed: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
 });
 const sendMultimediaMessage =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: SendMultimediaMessageInput) => Promise<SendMessageResult>) =>
   async input => {
     let resultInfo;
     const getResultInfo = (
       passedResultInfo: CallSingleKeyserverEndpointResultInfo,
     ) => {
       resultInfo = passedResultInfo;
     };
     const { threadID, localID, mediaMessageContents, sidebarCreation } = input;
     let payload = { threadID, localID, mediaMessageContents };
     if (sidebarCreation) {
       payload = { ...payload, sidebarCreation };
     }
 
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: payload };
 
     const responses = await callKeyserverEndpoint(
       'create_multimedia_message',
       requests,
       { getResultInfo },
     );
     const resultInterface = resultInfo?.interface;
     invariant(
       resultInterface,
       'getResultInfo not called before callKeyserverEndpoint resolves',
     );
     return {
       id: responses[keyserverID].newMessageInfo.id,
       time: responses[keyserverID].newMessageInfo.time,
       interface: resultInterface,
     };
   };
 
 function useSendMultimediaMessage(): (
   input: SendMultimediaMessageInput,
 ) => Promise<SendMessageResult> {
   return useKeyserverCall(sendMultimediaMessage);
 }
 
 export type LegacySendMultimediaMessageInput = {
   +threadID: string,
   +localID: string,
   +mediaIDs: $ReadOnlyArray<string>,
   +sidebarCreation?: boolean,
 };
 
 const legacySendMultimediaMessage =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: LegacySendMultimediaMessageInput,
   ) => Promise<SendMessageResult>) =>
   async input => {
     let resultInfo;
     const getResultInfo = (
       passedResultInfo: CallSingleKeyserverEndpointResultInfo,
     ) => {
       resultInfo = passedResultInfo;
     };
     const { threadID, localID, mediaIDs, sidebarCreation } = input;
     let payload = { threadID, localID, mediaIDs };
     if (sidebarCreation) {
       payload = { ...payload, sidebarCreation };
     }
 
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: payload };
 
     const responses = await callKeyserverEndpoint(
       'create_multimedia_message',
       requests,
       { getResultInfo },
     );
     const resultInterface = resultInfo?.interface;
     invariant(
       resultInterface,
       'getResultInfo not called before callKeyserverEndpoint resolves',
     );
     return {
       id: responses[keyserverID].newMessageInfo.id,
       time: responses[keyserverID].newMessageInfo.time,
       interface: resultInterface,
     };
   };
 
 function useLegacySendMultimediaMessage(): (
   input: LegacySendMultimediaMessageInput,
 ) => Promise<SendMessageResult> {
   return useKeyserverCall(legacySendMultimediaMessage);
 }
 
 const sendReactionMessageActionTypes = Object.freeze({
   started: 'SEND_REACTION_MESSAGE_STARTED',
   success: 'SEND_REACTION_MESSAGE_SUCCESS',
   failed: 'SEND_REACTION_MESSAGE_FAILED',
 });
 const sendReactionMessage =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: SendReactionMessageRequest) => Promise<SendMessageResult>) =>
   async input => {
     let resultInfo;
     const getResultInfo = (
       passedResultInfo: CallSingleKeyserverEndpointResultInfo,
     ) => {
       resultInfo = passedResultInfo;
     };
 
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = {
       [keyserverID]: {
         threadID: input.threadID,
         localID: input.localID,
         targetMessageID: input.targetMessageID,
         reaction: input.reaction,
         action: input.action,
       },
     };
 
     const responses = await callKeyserverEndpoint(
       'create_reaction_message',
       requests,
       { getResultInfo },
     );
 
     const resultInterface = resultInfo?.interface;
     invariant(
       resultInterface,
       'getResultInfo not called before callKeyserverEndpoint resolves',
     );
 
     return {
       id: responses[keyserverID].newMessageInfo.id,
       time: responses[keyserverID].newMessageInfo.time,
       interface: resultInterface,
     };
   };
 
 function useSendReactionMessage(): (
   input: SendReactionMessageRequest,
 ) => Promise<SendMessageResult> {
   return useKeyserverCall(sendReactionMessage);
 }
 
 const sendEditMessageActionTypes = Object.freeze({
   started: 'SEND_EDIT_MESSAGE_STARTED',
   success: 'SEND_EDIT_MESSAGE_SUCCESS',
   failed: 'SEND_EDIT_MESSAGE_FAILED',
 });
 const sendEditMessage =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: SendEditMessageRequest) => Promise<SendEditMessageResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.targetMessageID);
     const requests = {
       [keyserverID]: {
         targetMessageID: input.targetMessageID,
         text: input.text,
       },
     };
 
     const responses = await callKeyserverEndpoint('edit_message', requests);
 
     return {
       newMessageInfos: responses[keyserverID].newMessageInfos,
     };
   };
 
 function useSendEditMessage(): (
   input: SendEditMessageRequest,
 ) => Promise<SendEditMessageResult> {
   return useKeyserverCall(sendEditMessage);
 }
 
 const saveMessagesActionType = 'SAVE_MESSAGES';
 const processMessagesActionType = 'PROCESS_MESSAGES';
 const messageStorePruneActionType = 'MESSAGE_STORE_PRUNE';
 
 const fetchPinnedMessageActionTypes = Object.freeze({
   started: 'FETCH_PINNED_MESSAGES_STARTED',
   success: 'FETCH_PINNED_MESSAGES_SUCCESS',
   failed: 'FETCH_PINNED_MESSAGES_FAILED',
 });
 const fetchPinnedMessages =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: FetchPinnedMessagesRequest,
   ) => Promise<FetchPinnedMessagesResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'fetch_pinned_messages',
       requests,
     );
 
     return { pinnedMessages: responses[keyserverID].pinnedMessages };
   };
 
 function useFetchPinnedMessages(): (
   input: FetchPinnedMessagesRequest,
 ) => Promise<FetchPinnedMessagesResult> {
   return useKeyserverCall(fetchPinnedMessages);
 }
 
 const searchMessagesActionTypes = Object.freeze({
   started: 'SEARCH_MESSAGES_STARTED',
   success: 'SEARCH_MESSAGES_SUCCESS',
   failed: 'SEARCH_MESSAGES_FAILED',
 });
 
 const searchMessages =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: SearchMessagesRequest) => Promise<SearchMessagesResponse>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint('search_messages', requests);
 
     return {
       messages: responses[keyserverID].messages,
       endReached: responses[keyserverID].endReached,
     };
   };
 
 function useSearchMessages(): (
   input: SearchMessagesRequest,
 ) => Promise<SearchMessagesResponse> {
   return useKeyserverCall(searchMessages);
 }
 
 const toggleMessagePinActionTypes = Object.freeze({
   started: 'TOGGLE_MESSAGE_PIN_STARTED',
   success: 'TOGGLE_MESSAGE_PIN_SUCCESS',
   failed: 'TOGGLE_MESSAGE_PIN_FAILED',
 });
 const toggleMessagePin =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: ToggleMessagePinRequest) => Promise<ToggleMessagePinResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.messageID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'toggle_message_pin',
       requests,
     );
     const response = responses[keyserverID];
     return {
       newMessageInfos: response.newMessageInfos,
       threadID: response.threadID,
     };
   };
 
 function useToggleMessagePin(): (
   input: ToggleMessagePinRequest,
 ) => Promise<ToggleMessagePinResult> {
   return useKeyserverCall(toggleMessagePin);
 }
 
 export {
   fetchMessagesBeforeCursorActionTypes,
   useFetchMessagesBeforeCursor,
   fetchMostRecentMessagesActionTypes,
   useFetchMostRecentMessages,
   fetchSingleMostRecentMessagesFromThreadsActionTypes,
   useFetchSingleMostRecentMessagesFromThreads,
   sendTextMessageActionTypes,
   useSendTextMessage,
   createLocalMessageActionType,
   sendMultimediaMessageActionTypes,
   useSendMultimediaMessage,
   useLegacySendMultimediaMessage,
   searchMessagesActionTypes,
   useSearchMessages,
   sendReactionMessageActionTypes,
   useSendReactionMessage,
   saveMessagesActionType,
   processMessagesActionType,
   messageStorePruneActionType,
   sendEditMessageActionTypes,
   useSendEditMessage,
   useFetchPinnedMessages,
   fetchPinnedMessageActionTypes,
   toggleMessagePinActionTypes,
   useToggleMessagePin,
 };
diff --git a/lib/actions/message-report-actions.js b/lib/actions/message-report-actions.js
index bf0c85d8f..6f69afcf3 100644
--- a/lib/actions/message-report-actions.js
+++ b/lib/actions/message-report-actions.js
@@ -1,41 +1,41 @@
 // @flow
 
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
+import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import type {
   MessageReportCreationRequest,
   MessageReportCreationResult,
 } from '../types/message-report-types.js';
-import { useKeyserverCall } from '../utils/keyserver-call.js';
 
 const sendMessageReportActionTypes = Object.freeze({
   started: 'SEND_MESSAGE_REPORT_STARTED',
   success: 'SEND_MESSAGE_REPORT_SUCCESS',
   failed: 'SEND_MESSAGE_REPORT_FAILED',
 });
 const sendMessageReport =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: MessageReportCreationRequest,
   ) => Promise<MessageReportCreationResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.messageID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'create_message_report',
       requests,
     );
     const response = responses[keyserverID];
 
     return { messageInfo: response.messageInfo };
   };
 
 function useSendMessageReport(): (
   input: MessageReportCreationRequest,
 ) => Promise<MessageReportCreationResult> {
   return useKeyserverCall(sendMessageReport);
 }
 
 export { sendMessageReportActionTypes, useSendMessageReport };
diff --git a/lib/actions/thread-actions.js b/lib/actions/thread-actions.js
index 1cf4eaea1..17b659d73 100644
--- a/lib/actions/thread-actions.js
+++ b/lib/actions/thread-actions.js
@@ -1,393 +1,393 @@
 // @flow
 
 import invariant from 'invariant';
 
 import genesis from '../facts/genesis.js';
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
+import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import type {
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   UpdateThreadRequest,
   ClientNewThreadRequest,
   NewThreadResult,
   ClientThreadJoinRequest,
   ThreadJoinPayload,
   ThreadFetchMediaRequest,
   ThreadFetchMediaResult,
   RoleModificationRequest,
   RoleModificationPayload,
   RoleDeletionRequest,
   RoleDeletionPayload,
 } from '../types/thread-types.js';
-import { useKeyserverCall } from '../utils/keyserver-call.js';
 import { values } from '../utils/objects.js';
 
 export type DeleteThreadInput = {
   +threadID: string,
 };
 
 const deleteThreadActionTypes = Object.freeze({
   started: 'DELETE_THREAD_STARTED',
   success: 'DELETE_THREAD_SUCCESS',
   failed: 'DELETE_THREAD_FAILED',
 });
 
 const deleteThreadEndpointOptions = {
   timeout: 60000,
 };
 
 const deleteThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: DeleteThreadInput) => Promise<LeaveThreadPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'delete_thread',
       requests,
       deleteThreadEndpointOptions,
     );
     const response = responses[keyserverID];
     return {
       updatesResult: response.updatesResult,
     };
   };
 
 function useDeleteThread(): (
   input: DeleteThreadInput,
 ) => Promise<LeaveThreadPayload> {
   return useKeyserverCall(deleteThread);
 }
 const changeThreadSettingsActionTypes = Object.freeze({
   started: 'CHANGE_THREAD_SETTINGS_STARTED',
   success: 'CHANGE_THREAD_SETTINGS_SUCCESS',
   failed: 'CHANGE_THREAD_SETTINGS_FAILED',
 });
 
 const changeThreadSettingsEndpointOptions = {
   timeout: 60000,
 };
 
 const changeThreadSettings =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: UpdateThreadRequest) => Promise<ChangeThreadSettingsPayload>) =>
   async input => {
     invariant(
       Object.keys(input.changes).length > 0,
       'No changes provided to changeThreadSettings!',
     );
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'update_thread',
       requests,
       changeThreadSettingsEndpointOptions,
     );
     const response = responses[keyserverID];
     return {
       threadID: input.threadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
     };
   };
 
 function useChangeThreadSettings(): (
   input: UpdateThreadRequest,
 ) => Promise<ChangeThreadSettingsPayload> {
   return useKeyserverCall(changeThreadSettings);
 }
 
 export type RemoveUsersFromThreadInput = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
 };
 
 const removeUsersFromThreadActionTypes = Object.freeze({
   started: 'REMOVE_USERS_FROM_THREAD_STARTED',
   success: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
   failed: 'REMOVE_USERS_FROM_THREAD_FAILED',
 });
 
 const removeMembersFromThreadEndpointOptions = {
   timeout: 60000,
 };
 
 const removeUsersFromThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: RemoveUsersFromThreadInput,
   ) => Promise<ChangeThreadSettingsPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'remove_members',
       requests,
       removeMembersFromThreadEndpointOptions,
     );
     const response = responses[keyserverID];
     return {
       threadID: input.threadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
     };
   };
 
 function useRemoveUsersFromThread(): (
   input: RemoveUsersFromThreadInput,
 ) => Promise<ChangeThreadSettingsPayload> {
   return useKeyserverCall(removeUsersFromThread);
 }
 
 export type ChangeThreadMemberRolesInput = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +newRole: string,
 };
 
 const changeThreadMemberRolesActionTypes = Object.freeze({
   started: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
   success: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
   failed: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
 });
 
 const changeThreadMemberRoleEndpointOptions = {
   timeout: 60000,
 };
 
 const changeThreadMemberRoles =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: ChangeThreadMemberRolesInput,
   ) => Promise<ChangeThreadSettingsPayload>) =>
   async input => {
     const { threadID, memberIDs, newRole } = input;
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = {
       [keyserverID]: {
         threadID,
         memberIDs,
         role: newRole,
       },
     };
 
     const responses = await callKeyserverEndpoint(
       'update_role',
       requests,
       changeThreadMemberRoleEndpointOptions,
     );
     const response = responses[keyserverID];
     return {
       threadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
     };
   };
 
 function useChangeThreadMemberRoles(): (
   input: ChangeThreadMemberRolesInput,
 ) => Promise<ChangeThreadSettingsPayload> {
   return useKeyserverCall(changeThreadMemberRoles);
 }
 
 const newThreadActionTypes = Object.freeze({
   started: 'NEW_THREAD_STARTED',
   success: 'NEW_THREAD_SUCCESS',
   failed: 'NEW_THREAD_FAILED',
 });
 const newThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: ClientNewThreadRequest) => Promise<NewThreadResult>) =>
   async input => {
     const parentThreadID = input.parentThreadID ?? genesis().id;
     const keyserverID = extractKeyserverIDFromID(parentThreadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint('create_thread', requests);
     const response = responses[keyserverID];
 
     return {
       newThreadID: response.newThreadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
       userInfos: response.userInfos,
     };
   };
 
 function useNewThread(): (
   input: ClientNewThreadRequest,
 ) => Promise<NewThreadResult> {
   return useKeyserverCall(newThread);
 }
 
 const joinThreadActionTypes = Object.freeze({
   started: 'JOIN_THREAD_STARTED',
   success: 'JOIN_THREAD_SUCCESS',
   failed: 'JOIN_THREAD_FAILED',
 });
 const joinThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: ClientThreadJoinRequest) => Promise<ThreadJoinPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint('join_thread', requests);
     const response = responses[keyserverID];
     const userInfos = values(response.userInfos);
     return {
       updatesResult: response.updatesResult,
       rawMessageInfos: response.rawMessageInfos,
       truncationStatuses: response.truncationStatuses,
       userInfos,
     };
   };
 
 function useJoinThread(): (
   input: ClientThreadJoinRequest,
 ) => Promise<ThreadJoinPayload> {
   return useKeyserverCall(joinThread);
 }
 
 export type LeaveThreadInput = {
   +threadID: string,
 };
 const leaveThreadActionTypes = Object.freeze({
   started: 'LEAVE_THREAD_STARTED',
   success: 'LEAVE_THREAD_SUCCESS',
   failed: 'LEAVE_THREAD_FAILED',
 });
 const leaveThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: LeaveThreadInput) => Promise<LeaveThreadPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint('leave_thread', requests);
     const response = responses[keyserverID];
     return {
       updatesResult: response.updatesResult,
     };
   };
 
 function useLeaveThread(): (
   input: LeaveThreadInput,
 ) => Promise<LeaveThreadPayload> {
   return useKeyserverCall(leaveThread);
 }
 
 const fetchThreadMedia =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: ThreadFetchMediaRequest) => Promise<ThreadFetchMediaResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'fetch_thread_media',
       requests,
     );
     const response = responses[keyserverID];
     return { media: response.media };
   };
 
 function useFetchThreadMedia(): (
   input: ThreadFetchMediaRequest,
 ) => Promise<ThreadFetchMediaResult> {
   return useKeyserverCall(fetchThreadMedia);
 }
 
 const modifyCommunityRoleActionTypes = Object.freeze({
   started: 'MODIFY_COMMUNITY_ROLE_STARTED',
   success: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
   failed: 'MODIFY_COMMUNITY_ROLE_FAILED',
 });
 const modifyCommunityRole =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: RoleModificationRequest) => Promise<RoleModificationPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.community);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'modify_community_role',
       requests,
     );
     const response = responses[keyserverID];
     return {
       threadInfo: response.threadInfo,
       updatesResult: response.updatesResult,
     };
   };
 
 function useModifyCommunityRole(): (
   input: RoleModificationRequest,
 ) => Promise<RoleModificationPayload> {
   return useKeyserverCall(modifyCommunityRole);
 }
 
 const deleteCommunityRoleActionTypes = Object.freeze({
   started: 'DELETE_COMMUNITY_ROLE_STARTED',
   success: 'DELETE_COMMUNITY_ROLE_SUCCESS',
   failed: 'DELETE_COMMUNITY_ROLE_FAILED',
 });
 const deleteCommunityRole =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: RoleDeletionRequest) => Promise<RoleDeletionPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.community);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'delete_community_role',
       requests,
     );
     const response = responses[keyserverID];
     return {
       threadInfo: response.threadInfo,
       updatesResult: response.updatesResult,
     };
   };
 
 function useDeleteCommunityRole(): (
   input: RoleDeletionRequest,
 ) => Promise<RoleDeletionPayload> {
   return useKeyserverCall(deleteCommunityRole);
 }
 
 export {
   deleteThreadActionTypes,
   useDeleteThread,
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
   removeUsersFromThreadActionTypes,
   useRemoveUsersFromThread,
   changeThreadMemberRolesActionTypes,
   useChangeThreadMemberRoles,
   newThreadActionTypes,
   useNewThread,
   joinThreadActionTypes,
   useJoinThread,
   leaveThreadActionTypes,
   useLeaveThread,
   useFetchThreadMedia,
   modifyCommunityRoleActionTypes,
   useModifyCommunityRole,
   deleteCommunityRoleActionTypes,
   useDeleteCommunityRole,
 };
diff --git a/lib/actions/upload-actions.js b/lib/actions/upload-actions.js
index 420d56a63..fdd5c785c 100644
--- a/lib/actions/upload-actions.js
+++ b/lib/actions/upload-actions.js
@@ -1,282 +1,282 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import uuid from 'uuid';
 
 import blobService from '../facts/blob-service.js';
 import type { CallSingleKeyserverEndpoint } from '../keyserver-conn/call-single-keyserver-endpoint.js';
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
+import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import { type UploadBlob } from '../keyserver-conn/upload-blob.js';
 import { IdentityClientContext } from '../shared/identity-client-context.js';
 import type { AuthMetadata } from '../shared/identity-client-context.js';
 import type { UploadMultimediaResult, Dimensions } from '../types/media-types';
 import { toBase64URL } from '../utils/base64.js';
 import {
   blobServiceUploadHandler,
   type BlobServiceUploadHandler,
 } from '../utils/blob-service-upload.js';
 import { makeBlobServiceEndpointURL } from '../utils/blob-service.js';
 import { getMessageForException } from '../utils/errors.js';
-import { useKeyserverCall } from '../utils/keyserver-call.js';
 import {
   handleHTTPResponseError,
   createDefaultHTTPRequestHeaders,
 } from '../utils/services-utils.js';
 
 export type MultimediaUploadCallbacks = Partial<{
   +onProgress: (percent: number) => void,
   +abortHandler: (abort: () => void) => void,
   +uploadBlob: UploadBlob,
   +blobServiceUploadHandler: BlobServiceUploadHandler,
   +timeout: ?number,
 }>;
 export type MultimediaUploadExtras = $ReadOnly<
   Partial<{
     ...Dimensions,
     +loop: boolean,
     +encryptionKey: string,
     +thumbHash: ?string,
   }>,
 >;
 
 const uploadMultimedia =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((
     multimedia: Object,
     extras: MultimediaUploadExtras,
     callbacks?: MultimediaUploadCallbacks,
   ) => Promise<UploadMultimediaResult>) =>
   async (multimedia, extras, callbacks) => {
     const onProgress = callbacks && callbacks.onProgress;
     const abortHandler = callbacks && callbacks.abortHandler;
     const uploadBlob = callbacks && callbacks.uploadBlob;
 
     const stringExtras: { [string]: string } = {};
     if (extras.height !== null && extras.height !== undefined) {
       stringExtras.height = extras.height.toString();
     }
     if (extras.width !== null && extras.width !== undefined) {
       stringExtras.width = extras.width.toString();
     }
     if (extras.loop) {
       stringExtras.loop = '1';
     }
     if (extras.encryptionKey) {
       stringExtras.encryptionKey = extras.encryptionKey;
     }
     if (extras.thumbHash) {
       stringExtras.thumbHash = extras.thumbHash;
     }
 
     // also pass MIME type if available
     if (multimedia.type && typeof multimedia.type === 'string') {
       stringExtras.mimeType = multimedia.type;
     }
 
     const response = await callSingleKeyserverEndpoint(
       'upload_multimedia',
       {
         ...stringExtras,
         multimedia: [multimedia],
       },
       {
         onProgress,
         abortHandler,
         blobUpload: uploadBlob ? uploadBlob : true,
       },
     );
     const [uploadResult] = response.results;
     return {
       id: uploadResult.id,
       uri: uploadResult.uri,
       dimensions: uploadResult.dimensions,
       mediaType: uploadResult.mediaType,
       loop: uploadResult.loop,
     };
   };
 
 export type DeleteUploadInput = {
   +id: string,
   +keyserverOrThreadID: string,
 };
 
 const updateMultimediaMessageMediaActionType =
   'UPDATE_MULTIMEDIA_MESSAGE_MEDIA';
 
 const deleteUpload =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: DeleteUploadInput) => Promise<void>) =>
   async input => {
     const { id, keyserverOrThreadID } = input;
     const keyserverID = extractKeyserverIDFromID(keyserverOrThreadID);
     const requests = { [keyserverID]: { id } };
     await callKeyserverEndpoint('delete_upload', requests);
   };
 
 function useDeleteUpload(): (input: DeleteUploadInput) => Promise<void> {
   return useKeyserverCall(deleteUpload);
 }
 
 export type BlobServiceUploadFile =
   | { +type: 'file', +file: File }
   | {
       +type: 'uri',
       +uri: string,
       +filename: string,
       +mimeType: string,
     };
 
 export type BlobServiceUploadInput = {
   +blobInput: BlobServiceUploadFile,
   +blobHash: string,
   +encryptionKey: string,
   +dimensions: ?Dimensions,
   +thumbHash?: ?string,
   +loop?: boolean,
 };
 
 export type BlobServiceUploadResult = {
   ...UploadMultimediaResult,
   blobHolder: ?string,
 };
 
 export type BlobServiceUploadAction = (input: {
   +uploadInput: BlobServiceUploadInput,
   +keyserverOrThreadID: string,
   +callbacks?: MultimediaUploadCallbacks,
 }) => Promise<BlobServiceUploadResult>;
 
 const blobServiceUpload =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     authMetadata: AuthMetadata,
   ): BlobServiceUploadAction =>
   async input => {
     const { uploadInput, callbacks, keyserverOrThreadID } = input;
     const { encryptionKey, loop, dimensions, thumbHash, blobInput } =
       uploadInput;
     const blobHolder = uuid.v4();
     const blobHash = toBase64URL(uploadInput.blobHash);
     const defaultHeaders = createDefaultHTTPRequestHeaders(authMetadata);
 
     // 1. Assign new holder for blob with given blobHash
     let blobAlreadyExists: boolean;
     try {
       const assignHolderEndpoint = blobService.httpEndpoints.ASSIGN_HOLDER;
       const assignHolderResponse = await fetch(
         makeBlobServiceEndpointURL(assignHolderEndpoint),
         {
           method: assignHolderEndpoint.method,
           body: JSON.stringify({
             holder: blobHolder,
             blob_hash: blobHash,
           }),
           headers: {
             ...defaultHeaders,
             'content-type': 'application/json',
           },
         },
       );
       handleHTTPResponseError(assignHolderResponse);
       const { data_exists: dataExistsResponse } =
         await assignHolderResponse.json();
       blobAlreadyExists = dataExistsResponse;
     } catch (e) {
       throw new Error(
         `Failed to assign holder: ${
           getMessageForException(e) ?? 'unknown error'
         }`,
       );
     }
 
     // 2. Upload blob contents if blob doesn't exist
     if (!blobAlreadyExists) {
       const uploadEndpoint = blobService.httpEndpoints.UPLOAD_BLOB;
       let blobServiceUploadCallback = blobServiceUploadHandler;
       if (callbacks && callbacks.blobServiceUploadHandler) {
         blobServiceUploadCallback = callbacks.blobServiceUploadHandler;
       }
       try {
         await blobServiceUploadCallback(
           makeBlobServiceEndpointURL(uploadEndpoint),
           uploadEndpoint.method,
           {
             blobHash,
             blobInput,
           },
           authMetadata,
           { ...callbacks },
         );
       } catch (e) {
         throw new Error(
           `Failed to upload blob: ${
             getMessageForException(e) ?? 'unknown error'
           }`,
         );
       }
     }
 
     // 3. Upload metadata to keyserver
     const keyserverID = extractKeyserverIDFromID(keyserverOrThreadID);
     const requests = {
       [keyserverID]: {
         blobHash,
         blobHolder,
         encryptionKey,
         filename:
           blobInput.type === 'file' ? blobInput.file.name : blobInput.filename,
         mimeType:
           blobInput.type === 'file' ? blobInput.file.type : blobInput.mimeType,
         loop,
         thumbHash,
         ...dimensions,
       },
     };
     const responses = await callKeyserverEndpoint(
       'upload_media_metadata',
       requests,
     );
     const response = responses[keyserverID];
 
     return {
       id: response.id,
       uri: response.uri,
       mediaType: response.mediaType,
       dimensions: response.dimensions,
       loop: response.loop,
       blobHolder,
     };
   };
 
 function useBlobServiceUpload(): BlobServiceUploadAction {
   const identityContext = React.useContext(IdentityClientContext);
   invariant(identityContext, 'Identity context should be set');
   const { getAuthMetadata } = identityContext;
 
   const blobUploadAction = React.useCallback(
     (
       callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
     ): BlobServiceUploadAction =>
       async input => {
         const authMetadata = await getAuthMetadata();
         const authenticatedUploadAction = blobServiceUpload(
           callSingleKeyserverEndpoint,
           authMetadata,
         );
         return authenticatedUploadAction(input);
       },
     [getAuthMetadata],
   );
   return useKeyserverCall(blobUploadAction);
 }
 
 export {
   uploadMultimedia,
   useBlobServiceUpload,
   updateMultimediaMessageMediaActionType,
   useDeleteUpload,
 };
diff --git a/lib/actions/user-actions.js b/lib/actions/user-actions.js
index 348bc82e9..a9491ff0e 100644
--- a/lib/actions/user-actions.js
+++ b/lib/actions/user-actions.js
@@ -1,892 +1,892 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import type {
   CallSingleKeyserverEndpoint,
   CallSingleKeyserverEndpointOptions,
 } from '../keyserver-conn/call-single-keyserver-endpoint.js';
 import {
   extractKeyserverIDFromID,
   sortThreadIDsPerKeyserver,
   sortCalendarQueryPerKeyserver,
 } from '../keyserver-conn/keyserver-call-utils.js';
+import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import { usePreRequestUserState } from '../selectors/account-selectors.js';
 import {
   getOneTimeKeyValuesFromBlob,
   getPrekeyValueFromBlob,
 } from '../shared/crypto-utils.js';
 import { IdentityClientContext } from '../shared/identity-client-context.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type {
   LogInInfo,
   LogInResult,
   RegisterResult,
   RegisterInfo,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
   ClaimUsernameResponse,
   LogInRequest,
   KeyserverAuthResult,
   KeyserverAuthInfo,
   KeyserverAuthRequest,
   ClientLogInResponse,
   KeyserverLogOutResult,
   LogOutResult,
 } from '../types/account-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from '../types/avatar-types.js';
 import type { RawEntryInfo, CalendarQuery } from '../types/entry-types.js';
 import type { IdentityAuthResult } from '../types/identity-service-types.js';
 import type {
   RawMessageInfo,
   MessageTruncationStatuses,
 } from '../types/message-types.js';
 import type { GetOlmSessionInitializationDataResponse } from '../types/request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from '../types/search-types.js';
 import type { PreRequestUserState } from '../types/session-types.js';
 import type {
   SubscriptionUpdateRequest,
   SubscriptionUpdateResult,
 } from '../types/subscription-types.js';
 import type { RawThreadInfos } from '../types/thread-types';
 import type {
   CurrentUserInfo,
   UserInfo,
   PasswordUpdate,
   LoggedOutUserInfo,
 } from '../types/user-types.js';
 import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
 import { getConfig } from '../utils/config.js';
-import { useKeyserverCall } from '../utils/keyserver-call.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { usingCommServicesAccessToken } from '../utils/services-utils.js';
 import sleep from '../utils/sleep.js';
 
 const loggedOutUserInfo: LoggedOutUserInfo = {
   anonymous: true,
 };
 
 export type KeyserverLogOutInput = {
   +preRequestUserState: PreRequestUserState,
   +keyserverIDs?: $ReadOnlyArray<string>,
 };
 
 const logOutActionTypes = Object.freeze({
   started: 'LOG_OUT_STARTED',
   success: 'LOG_OUT_SUCCESS',
   failed: 'LOG_OUT_FAILED',
 });
 
 const keyserverLogOut =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: KeyserverLogOutInput) => Promise<KeyserverLogOutResult>) =>
   async input => {
     const { preRequestUserState } = input;
     const keyserverIDs = input.keyserverIDs ?? allKeyserverIDs;
     const requests: { [string]: {} } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {};
     }
 
     let response = null;
     try {
       response = await Promise.race([
         callKeyserverEndpoint('log_out', requests),
         (async () => {
           await sleep(500);
           throw new Error('keyserver log_out took more than 500ms');
         })(),
       ]);
     } catch {}
     const currentUserInfo = response ? loggedOutUserInfo : null;
     return { currentUserInfo, preRequestUserState, keyserverIDs };
   };
 
 function useLogOut(): (
   keyserverIDs?: $ReadOnlyArray<string>,
 ) => Promise<LogOutResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
 
   const preRequestUserState = usePreRequestUserState();
   const callKeyserverLogOut = useKeyserverCall(keyserverLogOut);
 
   const commServicesAccessToken = useSelector(
     state => state.commServicesAccessToken,
   );
 
   return React.useCallback(
     async (keyserverIDs?: $ReadOnlyArray<string>) => {
       const identityPromise = (async () => {
         if (!usingCommServicesAccessToken) {
           return;
         }
         invariant(identityClient, 'Identity client should be set');
         try {
           await Promise.race([
             identityClient.logOut(),
             (async () => {
               await sleep(500);
               throw new Error('identity log_out took more than 500ms');
             })(),
           ]);
         } catch {}
       })();
 
       const [{ keyserverIDs: _, ...result }] = await Promise.all([
         callKeyserverLogOut({
           preRequestUserState,
           keyserverIDs,
         }),
         identityPromise,
       ]);
       return {
         ...result,
         preRequestUserState: {
           ...result.preRequestUserState,
           commServicesAccessToken,
         },
       };
     },
     [
       callKeyserverLogOut,
       commServicesAccessToken,
       identityClient,
       preRequestUserState,
     ],
   );
 }
 
 const claimUsernameActionTypes = Object.freeze({
   started: 'CLAIM_USERNAME_STARTED',
   success: 'CLAIM_USERNAME_SUCCESS',
   failed: 'CLAIM_USERNAME_FAILED',
 });
 const claimUsernameCallSingleKeyserverEndpointOptions = { timeout: 500 };
 const claimUsername =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): (() => Promise<ClaimUsernameResponse>) =>
   async () => {
     const requests = { [authoritativeKeyserverID()]: {} };
     const responses = await callKeyserverEndpoint('claim_username', requests, {
       ...claimUsernameCallSingleKeyserverEndpointOptions,
     });
     const response = responses[authoritativeKeyserverID()];
     return {
       message: response.message,
       signature: response.signature,
     };
   };
 
 function useClaimUsername(): () => Promise<ClaimUsernameResponse> {
   return useKeyserverCall(claimUsername);
 }
 
 const deleteKeyserverAccountActionTypes = Object.freeze({
   started: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
   success: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
   failed: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
 });
 const deleteKeyserverAccount =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: KeyserverLogOutInput) => Promise<KeyserverLogOutResult>) =>
   async input => {
     const { preRequestUserState } = input;
     const keyserverIDs = input.keyserverIDs ?? allKeyserverIDs;
     const requests: { [string]: {} } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {};
     }
 
     await callKeyserverEndpoint('delete_account', requests);
     return {
       currentUserInfo: loggedOutUserInfo,
       preRequestUserState,
       keyserverIDs,
     };
   };
 
 function useDeleteKeyserverAccount(): (
   keyserverIDs?: $ReadOnlyArray<string>,
 ) => Promise<KeyserverLogOutResult> {
   const preRequestUserState = usePreRequestUserState();
   const callKeyserverDeleteAccount = useKeyserverCall(deleteKeyserverAccount);
 
   return React.useCallback(
     (keyserverIDs?: $ReadOnlyArray<string>) =>
       callKeyserverDeleteAccount({ preRequestUserState, keyserverIDs }),
     [callKeyserverDeleteAccount, preRequestUserState],
   );
 }
 
 const deleteAccountActionTypes = Object.freeze({
   started: 'DELETE_ACCOUNT_STARTED',
   success: 'DELETE_ACCOUNT_SUCCESS',
   failed: 'DELETE_ACCOUNT_FAILED',
 });
 
 function useDeleteAccount(): () => Promise<LogOutResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
 
   const preRequestUserState = usePreRequestUserState();
   const callKeyserverDeleteAccount = useKeyserverCall(deleteKeyserverAccount);
 
   const commServicesAccessToken = useSelector(
     state => state.commServicesAccessToken,
   );
 
   return React.useCallback(async () => {
     const identityPromise = (async () => {
       if (!usingCommServicesAccessToken) {
         return undefined;
       }
       if (!identityClient) {
         throw new Error('Identity service client is not initialized');
       }
       if (!identityClient.deleteWalletUser) {
         throw new Error('Delete wallet user method unimplemented');
       }
       return await identityClient.deleteWalletUser();
     })();
     const [keyserverResult] = await Promise.all([
       callKeyserverDeleteAccount({
         preRequestUserState,
       }),
       identityPromise,
     ]);
     const { keyserverIDs: _, ...result } = keyserverResult;
     return {
       ...result,
       preRequestUserState: {
         ...result.preRequestUserState,
         commServicesAccessToken,
       },
     };
   }, [
     callKeyserverDeleteAccount,
     commServicesAccessToken,
     identityClient,
     preRequestUserState,
   ]);
 }
 
 const keyserverRegisterActionTypes = Object.freeze({
   started: 'KEYSERVER_REGISTER_STARTED',
   success: 'KEYSERVER_REGISTER_SUCCESS',
   failed: 'KEYSERVER_REGISTER_FAILED',
 });
 const registerCallSingleKeyserverEndpointOptions = { timeout: 60000 };
 const keyserverRegister =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((
     registerInfo: RegisterInfo,
     options?: CallSingleKeyserverEndpointOptions,
   ) => Promise<RegisterResult>) =>
   async (registerInfo, options) => {
     const deviceTokenUpdateRequest =
       registerInfo.deviceTokenUpdateRequest[authoritativeKeyserverID()];
     const { preRequestUserInfo, ...rest } = registerInfo;
 
     const response = await callSingleKeyserverEndpoint(
       'create_account',
       {
         ...rest,
         deviceTokenUpdateRequest,
         platformDetails: getConfig().platformDetails,
       },
       {
         ...registerCallSingleKeyserverEndpointOptions,
         ...options,
       },
     );
     return {
       currentUserInfo: response.currentUserInfo,
       rawMessageInfos: response.rawMessageInfos,
       threadInfos: response.cookieChange.threadInfos,
       userInfos: response.cookieChange.userInfos,
       calendarQuery: registerInfo.calendarQuery,
     };
   };
 
 export type KeyserverAuthInput = $ReadOnly<{
   ...KeyserverAuthInfo,
   +preRequestUserInfo: ?CurrentUserInfo,
 }>;
 
 const keyserverAuthActionTypes = Object.freeze({
   started: 'KEYSERVER_AUTH_STARTED',
   success: 'KEYSERVER_AUTH_SUCCESS',
   failed: 'KEYSERVER_AUTH_FAILED',
 });
 const keyserverAuthCallSingleKeyserverEndpointOptions = { timeout: 60000 };
 const keyserverAuth =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: KeyserverAuthInput) => Promise<KeyserverAuthResult>) =>
   async keyserverAuthInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
 
     const {
       authActionSource,
       calendarQuery,
       keyserverData,
       deviceTokenUpdateInput,
       preRequestUserInfo,
       ...restLogInInfo
     } = keyserverAuthInfo;
 
     const keyserverIDs = Object.keys(keyserverData);
 
     const watchedIDsPerKeyserver = sortThreadIDsPerKeyserver(watchedIDs);
     const calendarQueryPerKeyserver = sortCalendarQueryPerKeyserver(
       calendarQuery,
       keyserverIDs,
     );
 
     const requests: { [string]: KeyserverAuthRequest } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {
         ...restLogInInfo,
         deviceTokenUpdateRequest: deviceTokenUpdateInput[keyserverID],
         watchedIDs: watchedIDsPerKeyserver[keyserverID] ?? [],
         calendarQuery: calendarQueryPerKeyserver[keyserverID],
         platformDetails: getConfig().platformDetails,
         initialContentEncryptedMessage:
           keyserverData[keyserverID].initialContentEncryptedMessage,
         initialNotificationsEncryptedMessage:
           keyserverData[keyserverID].initialNotificationsEncryptedMessage,
         source: authActionSource,
       };
     }
 
     const responses: { +[string]: ClientLogInResponse } =
       await callKeyserverEndpoint(
         'keyserver_auth',
         requests,
         keyserverAuthCallSingleKeyserverEndpointOptions,
       );
 
     const userInfosArrays = [];
 
     let threadInfos: RawThreadInfos = {};
     const calendarResult: WritableCalendarResult = {
       calendarQuery: keyserverAuthInfo.calendarQuery,
       rawEntryInfos: [],
     };
     const messagesResult: WritableGenericMessagesResult = {
       messageInfos: [],
       truncationStatus: {},
       watchedIDsAtRequestTime: watchedIDs,
       currentAsOf: {},
     };
     let updatesCurrentAsOf: { +[string]: number } = {};
     for (const keyserverID in responses) {
       threadInfos = {
         ...responses[keyserverID].cookieChange.threadInfos,
         ...threadInfos,
       };
       if (responses[keyserverID].rawEntryInfos) {
         calendarResult.rawEntryInfos = calendarResult.rawEntryInfos.concat(
           responses[keyserverID].rawEntryInfos,
         );
       }
       messagesResult.messageInfos = messagesResult.messageInfos.concat(
         responses[keyserverID].rawMessageInfos,
       );
       messagesResult.truncationStatus = {
         ...messagesResult.truncationStatus,
         ...responses[keyserverID].truncationStatuses,
       };
       messagesResult.currentAsOf = {
         ...messagesResult.currentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       updatesCurrentAsOf = {
         ...updatesCurrentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       userInfosArrays.push(responses[keyserverID].userInfos);
       userInfosArrays.push(responses[keyserverID].cookieChange.userInfos);
     }
 
     const userInfos = mergeUserInfos(...userInfosArrays);
 
     return {
       threadInfos,
       currentUserInfo: responses[authoritativeKeyserverID()]?.currentUserInfo,
       calendarResult,
       messagesResult,
       userInfos,
       updatesCurrentAsOf,
       authActionSource: keyserverAuthInfo.authActionSource,
       notAcknowledgedPolicies:
         responses[authoritativeKeyserverID()]?.notAcknowledgedPolicies,
       preRequestUserInfo,
     };
   };
 
 const identityRegisterActionTypes = Object.freeze({
   started: 'IDENTITY_REGISTER_STARTED',
   success: 'IDENTITY_REGISTER_SUCCESS',
   failed: 'IDENTITY_REGISTER_FAILED',
 });
 function useIdentityPasswordRegister(): (
   username: string,
   password: string,
   fid: ?string,
 ) => Promise<IdentityAuthResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   invariant(identityClient, 'Identity client should be set');
   if (!identityClient.registerPasswordUser) {
     throw new Error('Register password user method unimplemented');
   }
   return identityClient.registerPasswordUser;
 }
 function useIdentityWalletRegister(): (
   walletAddress: string,
   siweMessage: string,
   siweSignature: string,
   fid: ?string,
 ) => Promise<IdentityAuthResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   invariant(identityClient, 'Identity client should be set');
   if (!identityClient.registerWalletUser) {
     throw new Error('Register wallet user method unimplemented');
   }
   return identityClient.registerWalletUser;
 }
 
 const identityGenerateNonceActionTypes = Object.freeze({
   started: 'IDENTITY_GENERATE_NONCE_STARTED',
   success: 'IDENTITY_GENERATE_NONCE_SUCCESS',
   failed: 'IDENTITY_GENERATE_NONCE_FAILED',
 });
 function useIdentityGenerateNonce(): () => Promise<string> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   invariant(identityClient, 'Identity client should be set');
   return identityClient.generateNonce;
 }
 
 function mergeUserInfos(
   ...userInfoArrays: Array<$ReadOnlyArray<UserInfo>>
 ): UserInfo[] {
   const merged: { [string]: UserInfo } = {};
   for (const userInfoArray of userInfoArrays) {
     for (const userInfo of userInfoArray) {
       merged[userInfo.id] = userInfo;
     }
   }
   const flattened = [];
   for (const id in merged) {
     flattened.push(merged[id]);
   }
   return flattened;
 }
 
 type WritableGenericMessagesResult = {
   messageInfos: RawMessageInfo[],
   truncationStatus: MessageTruncationStatuses,
   watchedIDsAtRequestTime: string[],
   currentAsOf: { [keyserverID: string]: number },
 };
 type WritableCalendarResult = {
   rawEntryInfos: RawEntryInfo[],
   calendarQuery: CalendarQuery,
 };
 
 const identityLogInActionTypes = Object.freeze({
   started: 'IDENTITY_LOG_IN_STARTED',
   success: 'IDENTITY_LOG_IN_SUCCESS',
   failed: 'IDENTITY_LOG_IN_FAILED',
 });
 function useIdentityPasswordLogIn(): (
   username: string,
   password: string,
 ) => Promise<IdentityAuthResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   const preRequestUserState = useSelector(state => state.currentUserInfo);
 
   return React.useCallback(
     (username, password) => {
       if (!identityClient) {
         throw new Error('Identity service client is not initialized');
       }
       return (async () => {
         const result = await identityClient.logInPasswordUser(
           username,
           password,
         );
         return {
           ...result,
           preRequestUserState,
         };
       })();
     },
     [identityClient, preRequestUserState],
   );
 }
 function useIdentityWalletLogIn(): (
   walletAddress: string,
   siweMessage: string,
   siweSignature: string,
 ) => Promise<IdentityAuthResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   invariant(identityClient, 'Identity client should be set');
   return identityClient.logInWalletUser;
 }
 
 const logInActionTypes = Object.freeze({
   started: 'LOG_IN_STARTED',
   success: 'LOG_IN_SUCCESS',
   failed: 'LOG_IN_FAILED',
 });
 const logInCallSingleKeyserverEndpointOptions = { timeout: 60000 };
 const logIn =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: LogInInfo) => Promise<LogInResult>) =>
   async logInInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
     const {
       authActionSource,
       calendarQuery,
       keyserverIDs: inputKeyserverIDs,
       preRequestUserInfo,
       ...restLogInInfo
     } = logInInfo;
 
     // Eventually the list of keyservers will be fetched from the
     // identity service
     const keyserverIDs = inputKeyserverIDs ?? [authoritativeKeyserverID()];
 
     const watchedIDsPerKeyserver = sortThreadIDsPerKeyserver(watchedIDs);
     const calendarQueryPerKeyserver = sortCalendarQueryPerKeyserver(
       calendarQuery,
       keyserverIDs,
     );
 
     const requests: { [string]: LogInRequest } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {
         ...restLogInInfo,
         deviceTokenUpdateRequest:
           logInInfo.deviceTokenUpdateRequest[keyserverID],
         source: authActionSource,
         watchedIDs: watchedIDsPerKeyserver[keyserverID] ?? [],
         calendarQuery: calendarQueryPerKeyserver[keyserverID],
         platformDetails: getConfig().platformDetails,
       };
     }
 
     const responses: { +[string]: ClientLogInResponse } =
       await callKeyserverEndpoint(
         'log_in',
         requests,
         logInCallSingleKeyserverEndpointOptions,
       );
 
     const userInfosArrays = [];
 
     let threadInfos: RawThreadInfos = {};
     const calendarResult: WritableCalendarResult = {
       calendarQuery: logInInfo.calendarQuery,
       rawEntryInfos: [],
     };
     const messagesResult: WritableGenericMessagesResult = {
       messageInfos: [],
       truncationStatus: {},
       watchedIDsAtRequestTime: watchedIDs,
       currentAsOf: {},
     };
     let updatesCurrentAsOf: { +[string]: number } = {};
     for (const keyserverID in responses) {
       threadInfos = {
         ...responses[keyserverID].cookieChange.threadInfos,
         ...threadInfos,
       };
       if (responses[keyserverID].rawEntryInfos) {
         calendarResult.rawEntryInfos = calendarResult.rawEntryInfos.concat(
           responses[keyserverID].rawEntryInfos,
         );
       }
       messagesResult.messageInfos = messagesResult.messageInfos.concat(
         responses[keyserverID].rawMessageInfos,
       );
       messagesResult.truncationStatus = {
         ...messagesResult.truncationStatus,
         ...responses[keyserverID].truncationStatuses,
       };
       messagesResult.currentAsOf = {
         ...messagesResult.currentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       updatesCurrentAsOf = {
         ...updatesCurrentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       userInfosArrays.push(responses[keyserverID].userInfos);
       userInfosArrays.push(responses[keyserverID].cookieChange.userInfos);
     }
 
     const userInfos = mergeUserInfos(...userInfosArrays);
 
     return {
       threadInfos,
       currentUserInfo: responses[authoritativeKeyserverID()].currentUserInfo,
       calendarResult,
       messagesResult,
       userInfos,
       updatesCurrentAsOf,
       authActionSource: logInInfo.authActionSource,
       notAcknowledgedPolicies:
         responses[authoritativeKeyserverID()].notAcknowledgedPolicies,
       preRequestUserInfo,
     };
   };
 
 function useLogIn(): (input: LogInInfo) => Promise<LogInResult> {
   return useKeyserverCall(logIn);
 }
 
 const changeKeyserverUserPasswordActionTypes = Object.freeze({
   started: 'CHANGE_KEYSERVER_USER_PASSWORD_STARTED',
   success: 'CHANGE_KEYSERVER_USER_PASSWORD_SUCCESS',
   failed: 'CHANGE_KEYSERVER_USER_PASSWORD_FAILED',
 });
 const changeKeyserverUserPassword =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((passwordUpdate: PasswordUpdate) => Promise<void>) =>
   async passwordUpdate => {
     await callSingleKeyserverEndpoint('update_account', passwordUpdate);
   };
 
 const searchUsersActionTypes = Object.freeze({
   started: 'SEARCH_USERS_STARTED',
   success: 'SEARCH_USERS_SUCCESS',
   failed: 'SEARCH_USERS_FAILED',
 });
 const searchUsers =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((usernamePrefix: string) => Promise<UserSearchResult>) =>
   async usernamePrefix => {
     const response = await callSingleKeyserverEndpoint('search_users', {
       prefix: usernamePrefix,
     });
     return {
       userInfos: response.userInfos,
     };
   };
 
 const exactSearchUserActionTypes = Object.freeze({
   started: 'EXACT_SEARCH_USER_STARTED',
   success: 'EXACT_SEARCH_USER_SUCCESS',
   failed: 'EXACT_SEARCH_USER_FAILED',
 });
 const exactSearchUser =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((username: string) => Promise<ExactUserSearchResult>) =>
   async username => {
     const response = await callSingleKeyserverEndpoint('exact_search_user', {
       username,
     });
     return {
       userInfo: response.userInfo,
     };
   };
 
 const updateSubscriptionActionTypes = Object.freeze({
   started: 'UPDATE_SUBSCRIPTION_STARTED',
   success: 'UPDATE_SUBSCRIPTION_SUCCESS',
   failed: 'UPDATE_SUBSCRIPTION_FAILED',
 });
 const updateSubscription =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: SubscriptionUpdateRequest,
   ) => Promise<SubscriptionUpdateResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'update_user_subscription',
       requests,
     );
     const response = responses[keyserverID];
     return {
       threadID: input.threadID,
       subscription: response.threadSubscription,
     };
   };
 
 function useUpdateSubscription(): (
   input: SubscriptionUpdateRequest,
 ) => Promise<SubscriptionUpdateResult> {
   return useKeyserverCall(updateSubscription);
 }
 
 const setUserSettingsActionTypes = Object.freeze({
   started: 'SET_USER_SETTINGS_STARTED',
   success: 'SET_USER_SETTINGS_SUCCESS',
   failed: 'SET_USER_SETTINGS_FAILED',
 });
 
 const setUserSettings =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: UpdateUserSettingsRequest) => Promise<void>) =>
   async input => {
     const requests: { [string]: UpdateUserSettingsRequest } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = input;
     }
     await callKeyserverEndpoint('update_user_settings', requests);
   };
 
 function useSetUserSettings(): (
   input: UpdateUserSettingsRequest,
 ) => Promise<void> {
   return useKeyserverCall(setUserSettings);
 }
 
 const getOlmSessionInitializationDataActionTypes = Object.freeze({
   started: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
   success: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
   failed: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
 });
 
 const getOlmSessionInitializationData =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((
     options?: ?CallSingleKeyserverEndpointOptions,
   ) => Promise<GetOlmSessionInitializationDataResponse>) =>
   async options => {
     const olmInitData = await callSingleKeyserverEndpoint(
       'get_olm_session_initialization_data',
       {},
       options,
     );
     return {
       signedIdentityKeysBlob: olmInitData.signedIdentityKeysBlob,
       contentInitializationInfo: {
         ...olmInitData.contentInitializationInfo,
         oneTimeKey: getOneTimeKeyValuesFromBlob(
           olmInitData.contentInitializationInfo.oneTimeKey,
         )[0],
         prekey: getPrekeyValueFromBlob(
           olmInitData.contentInitializationInfo.prekey,
         ),
       },
       notifInitializationInfo: {
         ...olmInitData.notifInitializationInfo,
         oneTimeKey: getOneTimeKeyValuesFromBlob(
           olmInitData.notifInitializationInfo.oneTimeKey,
         )[0],
         prekey: getPrekeyValueFromBlob(
           olmInitData.notifInitializationInfo.prekey,
         ),
       },
     };
   };
 
 const policyAcknowledgmentActionTypes = Object.freeze({
   started: 'POLICY_ACKNOWLEDGMENT_STARTED',
   success: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
   failed: 'POLICY_ACKNOWLEDGMENT_FAILED',
 });
 const policyAcknowledgment =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((policyRequest: PolicyAcknowledgmentRequest) => Promise<void>) =>
   async policyRequest => {
     await callSingleKeyserverEndpoint('policy_acknowledgment', policyRequest);
   };
 
 const updateUserAvatarActionTypes = Object.freeze({
   started: 'UPDATE_USER_AVATAR_STARTED',
   success: 'UPDATE_USER_AVATAR_SUCCESS',
   failed: 'UPDATE_USER_AVATAR_FAILED',
 });
 const updateUserAvatar =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((
     avatarDBContent: UpdateUserAvatarRequest,
   ) => Promise<UpdateUserAvatarResponse>) =>
   async avatarDBContent => {
     const { updates }: UpdateUserAvatarResponse =
       await callSingleKeyserverEndpoint('update_user_avatar', avatarDBContent);
     return { updates };
   };
 
 const setAccessTokenActionType = 'SET_ACCESS_TOKEN';
 
 export {
   changeKeyserverUserPasswordActionTypes,
   changeKeyserverUserPassword,
   claimUsernameActionTypes,
   useClaimUsername,
   useDeleteKeyserverAccount,
   deleteKeyserverAccountActionTypes,
   getOlmSessionInitializationDataActionTypes,
   getOlmSessionInitializationData,
   mergeUserInfos,
   logIn as logInRawAction,
   identityLogInActionTypes,
   useIdentityPasswordLogIn,
   useIdentityWalletLogIn,
   useLogIn,
   logInActionTypes,
   useLogOut,
   logOutActionTypes,
   keyserverRegister,
   keyserverRegisterActionTypes,
   searchUsers,
   searchUsersActionTypes,
   exactSearchUser,
   exactSearchUserActionTypes,
   useSetUserSettings,
   setUserSettingsActionTypes,
   useUpdateSubscription,
   updateSubscriptionActionTypes,
   policyAcknowledgment,
   policyAcknowledgmentActionTypes,
   updateUserAvatarActionTypes,
   updateUserAvatar,
   setAccessTokenActionType,
   deleteAccountActionTypes,
   useDeleteAccount,
   keyserverAuthActionTypes,
   keyserverAuth as keyserverAuthRawAction,
   identityRegisterActionTypes,
   useIdentityPasswordRegister,
   useIdentityWalletRegister,
   identityGenerateNonceActionTypes,
   useIdentityGenerateNonce,
 };
diff --git a/lib/utils/keyserver-call.js b/lib/keyserver-conn/keyserver-call.js
similarity index 88%
rename from lib/utils/keyserver-call.js
rename to lib/keyserver-conn/keyserver-call.js
index d539b7e73..4e258d97b 100644
--- a/lib/utils/keyserver-call.js
+++ b/lib/keyserver-conn/keyserver-call.js
@@ -1,122 +1,122 @@
 // @flow
 
 import _memoize from 'lodash/memoize.js';
 import * as React from 'react';
 
-import { promiseAll } from './promises.js';
-import { useSelector, useDispatch } from './redux-utils.js';
-import { useCallKeyserverEndpointContext } from '../keyserver-conn/call-keyserver-endpoint-provider.react.js';
-import type { CallSingleKeyserverEndpointOptions } from '../keyserver-conn/call-single-keyserver-endpoint.js';
+import { useCallKeyserverEndpointContext } from './call-keyserver-endpoint-provider.react.js';
+import type { CallSingleKeyserverEndpointOptions } from './call-single-keyserver-endpoint.js';
 import {
   useKeyserverCallInfos,
   type KeyserverInfoPartial,
-} from '../keyserver-conn/keyserver-call-infos.js';
-import type { ActionFunc } from '../keyserver-conn/keyserver-conn-types.js';
+} from './keyserver-call-infos.js';
+import type { ActionFunc } from './keyserver-conn-types.js';
 import type { Endpoint } from '../types/endpoints.js';
 import type { Dispatch } from '../types/redux-types.js';
 import type { CurrentUserInfo } from '../types/user-types.js';
+import { promiseAll } from '../utils/promises.js';
+import { useSelector, useDispatch } from '../utils/redux-utils.js';
 
 export type KeyserverCallParamOverride = Partial<{
   +dispatch: Dispatch,
   +currentUserInfo: ?CurrentUserInfo,
   +keyserverInfos: { +[keyserverID: string]: KeyserverInfoPartial },
 }>;
 
 function useKeyserverCall<Args: mixed, Return>(
   keyserverCall: ActionFunc<Args, Return>,
   paramOverride?: ?KeyserverCallParamOverride,
 ): Args => Promise<Return> {
   const baseDispatch = useDispatch();
   const baseCurrentUserInfo = useSelector(state => state.currentUserInfo);
 
   const keyserverInfos = useSelector(
     state => state.keyserverStore.keyserverInfos,
   );
   const baseCombinedInfo = {
     dispatch: baseDispatch,
     currentUserInfo: baseCurrentUserInfo,
     keyserverInfos,
     ...paramOverride,
   };
 
   const {
     dispatch,
     currentUserInfo,
     keyserverInfos: keyserverInfoPartials,
   } = baseCombinedInfo;
   const keyserverCallInfos = useKeyserverCallInfos(keyserverInfoPartials);
 
   const {
     createCallSingleKeyserverEndpointSelector,
     getBoundKeyserverActionFunc,
   } = useCallKeyserverEndpointContext();
   const getCallSingleKeyserverEndpointSelector: typeof createCallSingleKeyserverEndpointSelector =
     React.useMemo(
       () => _memoize(createCallSingleKeyserverEndpointSelector),
       [createCallSingleKeyserverEndpointSelector],
     );
 
   const cachedNonOverridenBoundKeyserverCall = React.useMemo(
     () => getBoundKeyserverActionFunc(keyserverCall),
     [getBoundKeyserverActionFunc, keyserverCall],
   );
 
   return React.useMemo(() => {
     if (!paramOverride) {
       return cachedNonOverridenBoundKeyserverCall;
     }
 
     const callKeyserverEndpoint = (
       endpoint: Endpoint,
       requests: { +[keyserverID: string]: ?{ +[string]: mixed } },
       options?: ?CallSingleKeyserverEndpointOptions,
     ) => {
       const makeCallToSingleKeyserver = (keyserverID: string) => {
         const {
           cookie,
           urlPrefix,
           sessionID,
           isSocketConnected,
           activeSessionRecovery,
           lastCommunicatedPlatformDetails,
         } = keyserverCallInfos[keyserverID];
 
         const boundCallSingleKeyserverEndpoint =
           getCallSingleKeyserverEndpointSelector(keyserverID)({
             dispatch,
             currentUserInfo,
             cookie,
             urlPrefix,
             sessionID,
             isSocketConnected,
             activeSessionRecovery,
             lastCommunicatedPlatformDetails,
           });
 
         return boundCallSingleKeyserverEndpoint(
           endpoint,
           requests[keyserverID],
           options,
         );
       };
 
       const promises: { [string]: Promise<Object> } = {};
       for (const keyserverID in requests) {
         promises[keyserverID] = makeCallToSingleKeyserver(keyserverID);
       }
       return promiseAll(promises);
     };
     const keyserverIDs = Object.keys(keyserverCallInfos);
     return keyserverCall(callKeyserverEndpoint, keyserverIDs);
   }, [
     paramOverride,
     cachedNonOverridenBoundKeyserverCall,
     dispatch,
     currentUserInfo,
     keyserverCallInfos,
     getCallSingleKeyserverEndpointSelector,
     keyserverCall,
   ]);
 }
 
 export { useKeyserverCall };
diff --git a/web/redux/action-types.js b/web/redux/action-types.js
index 23ed53c65..1d34456de 100644
--- a/web/redux/action-types.js
+++ b/web/redux/action-types.js
@@ -1,182 +1,182 @@
 // @flow
 
 import { extractKeyserverIDFromID } from 'lib/keyserver-conn/keyserver-call-utils.js';
+import { useKeyserverCall } from 'lib/keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from 'lib/keyserver-conn/keyserver-conn-types.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.js';
 import type {
   WebInitialKeyserverInfo,
   ClientWebInitialReduxStateResponse,
 } from 'lib/types/redux-types.js';
-import { useKeyserverCall } from 'lib/utils/keyserver-call.js';
 import type { URLInfo } from 'lib/utils/url-utils.js';
 
 import { authoritativeKeyserverID } from '../authoritative-keyserver.js';
 import type {
   ExcludedData,
   InitialReduxState,
   InitialReduxStateRequest,
 } from '../types/redux-types.js';
 
 export const updateNavInfoActionType = 'UPDATE_NAV_INFO';
 export const updateWindowDimensionsActionType = 'UPDATE_WINDOW_DIMENSIONS';
 export const updateWindowActiveActionType = 'UPDATE_WINDOW_ACTIVE';
 export const setInitialReduxState = 'SET_INITIAL_REDUX_STATE';
 
 const getInitialReduxStateCallSingleKeyserverEndpointOptions = {
   timeout: 300000,
 };
 
 type GetInitialReduxStateInput = {
   +urlInfo: URLInfo,
   +excludedData: ExcludedData,
   +allUpdatesCurrentAsOf: {
     +[keyserverID: string]: number,
   },
 };
 const getInitialReduxState =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: GetInitialReduxStateInput) => Promise<InitialReduxState>) =>
   async input => {
     const requests: { [string]: InitialReduxStateRequest } = {};
     const { urlInfo, excludedData, allUpdatesCurrentAsOf } = input;
     const { thread, inviteSecret, ...rest } = urlInfo;
     const threadKeyserverID = thread ? extractKeyserverIDFromID(thread) : null;
 
     for (const keyserverID of allKeyserverIDs) {
       // As of Nov 2023, the only validation we have for adding a new keyserver
       // is we check if the keyserver URL is valid. This is not a very
       // extensive check, and gives the user the feeling of a false sucesses
       // when they add new keyservers to the keyserver store. ENG-5371 tracks
       // the task for initialzing a proper connection with the newly added
       // keyserver, and at that point we can make the validation checks
       // for adding a new keyserver more extensive. However, for the time being
       // we need to add this check below so that we aren't trying to make calls
       // to nonexistant keyservers that are in our keyserver store.
       if (keyserverID !== authoritativeKeyserverID) {
         continue;
       }
       const clientUpdatesCurrentAsOf = allUpdatesCurrentAsOf[keyserverID];
       const keyserverExcludedData: ExcludedData = clientUpdatesCurrentAsOf
         ? excludedData
         : {};
       if (keyserverID === threadKeyserverID) {
         requests[keyserverID] = {
           urlInfo,
           excludedData: keyserverExcludedData,
           clientUpdatesCurrentAsOf,
         };
       } else {
         requests[keyserverID] = {
           urlInfo: rest,
           excludedData: keyserverExcludedData,
           clientUpdatesCurrentAsOf,
         };
       }
     }
 
     const responses: { +[string]: ClientWebInitialReduxStateResponse } =
       await callKeyserverEndpoint(
         'get_initial_redux_state',
         requests,
         getInitialReduxStateCallSingleKeyserverEndpointOptions,
       );
 
     const { currentUserInfo, userInfos, pushApiPublicKey, navInfo } =
       responses[authoritativeKeyserverID];
 
     const dataLoaded = currentUserInfo && !currentUserInfo.anonymous;
     const actualizedCalendarQuery = {
       startDate: navInfo.startDate,
       endDate: navInfo.endDate,
       filters: defaultCalendarFilters,
     };
 
     const entryStore = {
       daysToEntries: {},
       entryInfos: {},
       lastUserInteractionCalendar: 0,
     };
     const threadStore = {
       threadInfos: {},
     };
     const messageStore = {
       currentAsOf: {},
       local: {},
       messages: {},
       threads: {},
     };
     const inviteLinksStore = {
       links: {},
     };
     let keyserverInfos: { [keyserverID: string]: WebInitialKeyserverInfo } = {};
 
     for (const keyserverID in responses) {
       entryStore.daysToEntries = {
         ...entryStore.daysToEntries,
         ...responses[keyserverID].entryStore.daysToEntries,
       };
       entryStore.entryInfos = {
         ...entryStore.entryInfos,
         ...responses[keyserverID].entryStore.entryInfos,
       };
       entryStore.lastUserInteractionCalendar = Math.max(
         entryStore.lastUserInteractionCalendar,
         responses[keyserverID].entryStore.lastUserInteractionCalendar,
       );
 
       threadStore.threadInfos = {
         ...threadStore.threadInfos,
         ...responses[keyserverID].threadStore.threadInfos,
       };
 
       messageStore.currentAsOf = {
         ...messageStore.currentAsOf,
         ...responses[keyserverID].messageStore.currentAsOf,
       };
       messageStore.messages = {
         ...messageStore.messages,
         ...responses[keyserverID].messageStore.messages,
       };
       messageStore.threads = {
         ...messageStore.threads,
         ...responses[keyserverID].messageStore.threads,
       };
 
       inviteLinksStore.links = {
         ...inviteLinksStore.links,
         ...responses[keyserverID].inviteLinksStore.links,
       };
 
       keyserverInfos = {
         ...keyserverInfos,
         [keyserverID]: responses[keyserverID].keyserverInfo,
       };
     }
 
     return {
       navInfo: {
         ...navInfo,
         inviteSecret,
       },
       currentUserInfo,
       entryStore,
       threadStore,
       userInfos,
       actualizedCalendarQuery,
       messageStore,
       dataLoaded,
       pushApiPublicKey,
       inviteLinksStore,
       keyserverInfos,
     };
   };
 
 function useGetInitialReduxState(): (
   input: GetInitialReduxStateInput,
 ) => Promise<InitialReduxState> {
   return useKeyserverCall(getInitialReduxState);
 }
 
 export { useGetInitialReduxState };