diff --git a/lib/actions/activity-actions.js b/lib/actions/activity-actions.js
index 978ba2a2b..9d91ebde2 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 type {
   ActivityUpdate,
   ActivityUpdateSuccessPayload,
   SetThreadUnreadStatusPayload,
   SetThreadUnreadStatusRequest,
 } from '../types/activity-types.js';
-import { extractKeyserverIDFromID } from '../utils/action-utils.js';
 import type { CallKeyserverEndpoint } from '../utils/keyserver-call';
 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/entry-actions.js b/lib/actions/entry-actions.js
index a52150c9e..d3eb0ca7f 100644
--- a/lib/actions/entry-actions.js
+++ b/lib/actions/entry-actions.js
@@ -1,344 +1,344 @@
 // @flow
 
+import {
+  extractKeyserverIDFromID,
+  sortCalendarQueryPerKeyserver,
+} from '../keyserver-conn/keyserver-call-utils.js';
 import { localIDPrefix } 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 {
-  extractKeyserverIDFromID,
-  sortCalendarQueryPerKeyserver,
-} from '../utils/action-utils.js';
 import { dateFromString } from '../utils/date-utils.js';
 import { useKeyserverCall } from '../utils/keyserver-call.js';
 import type { CallKeyserverEndpoint } 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,
 };
 
 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 calendarQueries = sortCalendarQueryPerKeyserver(
       calendarQuery,
       allKeyserverIDs,
     );
 
     const requests: { [string]: CalendarQuery } = {};
     for (const keyserverID of allKeyserverIDs) {
       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,
     };
   };
 
 function useUpdateCalendarQuery(): (
   input: UpdateCalendarQueryInput,
 ) => Promise<CalendarQueryUpdateResult> {
   return useKeyserverCall(updateCalendarQuery);
 }
 
 const createLocalEntryActionType = 'CREATE_LOCAL_ENTRY';
 function createLocalEntry(
   threadID: string,
   localID: number,
   dateString: string,
   creatorID: string,
 ): RawEntryInfo {
   const date = dateFromString(dateString);
   const newEntryInfo: RawEntryInfo = {
     localID: `${localIDPrefix}${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 913167a50..33c968ea2 100644
--- a/lib/actions/link-actions.js
+++ b/lib/actions/link-actions.js
@@ -1,147 +1,147 @@
 // @flow
 
+import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import type {
   FetchInviteLinksResponse,
   InviteLinkVerificationRequest,
   InviteLinkVerificationResponse,
   CreateOrUpdatePublicLinkRequest,
   InviteLink,
   DisableInviteLinkRequest,
   DisableInviteLinkPayload,
 } from '../types/link-types.js';
-import { extractKeyserverIDFromID } from '../utils/action-utils.js';
 import type { CallServerEndpoint } from '../utils/call-server-endpoint.js';
 import { useKeyserverCall } from '../utils/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../utils/keyserver-call.js';
 
 const verifyInviteLinkActionTypes = Object.freeze({
   started: 'VERIFY_INVITE_LINK_STARTED',
   success: 'VERIFY_INVITE_LINK_SUCCESS',
   failed: 'VERIFY_INVITE_LINK_FAILED',
 });
 const verifyInviteLink =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     request: InviteLinkVerificationRequest,
   ) => Promise<InviteLinkVerificationResponse>) =>
   async request => {
     const response = await callServerEndpoint('verify_invite_link', request);
     if (response.status === 'valid' || response.status === 'already_joined') {
       return {
         status: response.status,
         community: response.community,
       };
     }
     return {
       status: response.status,
     };
   };
 
 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,
   verifyInviteLink,
   fetchPrimaryInviteLinkActionTypes,
   useFetchPrimaryInviteLinks,
   createOrUpdatePublicLinkActionTypes,
   useCreateOrUpdatePublicLink,
   disableInviteLinkLinkActionTypes,
   useDisableInviteLink,
 };
diff --git a/lib/actions/message-actions.js b/lib/actions/message-actions.js
index ac7f0ccfe..5532db0fe 100644
--- a/lib/actions/message-actions.js
+++ b/lib/actions/message-actions.js
@@ -1,522 +1,522 @@
 // @flow
 
 import invariant from 'invariant';
 
+import {
+  extractKeyserverIDFromID,
+  sortThreadIDsPerKeyserver,
+} from '../keyserver-conn/keyserver-call-utils.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 {
-  extractKeyserverIDFromID,
-  sortThreadIDsPerKeyserver,
-} from '../utils/action-utils.js';
 import type { CallServerEndpointResultInfo } from '../utils/call-server-endpoint.js';
 import { useKeyserverCall } from '../utils/keyserver-call.js';
 import type { CallKeyserverEndpoint } 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: CallServerEndpointResultInfo) => {
       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: CallServerEndpointResultInfo) => {
       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: CallServerEndpointResultInfo) => {
       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: CallServerEndpointResultInfo) => {
       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 fa3e0e6f2..39a00ebf0 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 type {
   MessageReportCreationRequest,
   MessageReportCreationResult,
 } from '../types/message-report-types.js';
-import { extractKeyserverIDFromID } from '../utils/action-utils.js';
 import type { CallKeyserverEndpoint } from '../utils/keyserver-call.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 b52862036..52c0adaff 100644
--- a/lib/actions/thread-actions.js
+++ b/lib/actions/thread-actions.js
@@ -1,358 +1,358 @@
 // @flow
 
 import invariant from 'invariant';
 
 import genesis from '../facts/genesis.js';
+import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import type {
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   UpdateThreadRequest,
   ClientNewThreadRequest,
   NewThreadResult,
   ClientThreadJoinRequest,
   ThreadJoinPayload,
   ThreadFetchMediaRequest,
   ThreadFetchMediaResult,
   RoleModificationRequest,
   RoleModificationPayload,
   RoleDeletionRequest,
   RoleDeletionPayload,
 } from '../types/thread-types.js';
-import { extractKeyserverIDFromID } from '../utils/action-utils.js';
 import type { CallServerEndpoint } from '../utils/call-server-endpoint.js';
 import type { CallKeyserverEndpoint } from '../utils/keyserver-call';
 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 deleteThread =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((input: DeleteThreadInput) => Promise<LeaveThreadPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callServerEndpoint('delete_thread', requests);
     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 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);
     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 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);
     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 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);
     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 0a5b80bb5..5bce5cca8 100644
--- a/lib/actions/upload-actions.js
+++ b/lib/actions/upload-actions.js
@@ -1,251 +1,251 @@
 // @flow
 
 import uuid from 'uuid';
 
 import blobService from '../facts/blob-service.js';
+import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import type { UploadMultimediaResult, Dimensions } from '../types/media-types';
-import { extractKeyserverIDFromID } from '../utils/action-utils.js';
 import { toBase64URL } from '../utils/base64.js';
 import {
   blobServiceUploadHandler,
   type BlobServiceUploadHandler,
 } from '../utils/blob-service-upload.js';
 import { makeBlobServiceEndpointURL } from '../utils/blob-service.js';
 import type { CallServerEndpoint } from '../utils/call-server-endpoint.js';
 import { getMessageForException } from '../utils/errors.js';
 import { useKeyserverCall } from '../utils/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../utils/keyserver-call.js';
 import { handleHTTPResponseError } from '../utils/services-utils.js';
 import { type UploadBlob } from '../utils/upload-blob.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 =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     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 callServerEndpoint(
       '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): BlobServiceUploadAction =>
   async input => {
     const { uploadInput, callbacks, keyserverOrThreadID } = input;
     const { encryptionKey, loop, dimensions, thumbHash, blobInput } =
       uploadInput;
     const blobHolder = uuid.v4();
     const blobHash = toBase64URL(uploadInput.blobHash);
 
     // 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: {
             '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,
           },
           { ...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 {
   return useKeyserverCall(blobServiceUpload);
 }
 
 export {
   uploadMultimedia,
   useBlobServiceUpload,
   updateMultimediaMessageMediaActionType,
   useDeleteUpload,
 };
diff --git a/lib/actions/user-actions.js b/lib/actions/user-actions.js
index dddd8549d..4405d3ee1 100644
--- a/lib/actions/user-actions.js
+++ b/lib/actions/user-actions.js
@@ -1,694 +1,694 @@
 // @flow
 
 import * as React from 'react';
 
+import {
+  extractKeyserverIDFromID,
+  sortThreadIDsPerKeyserver,
+  sortCalendarQueryPerKeyserver,
+} from '../keyserver-conn/keyserver-call-utils.js';
 import { preRequestUserStateSelector } from '../selectors/account-selectors.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type {
   LogOutResult,
   LogInInfo,
   LogInResult,
   RegisterResult,
   RegisterInfo,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
   ClaimUsernameResponse,
   LogInResponse,
   LogInRequest,
   KeyserverAuthResult,
   KeyserverAuthInfo,
   KeyserverAuthRequest,
 } 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 { IdentityServiceClient } from '../types/identity-service-types';
 import type {
   RawMessageInfo,
   MessageTruncationStatuses,
 } from '../types/message-types.js';
 import type {
   GetSessionPublicKeysArgs,
   GetOlmSessionInitializationDataResponse,
 } from '../types/request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from '../types/search-types.js';
 import type {
   SessionPublicKeys,
   PreRequestUserState,
 } from '../types/session-types.js';
 import type {
   SubscriptionUpdateRequest,
   SubscriptionUpdateResult,
 } from '../types/subscription-types.js';
 import type { RawThreadInfos } from '../types/thread-types';
 import type {
   UserInfo,
   PasswordUpdate,
   LoggedOutUserInfo,
 } from '../types/user-types.js';
-import {
-  extractKeyserverIDFromID,
-  sortThreadIDsPerKeyserver,
-  sortCalendarQueryPerKeyserver,
-} from '../utils/action-utils.js';
 import type {
   CallServerEndpoint,
   CallServerEndpointOptions,
 } from '../utils/call-server-endpoint.js';
 import { getConfig } from '../utils/config.js';
 import type { CallKeyserverEndpoint } from '../utils/keyserver-call';
 import { useKeyserverCall } from '../utils/keyserver-call.js';
 import { useSelector } from '../utils/redux-utils.js';
 import sleep from '../utils/sleep.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 const loggedOutUserInfo: LoggedOutUserInfo = {
   anonymous: true,
 };
 
 const logOutActionTypes = Object.freeze({
   started: 'LOG_OUT_STARTED',
   success: 'LOG_OUT_SUCCESS',
   failed: 'LOG_OUT_FAILED',
 });
 const logOut =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: PreRequestUserState) => Promise<LogOutResult>) =>
   async preRequestUserState => {
     const requests: { [string]: {} } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = {};
     }
 
     let response = null;
     try {
       response = await Promise.race([
         callKeyserverEndpoint('log_out', requests),
         (async () => {
           await sleep(500);
           throw new Error('log_out took more than 500ms');
         })(),
       ]);
     } catch {}
     const currentUserInfo = response ? loggedOutUserInfo : null;
     return { currentUserInfo, preRequestUserState };
   };
 
 function useLogOut(): () => Promise<LogOutResult> {
   const preRequestUserState = useSelector(preRequestUserStateSelector);
   const callKeyserverLogOut = useKeyserverCall(logOut);
 
   return React.useCallback(
     () => callKeyserverLogOut(preRequestUserState),
     [callKeyserverLogOut, preRequestUserState],
   );
 }
 
 const claimUsernameActionTypes = Object.freeze({
   started: 'CLAIM_USERNAME_STARTED',
   success: 'CLAIM_USERNAME_SUCCESS',
   failed: 'CLAIM_USERNAME_FAILED',
 });
 const claimUsernameCallServerEndpointOptions = { timeout: 500 };
 const claimUsername =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): (() => Promise<ClaimUsernameResponse>) =>
   async () => {
     const requests = { [ashoatKeyserverID]: {} };
     const responses = await callKeyserverEndpoint('claim_username', requests, {
       ...claimUsernameCallServerEndpointOptions,
     });
     const response = responses[ashoatKeyserverID];
     return {
       message: response.message,
       signature: response.signature,
     };
   };
 
 function useClaimUsername(): () => Promise<ClaimUsernameResponse> {
   return useKeyserverCall(claimUsername);
 }
 
 const deleteKeyserverAccountActionTypes = Object.freeze({
   started: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
   success: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
   failed: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
 });
 const deleteKeyserverAccount =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: PreRequestUserState) => Promise<LogOutResult>) =>
   async preRequestUserState => {
     const requests: { [string]: {} } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = {};
     }
 
     await callKeyserverEndpoint('delete_account', requests);
     return { currentUserInfo: loggedOutUserInfo, preRequestUserState };
   };
 
 function useDeleteKeyserverAccount(): (
   input: PreRequestUserState,
 ) => Promise<LogOutResult> {
   return useKeyserverCall(deleteKeyserverAccount);
 }
 
 const deleteIdentityAccountActionTypes = Object.freeze({
   started: 'DELETE_IDENTITY_ACCOUNT_STARTED',
   success: 'DELETE_IDENTITY_ACCOUNT_SUCCESS',
   failed: 'DELETE_IDENTITY_ACCOUNT_FAILED',
 });
 
 function useDeleteIdentityAccount(): (
   client: IdentityServiceClient,
   deviceID: ?string,
 ) => Promise<void> {
   const userID = useSelector(state => state.currentUserInfo?.id);
   const accessToken = useSelector(state => state.commServicesAccessToken);
   const deleteIdentityAccount = React.useCallback(
     async (client: IdentityServiceClient, deviceID: ?string) => {
       if (!userID || !accessToken || !deviceID) {
         throw new Error('missing identity service auth metadata');
       }
       await client.deleteUser(userID, deviceID, accessToken);
     },
     [userID, accessToken],
   );
 
   return deleteIdentityAccount;
 }
 
 const registerActionTypes = Object.freeze({
   started: 'REGISTER_STARTED',
   success: 'REGISTER_SUCCESS',
   failed: 'REGISTER_FAILED',
 });
 const registerCallServerEndpointOptions = { timeout: 60000 };
 const register =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     registerInfo: RegisterInfo,
     options?: CallServerEndpointOptions,
   ) => Promise<RegisterResult>) =>
   async (registerInfo, options) => {
     const deviceTokenUpdateRequest =
       registerInfo.deviceTokenUpdateRequest[ashoatKeyserverID];
 
     const response = await callServerEndpoint(
       'create_account',
       {
         ...registerInfo,
         deviceTokenUpdateRequest,
         platformDetails: getConfig().platformDetails,
       },
       {
         ...registerCallServerEndpointOptions,
         ...options,
       },
     );
     return {
       currentUserInfo: response.currentUserInfo,
       rawMessageInfos: response.rawMessageInfos,
       threadInfos: response.cookieChange.threadInfos,
       userInfos: response.cookieChange.userInfos,
       calendarQuery: registerInfo.calendarQuery,
     };
   };
 
 const keyserverAuthActionTypes = Object.freeze({
   started: 'KEYSERVER_AUTH_STARTED',
   success: 'KEYSERVER_AUTH_SUCCESS',
   failed: 'KEYSERVER_AUTH_FAILED',
 });
 const keyserverAuthCallServerEndpointOptions = { timeout: 60000 };
 const keyserverAuth =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: KeyserverAuthInfo) => Promise<KeyserverAuthResult>) =>
   async keyserverAuthInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
 
     const {
       logInActionSource,
       calendarQuery,
       keyserverData,
       deviceTokenUpdateInput,
       ...restLogInInfo
     } = keyserverAuthInfo;
 
     const keyserverIDs = Object.keys(keyserverData);
 
     const watchedIDsPerKeyserver = sortThreadIDsPerKeyserver(watchedIDs);
     const calendarQueryPerKeyserver = sortCalendarQueryPerKeyserver(
       calendarQuery,
       keyserverIDs,
     );
 
     const requests: { [string]: KeyserverAuthRequest } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {
         ...restLogInInfo,
         deviceTokenUpdateRequest: deviceTokenUpdateInput[keyserverID],
         watchedIDs: watchedIDsPerKeyserver[keyserverID] ?? [],
         calendarQuery: calendarQueryPerKeyserver[keyserverID],
         platformDetails: getConfig().platformDetails,
         initialContentEncryptedMessage:
           keyserverData[keyserverID].initialContentEncryptedMessage,
         initialNotificationsEncryptedMessage:
           keyserverData[keyserverID].initialNotificationsEncryptedMessage,
         source: logInActionSource,
       };
     }
 
     const responses: { +[string]: LogInResponse } = await callKeyserverEndpoint(
       'keyserver_auth',
       requests,
       keyserverAuthCallServerEndpointOptions,
     );
 
     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[ashoatKeyserverID].currentUserInfo,
       calendarResult,
       messagesResult,
       userInfos,
       updatesCurrentAsOf,
       logInActionSource: keyserverAuthInfo.logInActionSource,
       notAcknowledgedPolicies:
         responses[ashoatKeyserverID].notAcknowledgedPolicies,
     };
   };
 
 function useKeyserverAuth(): (
   input: KeyserverAuthInfo,
 ) => Promise<KeyserverAuthResult> {
   return useKeyserverCall(keyserverAuth);
 }
 
 function mergeUserInfos(
   ...userInfoArrays: Array<$ReadOnlyArray<UserInfo>>
 ): UserInfo[] {
   const merged: { [string]: UserInfo } = {};
   for (const userInfoArray of userInfoArrays) {
     for (const userInfo of userInfoArray) {
       merged[userInfo.id] = userInfo;
     }
   }
   const flattened = [];
   for (const id in merged) {
     flattened.push(merged[id]);
   }
   return flattened;
 }
 
 type WritableGenericMessagesResult = {
   messageInfos: RawMessageInfo[],
   truncationStatus: MessageTruncationStatuses,
   watchedIDsAtRequestTime: string[],
   currentAsOf: { [keyserverID: string]: number },
 };
 type WritableCalendarResult = {
   rawEntryInfos: RawEntryInfo[],
   calendarQuery: CalendarQuery,
 };
 
 const tempIdentityLoginActionTypes = Object.freeze({
   started: 'TEMP_IDENTITY_LOG_IN_STARTED',
   success: 'TEMP_IDENTITY_LOG_IN_SUCCESS',
   failed: 'TEMP_IDENTITY_LOG_IN_FAILED',
 });
 
 const logInActionTypes = Object.freeze({
   started: 'LOG_IN_STARTED',
   success: 'LOG_IN_SUCCESS',
   failed: 'LOG_IN_FAILED',
 });
 const logInCallServerEndpointOptions = { timeout: 60000 };
 const logIn =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: LogInInfo) => Promise<LogInResult>) =>
   async logInInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
     const {
       logInActionSource,
       calendarQuery,
       keyserverIDs: inputKeyserverIDs,
       ...restLogInInfo
     } = logInInfo;
 
     // Eventually the list of keyservers will be fetched from the
     // identity service
     const keyserverIDs = inputKeyserverIDs ?? [ashoatKeyserverID];
 
     const watchedIDsPerKeyserver = sortThreadIDsPerKeyserver(watchedIDs);
     const calendarQueryPerKeyserver = sortCalendarQueryPerKeyserver(
       calendarQuery,
       keyserverIDs,
     );
 
     const requests: { [string]: LogInRequest } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {
         ...restLogInInfo,
         deviceTokenUpdateRequest:
           logInInfo.deviceTokenUpdateRequest[keyserverID],
         source: logInActionSource,
         watchedIDs: watchedIDsPerKeyserver[keyserverID] ?? [],
         calendarQuery: calendarQueryPerKeyserver[keyserverID],
         platformDetails: getConfig().platformDetails,
       };
     }
 
     const responses: { +[string]: LogInResponse } = await callKeyserverEndpoint(
       'log_in',
       requests,
       logInCallServerEndpointOptions,
     );
 
     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[ashoatKeyserverID].currentUserInfo,
       calendarResult,
       messagesResult,
       userInfos,
       updatesCurrentAsOf,
       logInActionSource: logInInfo.logInActionSource,
       notAcknowledgedPolicies:
         responses[ashoatKeyserverID].notAcknowledgedPolicies,
     };
   };
 
 function useLogIn(): (input: LogInInfo) => Promise<LogInResult> {
   return useKeyserverCall(logIn);
 }
 
 const changeUserPasswordActionTypes = Object.freeze({
   started: 'CHANGE_USER_PASSWORD_STARTED',
   success: 'CHANGE_USER_PASSWORD_SUCCESS',
   failed: 'CHANGE_USER_PASSWORD_FAILED',
 });
 const changeUserPassword =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((passwordUpdate: PasswordUpdate) => Promise<void>) =>
   async passwordUpdate => {
     await callServerEndpoint('update_account', passwordUpdate);
   };
 
 const searchUsersActionTypes = Object.freeze({
   started: 'SEARCH_USERS_STARTED',
   success: 'SEARCH_USERS_SUCCESS',
   failed: 'SEARCH_USERS_FAILED',
 });
 const searchUsers =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((usernamePrefix: string) => Promise<UserSearchResult>) =>
   async usernamePrefix => {
     const response = await callServerEndpoint('search_users', {
       prefix: usernamePrefix,
     });
     return {
       userInfos: response.userInfos,
     };
   };
 
 const exactSearchUserActionTypes = Object.freeze({
   started: 'EXACT_SEARCH_USER_STARTED',
   success: 'EXACT_SEARCH_USER_SUCCESS',
   failed: 'EXACT_SEARCH_USER_FAILED',
 });
 const exactSearchUser =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((username: string) => Promise<ExactUserSearchResult>) =>
   async username => {
     const response = await callServerEndpoint('exact_search_user', {
       username,
     });
     return {
       userInfo: response.userInfo,
     };
   };
 
 const updateSubscriptionActionTypes = Object.freeze({
   started: 'UPDATE_SUBSCRIPTION_STARTED',
   success: 'UPDATE_SUBSCRIPTION_SUCCESS',
   failed: 'UPDATE_SUBSCRIPTION_FAILED',
 });
 const updateSubscription =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: SubscriptionUpdateRequest,
   ) => Promise<SubscriptionUpdateResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'update_user_subscription',
       requests,
     );
     const response = responses[keyserverID];
     return {
       threadID: input.threadID,
       subscription: response.threadSubscription,
     };
   };
 
 function useUpdateSubscription(): (
   input: SubscriptionUpdateRequest,
 ) => Promise<SubscriptionUpdateResult> {
   return useKeyserverCall(updateSubscription);
 }
 
 const setUserSettingsActionTypes = Object.freeze({
   started: 'SET_USER_SETTINGS_STARTED',
   success: 'SET_USER_SETTINGS_SUCCESS',
   failed: 'SET_USER_SETTINGS_FAILED',
 });
 
 const setUserSettings =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: UpdateUserSettingsRequest) => Promise<void>) =>
   async input => {
     const requests: { [string]: UpdateUserSettingsRequest } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = input;
     }
     await callKeyserverEndpoint('update_user_settings', requests);
   };
 
 function useSetUserSettings(): (
   input: UpdateUserSettingsRequest,
 ) => Promise<void> {
   return useKeyserverCall(setUserSettings);
 }
 
 const getSessionPublicKeys =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((data: GetSessionPublicKeysArgs) => Promise<SessionPublicKeys | null>) =>
   async data => {
     return await callServerEndpoint('get_session_public_keys', data);
   };
 
 const getOlmSessionInitializationDataActionTypes = Object.freeze({
   started: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
   success: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
   failed: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
 });
 
 const getOlmSessionInitializationData =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     options?: ?CallServerEndpointOptions,
   ) => Promise<GetOlmSessionInitializationDataResponse>) =>
   async options => {
     return await callServerEndpoint(
       'get_olm_session_initialization_data',
       {},
       options,
     );
   };
 
 const policyAcknowledgmentActionTypes = Object.freeze({
   started: 'POLICY_ACKNOWLEDGMENT_STARTED',
   success: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
   failed: 'POLICY_ACKNOWLEDGMENT_FAILED',
 });
 const policyAcknowledgment =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((policyRequest: PolicyAcknowledgmentRequest) => Promise<void>) =>
   async policyRequest => {
     await callServerEndpoint('policy_acknowledgment', policyRequest);
   };
 
 const updateUserAvatarActionTypes = Object.freeze({
   started: 'UPDATE_USER_AVATAR_STARTED',
   success: 'UPDATE_USER_AVATAR_SUCCESS',
   failed: 'UPDATE_USER_AVATAR_FAILED',
 });
 const updateUserAvatar =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     avatarDBContent: UpdateUserAvatarRequest,
   ) => Promise<UpdateUserAvatarResponse>) =>
   async avatarDBContent => {
     const { updates }: UpdateUserAvatarResponse = await callServerEndpoint(
       'update_user_avatar',
       avatarDBContent,
     );
     return { updates };
   };
 
 const resetUserStateActionType = 'RESET_USER_STATE';
 
 const setAccessTokenActionType = 'SET_ACCESS_TOKEN';
 
 export {
   changeUserPasswordActionTypes,
   changeUserPassword,
   claimUsernameActionTypes,
   useClaimUsername,
   useDeleteKeyserverAccount,
   deleteKeyserverAccountActionTypes,
   getSessionPublicKeys,
   getOlmSessionInitializationDataActionTypes,
   getOlmSessionInitializationData,
   mergeUserInfos,
   logIn as logInRawAction,
   tempIdentityLoginActionTypes,
   useLogIn,
   logInActionTypes,
   useLogOut,
   logOutActionTypes,
   register,
   registerActionTypes,
   searchUsers,
   searchUsersActionTypes,
   exactSearchUser,
   exactSearchUserActionTypes,
   useSetUserSettings,
   setUserSettingsActionTypes,
   useUpdateSubscription,
   updateSubscriptionActionTypes,
   policyAcknowledgment,
   policyAcknowledgmentActionTypes,
   updateUserAvatarActionTypes,
   updateUserAvatar,
   resetUserStateActionType,
   setAccessTokenActionType,
   deleteIdentityAccountActionTypes,
   useDeleteIdentityAccount,
   keyserverAuthActionTypes,
   useKeyserverAuth,
 };
diff --git a/lib/keyserver-conn/keyserver-call-utils.js b/lib/keyserver-conn/keyserver-call-utils.js
new file mode 100644
index 000000000..6c11e2e6d
--- /dev/null
+++ b/lib/keyserver-conn/keyserver-call-utils.js
@@ -0,0 +1,93 @@
+// @flow
+
+import invariant from 'invariant';
+
+import type { CalendarQuery } from '../types/entry-types.js';
+import type { NotDeletedFilter } from '../types/filter-types.js';
+
+function extractKeyserverIDFromID(id: string): string {
+  return id.split('|')[0];
+}
+
+function sortThreadIDsPerKeyserver(threadIDs: $ReadOnlyArray<string>): {
+  +[keyserverID: string]: $ReadOnlyArray<string>,
+} {
+  const results: { [string]: string[] } = {};
+  for (const threadID of threadIDs) {
+    const keyserverID = extractKeyserverIDFromID(threadID);
+    invariant(keyserverID, 'keyserver data missing from thread id');
+    if (results[keyserverID] === undefined) {
+      results[keyserverID] = [];
+    }
+    results[keyserverID].push(threadID);
+  }
+  return results;
+}
+
+type CalendarThreadFilterWithWritableThreadIDs = {
+  +type: 'threads',
+  +threadIDs: string[],
+};
+type CalendarFilterWithWritableThreadIDs =
+  | NotDeletedFilter
+  | CalendarThreadFilterWithWritableThreadIDs;
+type CalendarQueryWithWritableFilters = {
+  +startDate: string,
+  +endDate: string,
+  +filters: CalendarFilterWithWritableThreadIDs[],
+};
+function sortCalendarQueryPerKeyserver(
+  calendarQuery: CalendarQuery,
+  keyserverIDs: $ReadOnlyArray<string>,
+): {
+  +[keyserverID: string]: CalendarQuery,
+} {
+  const { startDate, endDate, filters } = calendarQuery;
+  const results: { [string]: CalendarQueryWithWritableFilters } = {};
+
+  for (const keyserverID of keyserverIDs) {
+    results[keyserverID] = {
+      startDate,
+      endDate,
+      filters: [],
+    };
+  }
+
+  for (const filter of filters) {
+    if (filter.type === 'not_deleted') {
+      for (const keyserverID in results) {
+        results[keyserverID].filters.push({ type: 'not_deleted' });
+      }
+    } else if (filter.type === 'threads') {
+      for (const threadID of filter.threadIDs) {
+        const keyserverID = extractKeyserverIDFromID(threadID);
+        if (results[keyserverID] === undefined) {
+          continue;
+        }
+        let threadFilter = results[keyserverID].filters.find(
+          flt => flt.type === 'threads',
+        );
+        invariant(
+          !threadFilter || threadFilter.type === 'threads',
+          'should only match CalendarThreadFilter',
+        );
+        if (!threadFilter) {
+          threadFilter = { type: 'threads', threadIDs: [] };
+          results[keyserverID].filters.push(threadFilter);
+        }
+
+        threadFilter.threadIDs.push(threadID);
+      }
+    } else {
+      console.warn('unhandled filter in sortCalendarQueryPerKeyserver');
+    }
+  }
+
+  return results;
+}
+
+export {
+  extractKeyserverIDFromID,
+  sortThreadIDsPerKeyserver,
+  sortCalendarQueryPerKeyserver,
+};
diff --git a/lib/utils/action-utils.test.js b/lib/keyserver-conn/keyserver-call-utils.test.js
similarity index 98%
rename from lib/utils/action-utils.test.js
rename to lib/keyserver-conn/keyserver-call-utils.test.js
index a272006ba..e4a59b7e3 100644
--- a/lib/utils/action-utils.test.js
+++ b/lib/keyserver-conn/keyserver-call-utils.test.js
@@ -1,88 +1,88 @@
 // @flow
 
 import {
   extractKeyserverIDFromID,
   sortCalendarQueryPerKeyserver,
-} from './action-utils.js';
+} from './keyserver-call-utils.js';
 import type { CalendarQuery } from '../types/entry-types';
 
 describe('extractKeyserverIDFromID', () => {
   it('should return <keyserverID> for <keyserverID>|<number>', () => {
     const keyserverID = '404';
     const id = keyserverID + '|1234';
     expect(extractKeyserverIDFromID(id)).toBe(keyserverID);
   });
 
   it('should return <keyserverID> for <keyserverID>', () => {
     const keyserverID = '404';
     expect(extractKeyserverIDFromID(keyserverID)).toBe(keyserverID);
   });
 });
 
 describe('sortCalendarQueryPerKeyserver', () => {
   it('should split the calendar query into multiple queries, one for every \
   keyserver, that have all the properties of the original one, \
   but only the thread ids that the keyserver should get', () => {
     const query: CalendarQuery = {
       startDate: '1463588881886',
       endDate: '1463588889886',
       filters: [
         { type: 'not_deleted' },
         {
           type: 'threads',
           threadIDs: ['256|1', '256|2', '100|100', '100|101'],
         },
       ],
     };
     const queriesPerKeyserver = {
       ['256']: {
         startDate: '1463588881886',
         endDate: '1463588889886',
         filters: [
           { type: 'not_deleted' },
           {
             type: 'threads',
             threadIDs: ['256|1', '256|2'],
           },
         ],
       },
       ['100']: {
         startDate: '1463588881886',
         endDate: '1463588889886',
         filters: [
           { type: 'not_deleted' },
           {
             type: 'threads',
             threadIDs: ['100|100', '100|101'],
           },
         ],
       },
     };
     expect(sortCalendarQueryPerKeyserver(query, ['100', '256'])).toEqual(
       queriesPerKeyserver,
     );
   });
 
   it('should create calendar query for every keyserver in the second argument', () => {
     const query: CalendarQuery = {
       startDate: '1463588881886',
       endDate: '1463588889886',
       filters: [{ type: 'not_deleted' }],
     };
     const queriesPerKeyserver = {
       ['256']: {
         startDate: '1463588881886',
         endDate: '1463588889886',
         filters: [{ type: 'not_deleted' }],
       },
       ['100']: {
         startDate: '1463588881886',
         endDate: '1463588889886',
         filters: [{ type: 'not_deleted' }],
       },
     };
     expect(sortCalendarQueryPerKeyserver(query, ['100', '256'])).toEqual(
       queriesPerKeyserver,
     );
   });
 });
diff --git a/lib/reducers/calendar-filters-reducer.js b/lib/reducers/calendar-filters-reducer.js
index a4f366ec5..b491b5aad 100644
--- a/lib/reducers/calendar-filters-reducer.js
+++ b/lib/reducers/calendar-filters-reducer.js
@@ -1,211 +1,209 @@
 // @flow
 
 import {
   updateCalendarCommunityFilter,
   clearCalendarCommunityFilter,
 } from '../actions/community-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   newThreadActionTypes,
   joinThreadActionTypes,
   leaveThreadActionTypes,
   deleteThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   keyserverAuthActionTypes,
   logOutActionTypes,
   deleteKeyserverAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
   tempIdentityLoginActionTypes,
 } from '../actions/user-actions.js';
+import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import {
   filteredThreadIDs,
   nonThreadCalendarFilters,
   nonExcludeDeletedCalendarFilters,
 } from '../selectors/calendar-filter-selectors.js';
 import { threadInFilterList } from '../shared/thread-utils.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import {
   type CalendarFilter,
   defaultCalendarFilters,
   updateCalendarThreadFilter,
   clearCalendarThreadFilter,
   setCalendarDeletedFilter,
   calendarThreadFilterTypes,
 } from '../types/filter-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type { RawThreadInfos, ThreadStore } from '../types/thread-types.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
-import {
-  extractKeyserverIDFromID,
-  setNewSessionActionType,
-} from '../utils/action-utils.js';
+import { setNewSessionActionType } from '../utils/action-utils.js';
 import { filterThreadIDsBelongingToCommunity } from '../utils/drawer-utils.react.js';
 
 export default function reduceCalendarFilters(
   state: $ReadOnlyArray<CalendarFilter>,
   action: BaseAction,
   threadStore: ThreadStore,
 ): $ReadOnlyArray<CalendarFilter> {
   if (
     action.type === tempIdentityLoginActionTypes.success ||
     action.type === logOutActionTypes.success ||
     action.type === deleteKeyserverAccountActionTypes.success ||
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     return defaultCalendarFilters;
   } else if (action.type === keyserverAuthActionTypes.success) {
     const keyserverIDs = Object.keys(action.payload.updatesCurrentAsOf);
     return removeKeyserverThreadIDsFromFilterList(state, keyserverIDs);
   } else if (action.type === updateCalendarThreadFilter) {
     const nonThreadFilters = nonThreadCalendarFilters(state);
     return [
       ...nonThreadFilters,
       {
         type: calendarThreadFilterTypes.THREAD_LIST,
         threadIDs: action.payload.threadIDs,
       },
     ];
   } else if (action.type === clearCalendarThreadFilter) {
     return nonThreadCalendarFilters(state);
   } else if (action.type === setCalendarDeletedFilter) {
     const otherFilters = nonExcludeDeletedCalendarFilters(state);
     if (action.payload.includeDeleted && otherFilters.length === state.length) {
       // Attempting to remove NOT_DELETED filter, but it doesn't exist
       return state;
     } else if (action.payload.includeDeleted) {
       // Removing NOT_DELETED filter
       return otherFilters;
     } else if (otherFilters.length < state.length) {
       // Attempting to add NOT_DELETED filter, but it already exists
       return state;
     } else {
       // Adding NOT_DELETED filter
       return [...state, { type: calendarThreadFilterTypes.NOT_DELETED }];
     }
   } else if (
     action.type === newThreadActionTypes.success ||
     action.type === joinThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === processUpdatesActionType
   ) {
     return updateFilterListFromUpdateInfos(
       state,
       action.payload.updatesResult.newUpdates,
     );
   } else if (action.type === incrementalStateSyncActionType) {
     return updateFilterListFromUpdateInfos(
       state,
       action.payload.updatesResult.newUpdates,
     );
   } else if (action.type === fullStateSyncActionType) {
     return removeDeletedThreadIDsFromFilterList(
       state,
       action.payload.threadInfos,
     );
   } else if (action.type === updateCalendarCommunityFilter) {
     const nonThreadFilters = nonThreadCalendarFilters(state);
 
     const threadIDs = Array.from(
       filterThreadIDsBelongingToCommunity(
         action.payload,
         threadStore.threadInfos,
       ),
     );
     return [
       ...nonThreadFilters,
       {
         type: calendarThreadFilterTypes.THREAD_LIST,
         threadIDs,
       },
     ];
   } else if (action.type === clearCalendarCommunityFilter) {
     const nonThreadFilters = nonThreadCalendarFilters(state);
     return nonThreadFilters;
   }
   return state;
 }
 
 function updateFilterListFromUpdateInfos(
   state: $ReadOnlyArray<CalendarFilter>,
   updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
 ): $ReadOnlyArray<CalendarFilter> {
   const currentlyFilteredIDs: ?$ReadOnlySet<string> = filteredThreadIDs(state);
   if (!currentlyFilteredIDs) {
     return state;
   }
   const newFilteredThreadIDs = updateInfos.reduce(
     (reducedFilteredThreadIDs, update) => {
       const { reduceCalendarThreadFilters } = updateSpecs[update.type];
       return reduceCalendarThreadFilters
         ? reduceCalendarThreadFilters(reducedFilteredThreadIDs, update)
         : reducedFilteredThreadIDs;
     },
     currentlyFilteredIDs,
   );
   if (currentlyFilteredIDs !== newFilteredThreadIDs) {
     return [
       ...nonThreadCalendarFilters(state),
       { type: 'threads', threadIDs: [...newFilteredThreadIDs] },
     ];
   }
   return state;
 }
 
 function filterThreadIDsInFilterList(
   state: $ReadOnlyArray<CalendarFilter>,
   filterCondition: (threadID: string) => boolean,
 ): $ReadOnlyArray<CalendarFilter> {
   const currentlyFilteredIDs = filteredThreadIDs(state);
   if (!currentlyFilteredIDs) {
     return state;
   }
   const filtered = [...currentlyFilteredIDs].filter(filterCondition);
 
   if (filtered.length < currentlyFilteredIDs.size) {
     return [
       ...nonThreadCalendarFilters(state),
       { type: 'threads', threadIDs: filtered },
     ];
   }
   return state;
 }
 
 function removeDeletedThreadIDsFromFilterList(
   state: $ReadOnlyArray<CalendarFilter>,
   threadInfos: RawThreadInfos,
 ): $ReadOnlyArray<CalendarFilter> {
   const filterCondition = (threadID: string) =>
     threadInFilterList(threadInfos[threadID]);
 
   return filterThreadIDsInFilterList(state, filterCondition);
 }
 
 function removeKeyserverThreadIDsFromFilterList(
   state: $ReadOnlyArray<CalendarFilter>,
   keyserverIDs: $ReadOnlyArray<string>,
 ): $ReadOnlyArray<CalendarFilter> {
   const keyserverIDsSet = new Set<string>(keyserverIDs);
   const filterCondition = (threadID: string) =>
     !keyserverIDsSet.has(extractKeyserverIDFromID(threadID));
 
   return filterThreadIDsInFilterList(state, filterCondition);
 }
 
 export {
   removeDeletedThreadIDsFromFilterList,
   removeKeyserverThreadIDsFromFilterList,
 };
diff --git a/lib/shared/message-utils.js b/lib/shared/message-utils.js
index 9379e92e7..dd647f263 100644
--- a/lib/shared/message-utils.js
+++ b/lib/shared/message-utils.js
@@ -1,749 +1,749 @@
 // @flow
 
 import invariant from 'invariant';
 import _maxBy from 'lodash/fp/maxBy.js';
 import _orderBy from 'lodash/fp/orderBy.js';
 import * as React from 'react';
 
 import { codeBlockRegex, type ParserRules } from './markdown.js';
 import type { CreationSideEffectsFunc } from './messages/message-spec.js';
 import { messageSpecs } from './messages/message-specs.js';
 import { threadIsGroupChat } from './thread-utils.js';
 import { useStringForUser } from '../hooks/ens-cache.js';
+import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import { contentStringForMediaArray } from '../media/media-utils.js';
 import type { ChatMessageInfoItem } from '../selectors/chat-selectors.js';
 import { threadInfoSelector } from '../selectors/thread-selectors.js';
 import { userIDsToRelativeUserInfos } from '../selectors/user-selectors.js';
 import { type PlatformDetails, isWebPlatform } from '../types/device-types.js';
 import type { Media } from '../types/media-types.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import {
   type MessageInfo,
   type RawMessageInfo,
   type RobotextMessageInfo,
   type RawMultimediaMessageInfo,
   type MessageData,
   type MessageTruncationStatus,
   type MultimediaMessageData,
   type MessageStore,
   type ComposableMessageInfo,
   messageTruncationStatus,
   type RawComposableMessageInfo,
   type ThreadMessageInfo,
 } from '../types/message-types.js';
 import type {
   EditMessageInfo,
   RawEditMessageInfo,
 } from '../types/messages/edit.js';
 import type { ImagesMessageData } from '../types/messages/images.js';
 import type { MediaMessageData } from '../types/messages/media.js';
 import type {
   RawReactionMessageInfo,
   ReactionMessageInfo,
 } from '../types/messages/reaction.js';
 import type { RawThreadInfo, ThreadInfo } from '../types/thread-types.js';
 import type { UserInfos } from '../types/user-types.js';
-import { extractKeyserverIDFromID } from '../utils/action-utils.js';
 import {
   type EntityText,
   ET,
   useEntityTextAsString,
 } from '../utils/entity-text.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 const localIDPrefix = 'local';
 
 const defaultMediaMessageOptions = Object.freeze({});
 
 // Prefers localID
 function messageKey(messageInfo: MessageInfo | RawMessageInfo): string {
   if (messageInfo.localID) {
     return messageInfo.localID;
   }
   invariant(messageInfo.id, 'localID should exist if ID does not');
   return messageInfo.id;
 }
 
 // Prefers serverID
 function messageID(messageInfo: MessageInfo | RawMessageInfo): string {
   if (messageInfo.id) {
     return messageInfo.id;
   }
   invariant(messageInfo.localID, 'localID should exist if ID does not');
   return messageInfo.localID;
 }
 
 function robotextForMessageInfo(
   messageInfo: RobotextMessageInfo,
   threadInfo: ?ThreadInfo,
   parentThreadInfo: ?ThreadInfo,
 ): EntityText {
   const messageSpec = messageSpecs[messageInfo.type];
   invariant(
     messageSpec.robotext,
     `we're not aware of messageType ${messageInfo.type}`,
   );
   return messageSpec.robotext(messageInfo, { threadInfo, parentThreadInfo });
 }
 
 function createMessageInfo(
   rawMessageInfo: RawMessageInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   threadInfos: { +[id: string]: ThreadInfo },
 ): ?MessageInfo {
   const creatorInfo = userInfos[rawMessageInfo.creatorID];
   const creator = {
     id: rawMessageInfo.creatorID,
     username: creatorInfo ? creatorInfo.username : 'anonymous',
     isViewer: rawMessageInfo.creatorID === viewerID,
   };
 
   const createRelativeUserInfos = (userIDs: $ReadOnlyArray<string>) =>
     userIDsToRelativeUserInfos(userIDs, viewerID, userInfos);
   const createMessageInfoFromRaw = (rawInfo: RawMessageInfo) =>
     createMessageInfo(rawInfo, viewerID, userInfos, threadInfos);
 
   const messageSpec = messageSpecs[rawMessageInfo.type];
 
   return messageSpec.createMessageInfo(rawMessageInfo, creator, {
     threadInfos,
     createMessageInfoFromRaw,
     createRelativeUserInfos,
   });
 }
 
 type LengthResult = {
   +local: number,
   +realized: number,
 };
 function findMessageIDMaxLengths(
   messageIDs: $ReadOnlyArray<?string>,
 ): LengthResult {
   const result = {
     local: 0,
     realized: 0,
   };
   for (const id of messageIDs) {
     if (!id) {
       continue;
     }
     if (id.startsWith(localIDPrefix)) {
       result.local = Math.max(result.local, id.length - localIDPrefix.length);
     } else {
       result.realized = Math.max(result.realized, id.length);
     }
   }
   return result;
 }
 
 function extendMessageID(id: ?string, lengths: LengthResult): ?string {
   if (!id) {
     return id;
   }
   if (id.startsWith(localIDPrefix)) {
     const zeroPaddedID = id
       .substr(localIDPrefix.length)
       .padStart(lengths.local, '0');
     return `${localIDPrefix}${zeroPaddedID}`;
   }
   return id.padStart(lengths.realized, '0');
 }
 
 function sortMessageInfoList<T: MessageInfo | RawMessageInfo>(
   messageInfos: $ReadOnlyArray<T>,
 ): T[] {
   const lengths = findMessageIDMaxLengths(
     messageInfos.map(message => message?.id),
   );
   return _orderBy([
     'time',
     (message: T) => extendMessageID(message?.id, lengths),
   ])(['desc', 'desc'])(messageInfos);
 }
 
 const sortMessageIDs: (messages: {
   +[id: string]: RawMessageInfo,
 }) => (messageIDs: $ReadOnlyArray<string>) => string[] =
   messages => messageIDs => {
     const lengths = findMessageIDMaxLengths(messageIDs);
     return _orderBy([
       (id: string) => messages[id].time,
       (id: string) => extendMessageID(id, lengths),
     ])(['desc', 'desc'])(messageIDs);
   };
 
 function rawMessageInfoFromMessageData(
   messageData: MessageData,
   id: ?string,
 ): RawMessageInfo {
   const messageSpec = messageSpecs[messageData.type];
   invariant(
     messageSpec.rawMessageInfoFromMessageData,
     `we're not aware of messageType ${messageData.type}`,
   );
   return messageSpec.rawMessageInfoFromMessageData(messageData, id);
 }
 
 function mostRecentMessageTimestamp(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   previousTimestamp: number,
 ): number {
   if (messageInfos.length === 0) {
     return previousTimestamp;
   }
   return _maxBy('time')(messageInfos).time;
 }
 
 function usersInMessageInfos(
   messageInfos: $ReadOnlyArray<MessageInfo | RawMessageInfo>,
 ): string[] {
   const userIDs = new Set<string>();
   for (const messageInfo of messageInfos) {
     if (messageInfo.creatorID) {
       userIDs.add(messageInfo.creatorID);
     } else if (messageInfo.creator) {
       userIDs.add(messageInfo.creator.id);
     }
   }
   return [...userIDs];
 }
 
 function combineTruncationStatuses(
   first: MessageTruncationStatus,
   second: ?MessageTruncationStatus,
 ): MessageTruncationStatus {
   if (
     first === messageTruncationStatus.EXHAUSTIVE ||
     second === messageTruncationStatus.EXHAUSTIVE
   ) {
     return messageTruncationStatus.EXHAUSTIVE;
   } else if (
     first === messageTruncationStatus.UNCHANGED &&
     second !== null &&
     second !== undefined
   ) {
     return second;
   } else {
     return first;
   }
 }
 
 function shimUnsupportedRawMessageInfos(
   rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   platformDetails: ?PlatformDetails,
 ): RawMessageInfo[] {
   if (platformDetails && isWebPlatform(platformDetails.platform)) {
     return [...rawMessageInfos];
   }
   return rawMessageInfos.map(rawMessageInfo => {
     const { shimUnsupportedMessageInfo } = messageSpecs[rawMessageInfo.type];
     if (shimUnsupportedMessageInfo) {
       return shimUnsupportedMessageInfo(rawMessageInfo, platformDetails);
     }
     return rawMessageInfo;
   });
 }
 
 type MediaMessageDataCreationInput = {
   +threadID: string,
   +creatorID: string,
   +media: $ReadOnlyArray<Media>,
   +localID?: ?string,
   +time?: ?number,
   +sidebarCreation?: ?boolean,
   ...
 };
 function createMediaMessageData(
   input: MediaMessageDataCreationInput,
   options: {
     +forceMultimediaMessageType?: boolean,
   } = defaultMediaMessageOptions,
 ): MultimediaMessageData {
   let allMediaArePhotos = true;
   const photoMedia = [];
   for (const singleMedia of input.media) {
     if (singleMedia.type !== 'photo') {
       allMediaArePhotos = false;
       break;
     } else {
       photoMedia.push(singleMedia);
     }
   }
 
   const { localID, threadID, creatorID, sidebarCreation } = input;
   const { forceMultimediaMessageType = false } = options;
   const time = input.time ? input.time : Date.now();
   let messageData;
   if (allMediaArePhotos && !forceMultimediaMessageType) {
     messageData = ({
       type: messageTypes.IMAGES,
       threadID,
       creatorID,
       time,
       media: photoMedia,
     }: ImagesMessageData);
     if (localID) {
       messageData = { ...messageData, localID };
     }
     if (sidebarCreation) {
       messageData = { ...messageData, sidebarCreation };
     }
   } else {
     messageData = ({
       type: messageTypes.MULTIMEDIA,
       threadID,
       creatorID,
       time,
       media: input.media,
     }: MediaMessageData);
     if (localID) {
       messageData = { ...messageData, localID };
     }
     if (sidebarCreation) {
       messageData = { ...messageData, sidebarCreation };
     }
   }
   return messageData;
 }
 
 type MediaMessageInfoCreationInput = {
   ...$Exact<MediaMessageDataCreationInput>,
   +id?: ?string,
 };
 function createMediaMessageInfo(
   input: MediaMessageInfoCreationInput,
   options: {
     +forceMultimediaMessageType?: boolean,
   } = defaultMediaMessageOptions,
 ): RawMultimediaMessageInfo {
   const messageData = createMediaMessageData(input, options);
   const createRawMessageInfo =
     messageSpecs[messageData.type].rawMessageInfoFromMessageData;
   invariant(
     createRawMessageInfo,
     'multimedia message spec should have rawMessageInfoFromMessageData',
   );
   const result = createRawMessageInfo(messageData, input.id);
   invariant(
     result.type === messageTypes.MULTIMEDIA ||
       result.type === messageTypes.IMAGES,
     `media messageSpec returned MessageType ${result.type}`,
   );
   return result;
 }
 
 function stripLocalID(
   rawMessageInfo:
     | RawComposableMessageInfo
     | RawReactionMessageInfo
     | RawEditMessageInfo,
 ) {
   const { localID, ...rest } = rawMessageInfo;
   return rest;
 }
 
 function stripLocalIDs(
   input: $ReadOnlyArray<RawMessageInfo>,
 ): RawMessageInfo[] {
   const output = [];
   for (const rawMessageInfo of input) {
     if (rawMessageInfo.localID) {
       invariant(
         rawMessageInfo.id,
         'serverID should be set if localID is being stripped',
       );
       output.push(stripLocalID(rawMessageInfo));
     } else {
       output.push(rawMessageInfo);
     }
   }
   return output;
 }
 
 // Normally we call trim() to remove whitespace at the beginning and end of each
 // message. However, our Markdown parser supports a "codeBlock" format where the
 // user can indent each line to indicate a code block. If we match the
 // corresponding RegEx, we'll only trim whitespace off the end.
 function trimMessage(message: string): string {
   message = message.replace(/^\n*/, '');
   return codeBlockRegex.exec(message) ? message.trimEnd() : message.trim();
 }
 
 function createMessageQuote(message: string): string {
   // add `>` to each line to include empty lines in the quote
   return message.replace(/^/gm, '> ');
 }
 
 function createMessageReply(message: string): string {
   return createMessageQuote(message) + '\n\n';
 }
 
 function getMostRecentNonLocalMessageID(
   threadID: string,
   messageStore: MessageStore,
 ): ?string {
   const thread = messageStore.threads[threadID];
   return thread?.messageIDs.find(id => !id.startsWith(localIDPrefix));
 }
 
 function getOldestNonLocalMessageID(
   threadID: string,
   messageStore: MessageStore,
 ): ?string {
   const thread = messageStore.threads[threadID];
   if (!thread) {
     return thread;
   }
   const { messageIDs } = thread;
   for (let i = messageIDs.length - 1; i >= 0; i--) {
     const id = messageIDs[i];
     if (!id.startsWith(localIDPrefix)) {
       return id;
     }
   }
   return undefined;
 }
 
 function getMessageTitle(
   messageInfo:
     | ComposableMessageInfo
     | RobotextMessageInfo
     | ReactionMessageInfo
     | EditMessageInfo,
   threadInfo: ThreadInfo,
   parentThreadInfo: ?ThreadInfo,
   markdownRules: ParserRules,
 ): EntityText {
   const { messageTitle } = messageSpecs[messageInfo.type];
   if (messageTitle) {
     return messageTitle({ messageInfo, threadInfo, markdownRules });
   }
 
   invariant(
     messageInfo.type !== messageTypes.TEXT &&
       messageInfo.type !== messageTypes.IMAGES &&
       messageInfo.type !== messageTypes.MULTIMEDIA &&
       messageInfo.type !== messageTypes.REACTION &&
       messageInfo.type !== messageTypes.EDIT_MESSAGE,
     'messageTitle can only be auto-generated for RobotextMessageInfo',
   );
   return robotextForMessageInfo(messageInfo, threadInfo, parentThreadInfo);
 }
 
 function mergeThreadMessageInfos(
   first: ThreadMessageInfo,
   second: ThreadMessageInfo,
   messages: { +[id: string]: RawMessageInfo },
 ): ThreadMessageInfo {
   let firstPointer = 0;
   let secondPointer = 0;
   const mergedMessageIDs = [];
   let firstCandidate = first.messageIDs[firstPointer];
   let secondCandidate = second.messageIDs[secondPointer];
   while (firstCandidate !== undefined || secondCandidate !== undefined) {
     if (firstCandidate === undefined) {
       mergedMessageIDs.push(secondCandidate);
       secondPointer++;
     } else if (secondCandidate === undefined) {
       mergedMessageIDs.push(firstCandidate);
       firstPointer++;
     } else if (firstCandidate === secondCandidate) {
       mergedMessageIDs.push(firstCandidate);
       firstPointer++;
       secondPointer++;
     } else {
       const firstMessage = messages[firstCandidate];
       const secondMessage = messages[secondCandidate];
       invariant(
         firstMessage && secondMessage,
         'message in messageIDs not present in MessageStore',
       );
       if (
         (firstMessage.id &&
           secondMessage.id &&
           firstMessage.id === secondMessage.id) ||
         (firstMessage.localID &&
           secondMessage.localID &&
           firstMessage.localID === secondMessage.localID)
       ) {
         mergedMessageIDs.push(firstCandidate);
         firstPointer++;
         secondPointer++;
       } else if (firstMessage.time < secondMessage.time) {
         mergedMessageIDs.push(secondCandidate);
         secondPointer++;
       } else {
         mergedMessageIDs.push(firstCandidate);
         firstPointer++;
       }
     }
     firstCandidate = first.messageIDs[firstPointer];
     secondCandidate = second.messageIDs[secondPointer];
   }
   return {
     messageIDs: mergedMessageIDs,
     startReached: first.startReached && second.startReached,
   };
 }
 
 type MessagePreviewPart = {
   +text: string,
   // unread has highest contrast, followed by primary, followed by secondary
   +style: 'unread' | 'primary' | 'secondary',
 };
 export type MessagePreviewResult = {
   +message: MessagePreviewPart,
   +username: ?MessagePreviewPart,
 };
 function useMessagePreview(
   originalMessageInfo: ?MessageInfo,
   threadInfo: ThreadInfo,
   markdownRules: ParserRules,
 ): ?MessagePreviewResult {
   let messageInfo;
   if (
     originalMessageInfo &&
     originalMessageInfo.type === messageTypes.SIDEBAR_SOURCE
   ) {
     messageInfo = originalMessageInfo.sourceMessage;
   } else {
     messageInfo = originalMessageInfo;
   }
 
   const { parentThreadID } = threadInfo;
   const parentThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
 
   const hasUsername =
     threadIsGroupChat(threadInfo) ||
     threadInfo.name !== '' ||
     messageInfo?.creator.isViewer;
   const shouldDisplayUser =
     messageInfo?.type === messageTypes.TEXT && hasUsername;
 
   const stringForUser = useStringForUser(
     shouldDisplayUser ? messageInfo?.creator : null,
   );
 
   const { unread } = threadInfo.currentUser;
   const username = React.useMemo(() => {
     if (!shouldDisplayUser) {
       return null;
     }
     invariant(
       stringForUser,
       'useStringForUser should only return falsey if pass null or undefined',
     );
     return {
       text: stringForUser,
       style: unread ? 'unread' : 'secondary',
     };
   }, [shouldDisplayUser, stringForUser, unread]);
 
   const messageTitleEntityText = React.useMemo(() => {
     if (!messageInfo) {
       return messageInfo;
     }
     return getMessageTitle(
       messageInfo,
       threadInfo,
       parentThreadInfo,
       markdownRules,
     );
   }, [messageInfo, threadInfo, parentThreadInfo, markdownRules]);
 
   const threadID = threadInfo.id;
   const entityTextToStringParams = React.useMemo(
     () => ({
       threadID,
     }),
     [threadID],
   );
   const messageTitle = useEntityTextAsString(
     messageTitleEntityText,
     entityTextToStringParams,
   );
 
   const isTextMessage = messageInfo?.type === messageTypes.TEXT;
   const message = React.useMemo(() => {
     if (messageTitle === null || messageTitle === undefined) {
       return messageTitle;
     }
 
     let style;
     if (unread) {
       style = 'unread';
     } else if (isTextMessage) {
       style = 'primary';
     } else {
       style = 'secondary';
     }
 
     return { text: messageTitle, style };
   }, [messageTitle, unread, isTextMessage]);
 
   return React.useMemo(() => {
     if (!message) {
       return message;
     }
     return { message, username };
   }, [message, username]);
 }
 
 function useMessageCreationSideEffectsFunc<Info: RawMessageInfo>(
   messageType: $PropertyType<Info, 'type'>,
 ): CreationSideEffectsFunc<Info> {
   const messageSpec = messageSpecs[messageType];
   invariant(messageSpec, `we're not aware of messageType ${messageType}`);
   invariant(
     messageSpec.useCreationSideEffectsFunc,
     `no useCreationSideEffectsFunc in message spec for ${messageType}`,
   );
   return messageSpec.useCreationSideEffectsFunc();
 }
 
 function getPinnedContentFromMessage(targetMessage: RawMessageInfo): string {
   let pinnedContent;
   if (
     targetMessage.type === messageTypes.IMAGES ||
     targetMessage.type === messageTypes.MULTIMEDIA
   ) {
     pinnedContent = contentStringForMediaArray(targetMessage.media);
   } else {
     pinnedContent = 'a message';
   }
 
   return pinnedContent;
 }
 
 function modifyItemForResultScreen(
   item: ChatMessageInfoItem,
 ): ChatMessageInfoItem {
   if (item.messageInfoType === 'composable') {
     return {
       ...item,
       startsConversation: false,
       startsCluster: true,
       endsCluster: true,
       messageInfo: {
         ...item.messageInfo,
         creator: {
           ...item.messageInfo.creator,
           isViewer: false,
         },
       },
     };
   }
   return item;
 }
 
 function constructChangeRoleEntityText(
   affectedUsers: EntityText | string,
   roleName: ?string,
 ): EntityText {
   if (!roleName) {
     return ET`assigned ${affectedUsers} a new role`;
   }
 
   return ET`assigned ${affectedUsers} the "${roleName}" role`;
 }
 
 function useNextLocalID(): string {
   const nextLocalID = useSelector(state => state.nextLocalID);
   return `${localIDPrefix}${nextLocalID}`;
 }
 
 function isInvalidSidebarSource(
   message: RawMessageInfo | MessageInfo,
 ): boolean %checks {
   return (
     (message.type === messageTypes.REACTION ||
       message.type === messageTypes.EDIT_MESSAGE ||
       message.type === messageTypes.SIDEBAR_SOURCE ||
       message.type === messageTypes.TOGGLE_PIN) &&
     !messageSpecs[message.type].canBeSidebarSource
   );
 }
 
 // Prefer checking isInvalidPinSourceForThread below. This function doesn't
 // check whether the user is attempting to pin a SIDEBAR_SOURCE in the context
 // of its parent thread, so it's not suitable for permission checks. We only
 // use it in the message-fetchers.js code where we don't have access to the
 // RawThreadInfo and don't need to do permission checks.
 function isInvalidPinSource(
   messageInfo: RawMessageInfo | MessageInfo,
 ): boolean {
   return !messageSpecs[messageInfo.type].canBePinned;
 }
 
 function isInvalidPinSourceForThread(
   messageInfo: RawMessageInfo | MessageInfo,
   threadInfo: RawThreadInfo | ThreadInfo,
 ): boolean {
   const isValidPinSource = !isInvalidPinSource(messageInfo);
   const isFirstMessageInSidebar = threadInfo.sourceMessageID === messageInfo.id;
   return !isValidPinSource || isFirstMessageInSidebar;
 }
 
 function isUnableToBeRenderedIndependently(
   message: RawMessageInfo | MessageInfo,
 ): boolean {
   return messageSpecs[message.type].canBeRenderedIndependently === false;
 }
 
 function findNewestMessageTimePerKeyserver(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
 ): { [keyserverID: string]: number } {
   const timePerKeyserver: { [keyserverID: string]: number } = {};
 
   for (const messageInfo of messageInfos) {
     const keyserverID = extractKeyserverIDFromID(messageInfo.threadID);
 
     if (
       !timePerKeyserver[keyserverID] ||
       timePerKeyserver[keyserverID] < messageInfo.time
     ) {
       timePerKeyserver[keyserverID] = messageInfo.time;
     }
   }
 
   return timePerKeyserver;
 }
 
 export {
   localIDPrefix,
   messageKey,
   messageID,
   robotextForMessageInfo,
   createMessageInfo,
   sortMessageInfoList,
   sortMessageIDs,
   rawMessageInfoFromMessageData,
   mostRecentMessageTimestamp,
   usersInMessageInfos,
   combineTruncationStatuses,
   shimUnsupportedRawMessageInfos,
   createMediaMessageData,
   createMediaMessageInfo,
   stripLocalIDs,
   trimMessage,
   createMessageQuote,
   createMessageReply,
   getMostRecentNonLocalMessageID,
   getOldestNonLocalMessageID,
   getMessageTitle,
   mergeThreadMessageInfos,
   useMessagePreview,
   useMessageCreationSideEffectsFunc,
   getPinnedContentFromMessage,
   modifyItemForResultScreen,
   constructChangeRoleEntityText,
   useNextLocalID,
   isInvalidSidebarSource,
   isInvalidPinSource,
   isInvalidPinSourceForThread,
   isUnableToBeRenderedIndependently,
   findNewestMessageTimePerKeyserver,
 };
diff --git a/lib/utils/action-utils.js b/lib/utils/action-utils.js
index 48a8c2083..ba9c15f0d 100644
--- a/lib/utils/action-utils.js
+++ b/lib/utils/action-utils.js
@@ -1,632 +1,546 @@
 // @flow
 
 import invariant from 'invariant';
 import _memoize from 'lodash/memoize.js';
 import * as React from 'react';
 import { createSelector } from 'reselect';
 
 import callServerEndpoint from './call-server-endpoint.js';
 import type {
   CallServerEndpoint,
   CallServerEndpointOptions,
 } from './call-server-endpoint.js';
 import { getConfig } from './config.js';
 import { promiseAll } from './promises.js';
 import { useSelector, useDispatch } from './redux-utils.js';
 import { usingCommServicesAccessToken } from './services-utils.js';
 import { ashoatKeyserverID } from './validation-utils.js';
 import { serverCallStateSelector } from '../selectors/server-calls.js';
 import {
   logInActionSources,
   type LogInActionSource,
   type LogInStartingPayload,
   type LogInResult,
 } from '../types/account-types.js';
 import type { PlatformDetails } from '../types/device-types.js';
 import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js';
-import type { CalendarQuery } from '../types/entry-types.js';
-import type { NotDeletedFilter } from '../types/filter-types.js';
 import type { LoadingOptions, LoadingInfo } from '../types/loading-types.js';
 import type {
   ActionPayload,
   Dispatch,
   PromisedAction,
   BaseAction,
 } from '../types/redux-types.js';
 import type {
   ClientSessionChange,
   PreRequestUserState,
 } from '../types/session-types.js';
 import type { CurrentUserInfo } from '../types/user-types.js';
 
-function extractKeyserverIDFromID(id: string): string {
-  return id.split('|')[0];
-}
-
 let nextPromiseIndex = 0;
 
 export type ActionTypes<
   STARTED_ACTION_TYPE: string,
   SUCCESS_ACTION_TYPE: string,
   FAILED_ACTION_TYPE: string,
 > = {
   started: STARTED_ACTION_TYPE,
   success: SUCCESS_ACTION_TYPE,
   failed: FAILED_ACTION_TYPE,
 };
 
 function wrapActionPromise<
   STARTED_ACTION_TYPE: string,
   STARTED_PAYLOAD: ActionPayload,
   SUCCESS_ACTION_TYPE: string,
   SUCCESS_PAYLOAD: ActionPayload,
   FAILED_ACTION_TYPE: string,
 >(
   actionTypes: ActionTypes<
     STARTED_ACTION_TYPE,
     SUCCESS_ACTION_TYPE,
     FAILED_ACTION_TYPE,
   >,
   promise: Promise<SUCCESS_PAYLOAD>,
   loadingOptions: ?LoadingOptions,
   startingPayload: ?STARTED_PAYLOAD,
 ): PromisedAction {
   const loadingInfo: LoadingInfo = {
     fetchIndex: nextPromiseIndex++,
     trackMultipleRequests: !!loadingOptions?.trackMultipleRequests,
     customKeyName: loadingOptions?.customKeyName || null,
   };
   return async (dispatch: Dispatch): Promise<void> => {
     const startAction = startingPayload
       ? {
           type: (actionTypes.started: STARTED_ACTION_TYPE),
           loadingInfo,
           payload: (startingPayload: STARTED_PAYLOAD),
         }
       : {
           type: (actionTypes.started: STARTED_ACTION_TYPE),
           loadingInfo,
         };
     dispatch(startAction);
     try {
       const result = await promise;
       dispatch({
         type: (actionTypes.success: SUCCESS_ACTION_TYPE),
         payload: (result: SUCCESS_PAYLOAD),
         loadingInfo,
       });
     } catch (e) {
       console.log(e);
       dispatch({
         type: (actionTypes.failed: FAILED_ACTION_TYPE),
         error: true,
         payload: (e: Error),
         loadingInfo,
       });
     }
   };
 }
 
 export type DispatchActionPromise = <
   STARTED: BaseAction,
   SUCCESS: BaseAction,
   FAILED: BaseAction,
 >(
   actionTypes: ActionTypes<
     $PropertyType<STARTED, 'type'>,
     $PropertyType<SUCCESS, 'type'>,
     $PropertyType<FAILED, 'type'>,
   >,
   promise: Promise<$PropertyType<SUCCESS, 'payload'>>,
   loadingOptions?: LoadingOptions,
   startingPayload?: $PropertyType<STARTED, 'payload'>,
 ) => Promise<void>;
 
 function useDispatchActionPromise(): DispatchActionPromise {
   const dispatch = useDispatch();
   return React.useMemo(() => createDispatchActionPromise(dispatch), [dispatch]);
 }
 
 function createDispatchActionPromise(dispatch: Dispatch) {
   const dispatchActionPromise = function <
     STARTED: BaseAction,
     SUCCESS: BaseAction,
     FAILED: BaseAction,
   >(
     actionTypes: ActionTypes<
       $PropertyType<STARTED, 'type'>,
       $PropertyType<SUCCESS, 'type'>,
       $PropertyType<FAILED, 'type'>,
     >,
     promise: Promise<$PropertyType<SUCCESS, 'payload'>>,
     loadingOptions?: LoadingOptions,
     startingPayload?: $PropertyType<STARTED, 'payload'>,
   ): Promise<void> {
     return dispatch(
       wrapActionPromise(actionTypes, promise, loadingOptions, startingPayload),
     );
   };
   return dispatchActionPromise;
 }
 
 export type DispatchFunctions = {
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
 };
 
 let currentlyWaitingForNewCookie = false;
 let serverEndpointCallsWaitingForNewCookie: ((
   callServerEndpoint: ?CallServerEndpoint,
 ) => void)[] = [];
 
 export type DispatchRecoveryAttempt = (
   actionTypes: ActionTypes<'LOG_IN_STARTED', 'LOG_IN_SUCCESS', 'LOG_IN_FAILED'>,
   promise: Promise<LogInResult>,
   startingPayload: LogInStartingPayload,
 ) => Promise<boolean>;
 
 const setNewSessionActionType = 'SET_NEW_SESSION';
 function setNewSession(
   dispatch: Dispatch,
   sessionChange: ClientSessionChange,
   preRequestUserState: ?PreRequestUserState,
   error: ?string,
   logInActionSource: ?LogInActionSource,
   keyserverID: string,
 ) {
   dispatch({
     type: setNewSessionActionType,
     payload: {
       sessionChange,
       preRequestUserState,
       error,
       logInActionSource,
       keyserverID,
     },
   });
 }
 
 // This function is a shortcut that tells us whether it's worth even trying to
 // call resolveKeyserverSessionInvalidation
 function canResolveKeyserverSessionInvalidation() {
   if (usingCommServicesAccessToken) {
     // We can always try to resolve a keyserver session invalidation
     // automatically using the Olm auth responder
     return true;
   }
   const { resolveKeyserverSessionInvalidationUsingNativeCredentials } =
     getConfig();
   // If we can't use the Olm auth responder, then we can only resolve a
   // keyserver session invalidation on native, where we have access to the
   // user's native credentials. Note that we can't do this for ETH users, but we
   // don't know if the user is an ETH user from this function
   return !!resolveKeyserverSessionInvalidationUsingNativeCredentials;
 }
 
 // This function attempts to resolve an invalid keyserver session. A session can
 // become invalid when a keyserver invalidates it, or due to inconsistent client
 // state. If the client is usingCommServicesAccessToken, then the invalidation
 // recovery will try to go through the keyserver's Olm auth responder.
 // Otherwise, it will attempt to use the user's credentials to log in with the
 // legacy auth responder, which won't work on web and won't work for ETH users.
 async function resolveKeyserverSessionInvalidation(
   dispatch: Dispatch,
   cookie: ?string,
   urlPrefix: string,
   logInActionSource: LogInActionSource,
   keyserverID: string,
   getInitialNotificationsEncryptedMessage?: () => Promise<string>,
 ): Promise<?ClientSessionChange> {
   const { resolveKeyserverSessionInvalidationUsingNativeCredentials } =
     getConfig();
   if (!resolveKeyserverSessionInvalidationUsingNativeCredentials) {
     return null;
   }
   let newSessionChange = null;
   let callServerEndpointCallback = null;
   const boundCallServerEndpoint = async (
     endpoint: Endpoint,
     data: { +[key: string]: mixed },
     options?: ?CallServerEndpointOptions,
   ) => {
     const innerBoundSetNewSession = (
       sessionChange: ClientSessionChange,
       error: ?string,
     ) => {
       newSessionChange = sessionChange;
       setNewSession(
         dispatch,
         sessionChange,
         null,
         error,
         logInActionSource,
         keyserverID,
       );
     };
     try {
       const result = await callServerEndpoint(
         cookie,
         innerBoundSetNewSession,
         () => new Promise(r => r(null)),
         () => new Promise(r => r(null)),
         urlPrefix,
         null,
         false,
         null,
         null,
         endpoint,
         data,
         dispatch,
         options,
         false,
         keyserverID,
       );
       if (callServerEndpointCallback) {
         callServerEndpointCallback(!!newSessionChange);
       }
       return result;
     } catch (e) {
       if (callServerEndpointCallback) {
         callServerEndpointCallback(!!newSessionChange);
       }
       throw e;
     }
   };
 
   const boundCallKeyserverEndpoint = (
     endpoint: Endpoint,
     requests: { +[keyserverID: string]: ?{ +[string]: mixed } },
     options?: ?CallServerEndpointOptions,
   ) => {
     if (requests[keyserverID]) {
       const promises = {
         [keyserverID]: boundCallServerEndpoint(
           endpoint,
           requests[keyserverID],
           options,
         ),
       };
       return promiseAll(promises);
     }
     return Promise.resolve({});
   };
 
   const dispatchRecoveryAttempt = (
     actionTypes: ActionTypes<
       'LOG_IN_STARTED',
       'LOG_IN_SUCCESS',
       'LOG_IN_FAILED',
     >,
     promise: Promise<LogInResult>,
     inputStartingPayload: LogInStartingPayload,
   ) => {
     const startingPayload = { ...inputStartingPayload, logInActionSource };
     void dispatch(
       wrapActionPromise(actionTypes, promise, null, startingPayload),
     );
     return new Promise<boolean>(r => (callServerEndpointCallback = r));
   };
   await resolveKeyserverSessionInvalidationUsingNativeCredentials(
     boundCallServerEndpoint,
     boundCallKeyserverEndpoint,
     dispatchRecoveryAttempt,
     logInActionSource,
     keyserverID,
     getInitialNotificationsEncryptedMessage,
   );
   return newSessionChange;
 }
 
 // Third param is optional and gets called with newCookie if we get a new cookie
 // Necessary to propagate cookie in cookieInvalidationRecovery below
 function bindCookieAndUtilsIntoCallServerEndpoint(
   params: BindServerCallsParams,
 ): CallServerEndpoint {
   const {
     dispatch,
     cookie,
     urlPrefix,
     sessionID,
     currentUserInfo,
     isSocketConnected,
     lastCommunicatedPlatformDetails,
     keyserverID,
   } = params;
   const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true);
   const boundSetNewSession = (
     sessionChange: ClientSessionChange,
     error: ?string,
   ) =>
     setNewSession(
       dispatch,
       sessionChange,
       {
         currentUserInfo,
         cookiesAndSessions: { [keyserverID]: { cookie, sessionID } },
       },
       error,
       undefined,
       keyserverID,
     );
   const canResolveInvalidation = canResolveKeyserverSessionInvalidation();
   // This function gets called before callServerEndpoint sends a request,
   // to make sure that we're not in the middle of trying to recover
   // an invalidated cookie
   const waitIfCookieInvalidated = () => {
     if (!canResolveInvalidation) {
       // If there is no way to resolve the session invalidation,
       // just let the caller callServerEndpoint instance continue
       return Promise.resolve(null);
     }
     if (!currentlyWaitingForNewCookie) {
       // Our cookie seems to be valid
       return Promise.resolve(null);
     }
     // Wait to run until we get our new cookie
     return new Promise<?CallServerEndpoint>(r =>
       serverEndpointCallsWaitingForNewCookie.push(r),
     );
   };
   // This function is a helper for the next function defined below
   const attemptToResolveInvalidation = async (
     sessionChange: ClientSessionChange,
   ) => {
     const newAnonymousCookie = sessionChange.cookie;
     const newSessionChange = await resolveKeyserverSessionInvalidation(
       dispatch,
       newAnonymousCookie,
       urlPrefix,
       logInActionSources.cookieInvalidationResolutionAttempt,
       keyserverID,
     );
 
     currentlyWaitingForNewCookie = false;
     const currentWaitingCalls = serverEndpointCallsWaitingForNewCookie;
     serverEndpointCallsWaitingForNewCookie = [];
 
     const newCallServerEndpoint = newSessionChange
       ? bindCookieAndUtilsIntoCallServerEndpoint({
           ...params,
           cookie: newSessionChange.cookie,
           sessionID: newSessionChange.sessionID,
           currentUserInfo: newSessionChange.currentUserInfo,
         })
       : null;
     for (const func of currentWaitingCalls) {
       func(newCallServerEndpoint);
     }
     return newCallServerEndpoint;
   };
   // If this function is called, callServerEndpoint got a response invalidating
   // its cookie, and is wondering if it should just like... give up?
   // Or if there's a chance at redemption
   const cookieInvalidationRecovery = (sessionChange: ClientSessionChange) => {
     if (!canResolveInvalidation) {
       // If there is no way to resolve the session invalidation,
       // just let the caller callServerEndpoint instance continue
       return Promise.resolve(null);
     }
     if (!loggedIn) {
       // We don't want to attempt any use native credentials of a logged out
       // user to log-in after a cookieInvalidation while logged out
       return Promise.resolve(null);
     }
     if (currentlyWaitingForNewCookie) {
       return new Promise<?CallServerEndpoint>(r =>
         serverEndpointCallsWaitingForNewCookie.push(r),
       );
     }
     currentlyWaitingForNewCookie = true;
     return attemptToResolveInvalidation(sessionChange);
   };
 
   return (
     endpoint: Endpoint,
     data: Object,
     options?: ?CallServerEndpointOptions,
   ) =>
     callServerEndpoint(
       cookie,
       boundSetNewSession,
       waitIfCookieInvalidated,
       cookieInvalidationRecovery,
       urlPrefix,
       sessionID,
       isSocketConnected,
       lastCommunicatedPlatformDetails,
       socketAPIHandler,
       endpoint,
       data,
       dispatch,
       options,
       loggedIn,
       keyserverID,
     );
 }
 
 export type ActionFunc<F> = (callServerEndpoint: CallServerEndpoint) => F;
 export type BindServerCall = <F>(serverCall: ActionFunc<F>) => F;
 export type BindServerCallsParams = {
   +dispatch: Dispatch,
   +cookie: ?string,
   +urlPrefix: string,
   +sessionID: ?string,
   +currentUserInfo: ?CurrentUserInfo,
   +isSocketConnected: boolean,
   +lastCommunicatedPlatformDetails: ?PlatformDetails,
   +keyserverID: string,
 };
 
 // All server calls needs to include some information from the Redux state
 // (namely, the cookie). This information is used deep in the server call,
 // at the point where callServerEndpoint is called. We don't want to bother
 // propagating the cookie (and any future config info that callServerEndpoint
 // needs) through to the server calls so they can pass it to callServerEndpoint.
 // Instead, we "curry" the cookie onto callServerEndpoint within react-redux's
 // connect's mapStateToProps function, and then pass that "bound"
 // callServerEndpoint that no longer needs the cookie as a parameter on to
 // the server call.
 const baseCreateBoundServerCallsSelector = <F>(
   actionFunc: ActionFunc<F>,
 ): (BindServerCallsParams => F) =>
   createSelector(
     (state: BindServerCallsParams) => state.dispatch,
     (state: BindServerCallsParams) => state.cookie,
     (state: BindServerCallsParams) => state.urlPrefix,
     (state: BindServerCallsParams) => state.sessionID,
     (state: BindServerCallsParams) => state.currentUserInfo,
     (state: BindServerCallsParams) => state.isSocketConnected,
     (state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
     (state: BindServerCallsParams) => state.keyserverID,
     (
       dispatch: Dispatch,
       cookie: ?string,
       urlPrefix: string,
       sessionID: ?string,
       currentUserInfo: ?CurrentUserInfo,
       isSocketConnected: boolean,
       lastCommunicatedPlatformDetails: ?PlatformDetails,
       keyserverID: string,
     ) => {
       const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({
         dispatch,
         cookie,
         urlPrefix,
         sessionID,
         currentUserInfo,
         isSocketConnected,
         lastCommunicatedPlatformDetails,
         keyserverID,
       });
       return actionFunc(boundCallServerEndpoint);
     },
   );
 
 type CreateBoundServerCallsSelectorType = <F>(
   ActionFunc<F>,
 ) => BindServerCallsParams => F;
 const createBoundServerCallsSelector: CreateBoundServerCallsSelectorType =
   (_memoize(baseCreateBoundServerCallsSelector): any);
 
 function useServerCall<F>(
   serverCall: ActionFunc<F>,
   paramOverride?: ?Partial<BindServerCallsParams>,
 ): F {
   const dispatch = useDispatch();
   const serverCallState = useSelector(
     serverCallStateSelector(ashoatKeyserverID),
   );
   return React.useMemo(() => {
     const { urlPrefix, isSocketConnected } = serverCallState;
     invariant(
       !!urlPrefix &&
         isSocketConnected !== undefined &&
         isSocketConnected !== null,
       'keyserver missing from keyserverStore',
     );
 
     return createBoundServerCallsSelector(serverCall)({
       ...serverCallState,
       urlPrefix,
       isSocketConnected,
       dispatch,
       ...paramOverride,
       keyserverID: ashoatKeyserverID,
     });
   }, [serverCall, serverCallState, dispatch, paramOverride]);
 }
 
 let socketAPIHandler: ?SocketAPIHandler = null;
 function registerActiveSocket(passedSocketAPIHandler: ?SocketAPIHandler) {
   socketAPIHandler = passedSocketAPIHandler;
 }
 
-function sortThreadIDsPerKeyserver(threadIDs: $ReadOnlyArray<string>): {
-  +[keyserverID: string]: $ReadOnlyArray<string>,
-} {
-  const results: { [string]: string[] } = {};
-  for (const threadID of threadIDs) {
-    const keyserverID = extractKeyserverIDFromID(threadID);
-    invariant(keyserverID, 'keyserver data missing from thread id');
-    if (results[keyserverID] === undefined) {
-      results[keyserverID] = [];
-    }
-    results[keyserverID].push(threadID);
-  }
-  return results;
-}
-
-type CalendarThreadFilterWithWritableThreadIDs = {
-  +type: 'threads',
-  +threadIDs: string[],
-};
-type CalendarFilterWithWritableThreadIDs =
-  | NotDeletedFilter
-  | CalendarThreadFilterWithWritableThreadIDs;
-type CalendarQueryWithWritableFilters = {
-  +startDate: string,
-  +endDate: string,
-  +filters: CalendarFilterWithWritableThreadIDs[],
-};
-function sortCalendarQueryPerKeyserver(
-  calendarQuery: CalendarQuery,
-  keyserverIDs: $ReadOnlyArray<string>,
-): {
-  +[keyserverID: string]: CalendarQuery,
-} {
-  const { startDate, endDate, filters } = calendarQuery;
-  const results: { [string]: CalendarQueryWithWritableFilters } = {};
-
-  for (const keyserverID of keyserverIDs) {
-    results[keyserverID] = {
-      startDate,
-      endDate,
-      filters: [],
-    };
-  }
-
-  for (const filter of filters) {
-    if (filter.type === 'not_deleted') {
-      for (const keyserverID in results) {
-        results[keyserverID].filters.push({ type: 'not_deleted' });
-      }
-    } else if (filter.type === 'threads') {
-      for (const threadID of filter.threadIDs) {
-        const keyserverID = extractKeyserverIDFromID(threadID);
-        if (results[keyserverID] === undefined) {
-          continue;
-        }
-        let threadFilter = results[keyserverID].filters.find(
-          flt => flt.type === 'threads',
-        );
-        invariant(
-          !threadFilter || threadFilter.type === 'threads',
-          'should only match CalendarThreadFilter',
-        );
-        if (!threadFilter) {
-          threadFilter = { type: 'threads', threadIDs: [] };
-          results[keyserverID].filters.push(threadFilter);
-        }
-
-        threadFilter.threadIDs.push(threadID);
-      }
-    } else {
-      console.warn('unhandled filter in sortCalendarQueryPerKeyserver');
-    }
-  }
-
-  return results;
-}
-
 export {
   useDispatchActionPromise,
   setNewSessionActionType,
   resolveKeyserverSessionInvalidation,
   createBoundServerCallsSelector,
   registerActiveSocket,
   useServerCall,
   bindCookieAndUtilsIntoCallServerEndpoint,
-  extractKeyserverIDFromID,
-  sortThreadIDsPerKeyserver,
-  sortCalendarQueryPerKeyserver,
 };
diff --git a/native/chat/settings/thread-settings-push-notifs.react.js b/native/chat/settings/thread-settings-push-notifs.react.js
index 4112dcffc..06919de11 100644
--- a/native/chat/settings/thread-settings-push-notifs.react.js
+++ b/native/chat/settings/thread-settings-push-notifs.react.js
@@ -1,196 +1,194 @@
 // @flow
 
 import * as React from 'react';
 import { View, Switch, TouchableOpacity, Platform } from 'react-native';
 import Linking from 'react-native/Libraries/Linking/Linking.js';
 
 import {
   updateSubscriptionActionTypes,
   useUpdateSubscription,
 } from 'lib/actions/user-actions.js';
+import { extractKeyserverIDFromID } from 'lib/keyserver-conn/keyserver-call-utils.js';
 import { deviceTokenSelector } from 'lib/selectors/keyserver-selectors.js';
 import type {
   SubscriptionUpdateRequest,
   SubscriptionUpdateResult,
 } from 'lib/types/subscription-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import type { DispatchActionPromise } from 'lib/utils/action-utils.js';
-import {
-  useDispatchActionPromise,
-  extractKeyserverIDFromID,
-} from 'lib/utils/action-utils.js';
+import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import SingleLine from '../../components/single-line.react.js';
 import SWMansionIcon from '../../components/swmansion-icon.react.js';
 import { CommAndroidNotifications } from '../../push/android.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { useStyles } from '../../themes/colors.js';
 import Alert from '../../utils/alert.js';
 
 const unboundStyles = {
   currentValue: {
     alignItems: 'flex-end',
     margin: 0,
     paddingLeft: 4,
     paddingRight: 0,
     paddingVertical: 0,
   },
   label: {
     color: 'panelForegroundTertiaryLabel',
     fontSize: 16,
     flex: 1,
   },
   row: {
     alignItems: 'center',
     backgroundColor: 'panelForeground',
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 3,
   },
   infoIcon: {
     paddingRight: 20,
   },
 };
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +hasPushPermissions: boolean,
   +updateSubscription: (
     subscriptionUpdate: SubscriptionUpdateRequest,
   ) => Promise<SubscriptionUpdateResult>,
 };
 type State = {
   +currentValue: boolean,
 };
 class ThreadSettingsPushNotifs extends React.PureComponent<Props, State> {
   constructor(props: Props) {
     super(props);
     this.state = {
       currentValue: props.threadInfo.currentUser.subscription.pushNotifs,
     };
   }
 
   render(): React.Node {
     const componentLabel = 'Push notifs';
     let notificationsSettingsLinkingIcon: React.Node = undefined;
     if (!this.props.hasPushPermissions) {
       notificationsSettingsLinkingIcon = (
         <TouchableOpacity
           onPress={this.onNotificationsSettingsLinkingIconPress}
         >
           <View style={this.props.styles.infoIcon}>
             <SWMansionIcon name="info-circle" size={25} color="gray" />
           </View>
         </TouchableOpacity>
       );
     }
     return (
       <View style={this.props.styles.row}>
         <SingleLine style={this.props.styles.label} adjustsFontSizeToFit={true}>
           {componentLabel}
         </SingleLine>
         {notificationsSettingsLinkingIcon}
         <View style={this.props.styles.currentValue}>
           <Switch
             value={this.state.currentValue}
             onValueChange={this.onValueChange}
             disabled={!this.props.hasPushPermissions}
           />
         </View>
       </View>
     );
   }
 
   onValueChange = (value: boolean) => {
     this.setState({ currentValue: value });
     void this.props.dispatchActionPromise(
       updateSubscriptionActionTypes,
       this.props.updateSubscription({
         threadID: this.props.threadInfo.id,
         updatedFields: {
           pushNotifs: value,
         },
       }),
     );
   };
 
   onNotificationsSettingsLinkingIconPress = async () => {
     let platformRequestsPermission;
     if (Platform.OS !== 'android') {
       platformRequestsPermission = true;
     } else {
       platformRequestsPermission =
         await CommAndroidNotifications.canRequestNotificationsPermissionFromUser();
     }
 
     const alertTitle = platformRequestsPermission
       ? 'Need notif permissions'
       : 'Unable to initialize notifs';
     const notificationsSettingsPath =
       Platform.OS === 'ios'
         ? 'Settings App → Notifications → Comm'
         : 'Settings → Apps → Comm → Notifications';
 
     let alertMessage;
     if (platformRequestsPermission && this.state.currentValue) {
       alertMessage =
         'Notifs for this chat are enabled, but cannot be delivered ' +
         'to this device because you haven’t granted notif permissions to Comm. ' +
         'Please enable them in ' +
         notificationsSettingsPath;
     } else if (platformRequestsPermission) {
       alertMessage =
         'In order to enable push notifs for this chat, ' +
         'you need to first grant notif permissions to Comm. ' +
         'Please enable them in ' +
         notificationsSettingsPath;
     } else {
       alertMessage =
         'Please check your network connection, make sure Google Play ' +
         'services are installed and enabled, and confirm that your Google ' +
         'Play credentials are valid in the Google Play Store.';
     }
     Alert.alert(alertTitle, alertMessage, [
       {
         text: 'Go to settings',
         onPress: () => Linking.openSettings(),
       },
       {
         text: 'Cancel',
         style: 'cancel',
       },
     ]);
   };
 }
 
 const ConnectedThreadSettingsPushNotifs: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedThreadSettingsPushNotifs(
     props: BaseProps,
   ) {
     const keyserverID = extractKeyserverIDFromID(props.threadInfo.id);
     const deviceToken = useSelector(deviceTokenSelector(keyserverID));
     const hasPushPermissions =
       deviceToken !== null && deviceToken !== undefined;
     const styles = useStyles(unboundStyles);
     const dispatchActionPromise = useDispatchActionPromise();
     const callUpdateSubscription = useUpdateSubscription();
     return (
       <ThreadSettingsPushNotifs
         {...props}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         updateSubscription={callUpdateSubscription}
         hasPushPermissions={hasPushPermissions}
       />
     );
   });
 
 export default ConnectedThreadSettingsPushNotifs;
diff --git a/web/redux/action-types.js b/web/redux/action-types.js
index 872728e1f..5bda74ad5 100644
--- a/web/redux/action-types.js
+++ b/web/redux/action-types.js
@@ -1,184 +1,184 @@
 // @flow
 
+import { extractKeyserverIDFromID } from 'lib/keyserver-conn/keyserver-call-utils.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.js';
-import { extractKeyserverIDFromID } from 'lib/utils/action-utils.js';
 import { useKeyserverCall } from 'lib/utils/keyserver-call.js';
 import type { CallKeyserverEndpoint } from 'lib/utils/keyserver-call.js';
 import type { URLInfo } from 'lib/utils/url-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import type {
   ExcludedData,
   InitialReduxState,
   InitialReduxStateResponse,
   InitialKeyserverInfo,
   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 getInitialReduxStateCallServerEndpointOptions = { 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 !== ashoatKeyserverID) {
         continue;
       }
       const clientUpdatesCurrentAsOf = allUpdatesCurrentAsOf[keyserverID];
       const keyserverExcludedData: ExcludedData = {
         threadStore: !!excludedData.threadStore && !!clientUpdatesCurrentAsOf,
       };
       if (keyserverID === threadKeyserverID) {
         requests[keyserverID] = {
           urlInfo,
           excludedData: keyserverExcludedData,
           clientUpdatesCurrentAsOf,
         };
       } else {
         requests[keyserverID] = {
           urlInfo: rest,
           excludedData: keyserverExcludedData,
           clientUpdatesCurrentAsOf,
         };
       }
     }
 
     const responses: { +[string]: InitialReduxStateResponse } =
       await callKeyserverEndpoint(
         'get_initial_redux_state',
         requests,
         getInitialReduxStateCallServerEndpointOptions,
       );
 
     const {
       currentUserInfo,
       userInfos,
       pushApiPublicKey,
       commServicesAccessToken,
       navInfo,
     } = responses[ashoatKeyserverID];
 
     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]: InitialKeyserverInfo } = {};
 
     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,
       commServicesAccessToken,
       inviteLinksStore,
       keyserverInfos,
     };
   };
 
 function useGetInitialReduxState(): (
   input: GetInitialReduxStateInput,
 ) => Promise<InitialReduxState> {
   return useKeyserverCall(getInitialReduxState);
 }
 
 export { useGetInitialReduxState };