diff --git a/lib/components/integrity-handler.react.js b/lib/components/integrity-handler.react.js
index 010b6f340..093e2bd9f 100644
--- a/lib/components/integrity-handler.react.js
+++ b/lib/components/integrity-handler.react.js
@@ -1,64 +1,63 @@
 // @flow
 
 import * as React from 'react';
-import { useDispatch } from 'react-redux';
 
 import { updateIntegrityStoreActionType } from '../actions/integrity-actions.js';
 import { splitIntoChunks } from '../utils/array.js';
-import { useSelector } from '../utils/redux-utils.js';
+import { useSelector, useDispatch } from '../utils/redux-utils.js';
 
 const BATCH_SIZE = 50;
 // Time between hashing of each thread batch
 const BATCH_INTERVAL = 500; // in milliseconds
 
 function IntegrityHandler(): null {
   const dispatch = useDispatch();
 
   const threadInfos = useSelector(state => state.threadStore.threadInfos);
   const integrityStore = useSelector(state => state.integrityStore);
 
   const [batches, setBatches] =
     React.useState<?$ReadOnlyArray<$ReadOnlyArray<string>>>(null);
   const timeout = React.useRef<?TimeoutID>(null);
 
   React.useEffect(() => {
     if (integrityStore.threadHashingStatus === 'starting') {
       const threadIDs = Object.keys(threadInfos);
       setBatches(splitIntoChunks(threadIDs, BATCH_SIZE));
       dispatch({
         type: updateIntegrityStoreActionType,
         payload: { threadHashingStatus: 'running' },
       });
     } else if (integrityStore.threadHashingStatus === 'completed') {
       clearTimeout(timeout.current);
       setBatches(null);
     }
   }, [dispatch, integrityStore.threadHashingStatus, threadInfos]);
 
   React.useEffect(() => {
     if (!batches) {
       return undefined;
     }
     const [batch, ...rest] = batches;
     if (!batch) {
       dispatch({
         type: updateIntegrityStoreActionType,
         payload: { threadHashingStatus: 'completed' },
       });
       return undefined;
     }
 
     dispatch({
       type: updateIntegrityStoreActionType,
       payload: { threadIDsToHash: batch },
     });
 
     const timeoutID = setTimeout(() => setBatches(rest), BATCH_INTERVAL);
     timeout.current = timeoutID;
     return () => clearTimeout(timeoutID);
   }, [batches, dispatch]);
 
   return null;
 }
 
 export default IntegrityHandler;
diff --git a/lib/components/thread-draft-updater.react.js b/lib/components/thread-draft-updater.react.js
index 9ecc89b02..4c0aaa2fe 100644
--- a/lib/components/thread-draft-updater.react.js
+++ b/lib/components/thread-draft-updater.react.js
@@ -1,51 +1,50 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
-import { useDispatch } from 'react-redux';
 
 import { moveDraftActionType } from '../actions/draft-actions.js';
 import { pendingToRealizedThreadIDsSelector } from '../selectors/thread-selectors.js';
 import { draftKeyFromThreadID } from '../shared/thread-utils.js';
 import type { AppState } from '../types/redux-types.js';
-import { useSelector } from '../utils/redux-utils.js';
+import { useSelector, useDispatch } from '../utils/redux-utils.js';
 
 const ThreadDraftUpdater: React.ComponentType<{}> = React.memo<{}>(
   function ThreadDraftUpdater() {
     const pendingToRealizedThreadIDs = useSelector((state: AppState) =>
       pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
     );
     const dispatch = useDispatch();
 
     const cachedThreadIDsRef = React.useRef<?Set<string>>();
     if (!cachedThreadIDsRef.current) {
       const newCachedThreadIDs = new Set();
       for (const realizedThreadID of pendingToRealizedThreadIDs.values()) {
         newCachedThreadIDs.add(realizedThreadID);
       }
       cachedThreadIDsRef.current = newCachedThreadIDs;
     }
 
     React.useEffect(() => {
       for (const [pendingThreadID, threadID] of pendingToRealizedThreadIDs) {
         const cachedThreadIDs = cachedThreadIDsRef.current;
         invariant(cachedThreadIDs, 'should be set');
         if (cachedThreadIDs.has(threadID)) {
           continue;
         }
         dispatch({
           type: moveDraftActionType,
           payload: {
             oldKey: draftKeyFromThreadID(pendingThreadID),
             newKey: draftKeyFromThreadID(threadID),
           },
         });
         cachedThreadIDs.add(threadID);
       }
     }, [pendingToRealizedThreadIDs, dispatch]);
     return null;
   },
 );
 ThreadDraftUpdater.displayName = 'ThreadDraftUpdater';
 
 export default ThreadDraftUpdater;
diff --git a/lib/hooks/disconnected-bar.js b/lib/hooks/disconnected-bar.js
index 7b5e819d2..153a0cd15 100644
--- a/lib/hooks/disconnected-bar.js
+++ b/lib/hooks/disconnected-bar.js
@@ -1,118 +1,117 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
-import { useDispatch } from 'react-redux';
 
 import { connectionSelector } from '../selectors/keyserver-selectors.js';
 import {
   updateDisconnectedBarActionType,
   type ConnectionStatus,
 } from '../types/socket-types.js';
-import { useSelector } from '../utils/redux-utils.js';
+import { useSelector, useDispatch } from '../utils/redux-utils.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 function useDisconnectedBarVisibilityHandler(networkConnected: boolean): void {
   const dispatch = useDispatch();
   const connection = useSelector(connectionSelector(ashoatKeyserverID));
   invariant(connection, 'keyserver missing from keyserverStore');
 
   const disconnected = connection.showDisconnectedBar;
   const setDisconnected = React.useCallback(
     (newDisconnected: boolean) => {
       if (newDisconnected === disconnected) {
         return;
       }
       dispatch({
         type: updateDisconnectedBarActionType,
         payload: { visible: newDisconnected, keyserverID: ashoatKeyserverID },
       });
     },
     [disconnected, dispatch],
   );
 
   const networkActiveRef = React.useRef<boolean>(true);
   React.useEffect(() => {
     networkActiveRef.current = networkConnected;
     if (!networkConnected) {
       setDisconnected(true);
     }
   }, [setDisconnected, networkConnected]);
 
   const prevConnectionStatusRef = React.useRef<?ConnectionStatus>();
   const connectionStatus = connection.status;
   const someRequestIsLate = connection.lateResponses.length !== 0;
   React.useEffect(() => {
     const prevConnectionStatus = prevConnectionStatusRef.current;
     prevConnectionStatusRef.current = connectionStatus;
 
     if (
       connectionStatus === 'connected' &&
       prevConnectionStatus !== 'connected'
     ) {
       // Sometimes NetInfo misses the network coming back online for some
       // reason. But if the socket reconnects, the network must be up
       networkActiveRef.current = true;
       setDisconnected(false);
     } else if (!networkActiveRef.current || someRequestIsLate) {
       setDisconnected(true);
     } else if (
       connectionStatus === 'reconnecting' ||
       connectionStatus === 'forcedDisconnecting'
     ) {
       setDisconnected(true);
     } else if (connectionStatus === 'connected') {
       setDisconnected(false);
     }
   }, [connectionStatus, someRequestIsLate, setDisconnected]);
 }
 
 function useShouldShowDisconnectedBar(): {
   +disconnected: boolean,
   +shouldShowDisconnectedBar: boolean,
 } {
   const connection = useSelector(connectionSelector(ashoatKeyserverID));
   invariant(connection, 'keyserver missing from keyserverStore');
   const disconnected = connection.showDisconnectedBar;
   const socketConnected = connection.status === 'connected';
 
   const shouldShowDisconnectedBar = disconnected || !socketConnected;
   return { disconnected, shouldShowDisconnectedBar };
 }
 
 type DisconnectedBarCause = 'connecting' | 'disconnected';
 
 function useDisconnectedBar(
   changeShowing: boolean => void,
 ): DisconnectedBarCause {
   const { disconnected, shouldShowDisconnectedBar } =
     useShouldShowDisconnectedBar();
 
   const prevShowDisconnectedBar = React.useRef<?boolean>();
   React.useEffect(() => {
     const wasShowing = prevShowDisconnectedBar.current;
     if (shouldShowDisconnectedBar && wasShowing === false) {
       changeShowing(true);
     } else if (!shouldShowDisconnectedBar && wasShowing) {
       changeShowing(false);
     }
     prevShowDisconnectedBar.current = shouldShowDisconnectedBar;
   }, [shouldShowDisconnectedBar, changeShowing]);
 
   const [barCause, setBarCause] =
     React.useState<DisconnectedBarCause>('connecting');
   React.useEffect(() => {
     if (shouldShowDisconnectedBar && disconnected) {
       setBarCause('disconnected');
     } else if (shouldShowDisconnectedBar) {
       setBarCause('connecting');
     }
   }, [shouldShowDisconnectedBar, disconnected]);
   return barCause;
 }
 
 export {
   useDisconnectedBarVisibilityHandler,
   useShouldShowDisconnectedBar,
   useDisconnectedBar,
 };
diff --git a/lib/hooks/relationship-prompt.js b/lib/hooks/relationship-prompt.js
index b34db2883..e5388f55a 100644
--- a/lib/hooks/relationship-prompt.js
+++ b/lib/hooks/relationship-prompt.js
@@ -1,128 +1,128 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
-import { useSelector } from 'react-redux';
 
 import {
   updateRelationships as serverUpdateRelationships,
   updateRelationshipsActionTypes,
 } from '../actions/relationship-actions.js';
 import { getSingleOtherUser } from '../shared/thread-utils.js';
 import type { MinimallyEncodedThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import {
   type RelationshipAction,
   relationshipActions,
 } from '../types/relationship-types.js';
 import type { ThreadInfo } from '../types/thread-types.js';
 import type { UserInfo } from '../types/user-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from '../utils/action-utils.js';
+import { useSelector } from '../utils/redux-utils.js';
 
 type RelationshipCallbacks = {
   +blockUser: () => void,
   +unblockUser: () => void,
   +friendUser: () => void,
   +unfriendUser: () => void,
 };
 
 type RelationshipPromptData = {
   +otherUserInfo: ?UserInfo,
   +callbacks: RelationshipCallbacks,
 };
 
 function useRelationshipPrompt(
   threadInfo: ThreadInfo | MinimallyEncodedThreadInfo,
   onErrorCallback?: () => void,
   pendingPersonalThreadUserInfo?: ?UserInfo,
 ): RelationshipPromptData {
   // We're fetching the info from state because we need the most recent
   // relationship status. Additionally, member info does not contain info
   // about relationship.
   const otherUserInfo = useSelector(state => {
     const otherUserID =
       getSingleOtherUser(threadInfo, state.currentUserInfo?.id) ??
       pendingPersonalThreadUserInfo?.id;
     const { userInfos } = state.userStore;
     return otherUserID && userInfos[otherUserID]
       ? userInfos[otherUserID]
       : pendingPersonalThreadUserInfo;
   });
 
   const callbacks = useRelationshipCallbacks(
     otherUserInfo?.id,
     onErrorCallback,
   );
 
   return React.useMemo(
     () => ({
       otherUserInfo,
       callbacks,
     }),
     [callbacks, otherUserInfo],
   );
 }
 
 function useRelationshipCallbacks(
   otherUserID?: string,
   onErrorCallback?: () => void,
 ): RelationshipCallbacks {
   const callUpdateRelationships = useServerCall(serverUpdateRelationships);
   const updateRelationship = React.useCallback(
     async (action: RelationshipAction) => {
       try {
         invariant(otherUserID, 'Other user info id should be present');
         return await callUpdateRelationships({
           action,
           userIDs: [otherUserID],
         });
       } catch (e) {
         onErrorCallback?.();
         throw e;
       }
     },
     [callUpdateRelationships, onErrorCallback, otherUserID],
   );
 
   const dispatchActionPromise = useDispatchActionPromise();
   const onButtonPress = React.useCallback(
     (action: RelationshipAction) => {
       dispatchActionPromise(
         updateRelationshipsActionTypes,
         updateRelationship(action),
       );
     },
     [dispatchActionPromise, updateRelationship],
   );
 
   const blockUser = React.useCallback(
     () => onButtonPress(relationshipActions.BLOCK),
     [onButtonPress],
   );
   const unblockUser = React.useCallback(
     () => onButtonPress(relationshipActions.UNBLOCK),
     [onButtonPress],
   );
   const friendUser = React.useCallback(
     () => onButtonPress(relationshipActions.FRIEND),
     [onButtonPress],
   );
   const unfriendUser = React.useCallback(
     () => onButtonPress(relationshipActions.UNFRIEND),
     [onButtonPress],
   );
 
   return React.useMemo(
     () => ({
       blockUser,
       unblockUser,
       friendUser,
       unfriendUser,
     }),
     [blockUser, friendUser, unblockUser, unfriendUser],
   );
 }
 
 export { useRelationshipPrompt, useRelationshipCallbacks };
diff --git a/lib/hooks/theme.js b/lib/hooks/theme.js
index 85e2fade2..373db7d81 100644
--- a/lib/hooks/theme.js
+++ b/lib/hooks/theme.js
@@ -1,70 +1,69 @@
 // @flow
 
 import * as React from 'react';
-import { useDispatch } from 'react-redux';
 
 import { updateThemeInfoActionType } from '../actions/theme-actions.js';
 import type { Shape } from '../types/core.js';
 import type {
   GlobalTheme,
   GlobalThemeInfo,
   GlobalThemePreference,
 } from '../types/theme-types.js';
-import { useSelector } from '../utils/redux-utils.js';
+import { useSelector, useDispatch } from '../utils/redux-utils.js';
 
 function useUpdateSystemTheme(): (colorScheme: ?GlobalTheme) => mixed {
   const globalThemeInfo = useSelector(state => state.globalThemeInfo);
   const dispatch = useDispatch();
 
   return React.useCallback(
     (colorScheme: ?GlobalTheme) => {
       if (globalThemeInfo.systemTheme === colorScheme) {
         return;
       }
 
       let updateObject: Shape<GlobalThemeInfo> = {
         systemTheme: colorScheme,
       };
       if (globalThemeInfo.preference === 'system') {
         updateObject = { ...updateObject, activeTheme: colorScheme };
       }
 
       dispatch({
         type: updateThemeInfoActionType,
         payload: updateObject,
       });
     },
     [globalThemeInfo, dispatch],
   );
 }
 
 function useUpdateThemePreference(): (
   themePreference: GlobalThemePreference,
 ) => mixed {
   const globalThemeInfo = useSelector(state => state.globalThemeInfo);
   const dispatch = useDispatch();
 
   return React.useCallback(
     (themePreference: GlobalThemePreference) => {
       if (themePreference === globalThemeInfo.preference) {
         return;
       }
 
       let theme = themePreference;
       if (themePreference === 'system') {
         theme = globalThemeInfo.systemTheme;
       }
 
       dispatch({
         type: updateThemeInfoActionType,
         payload: {
           preference: themePreference,
           activeTheme: theme,
         },
       });
     },
     [globalThemeInfo, dispatch],
   );
 }
 
 export { useUpdateSystemTheme, useUpdateThemePreference };
diff --git a/lib/selectors/chat-selectors.js b/lib/selectors/chat-selectors.js
index 165ca567d..1b047f2ad 100644
--- a/lib/selectors/chat-selectors.js
+++ b/lib/selectors/chat-selectors.js
@@ -1,717 +1,717 @@
 // @flow
 
 import invariant from 'invariant';
 import _filter from 'lodash/fp/filter.js';
 import _flow from 'lodash/fp/flow.js';
 import _map from 'lodash/fp/map.js';
 import _orderBy from 'lodash/fp/orderBy.js';
 import * as React from 'react';
-import { useSelector } from 'react-redux';
 import { createSelector } from 'reselect';
 import { createObjectSelector } from 'reselect-map';
 
 import {
   threadInfoSelector,
   sidebarInfoSelector,
   threadInfoFromSourceMessageIDSelector,
 } from './thread-selectors.js';
 import {
   messageKey,
   robotextForMessageInfo,
   createMessageInfo,
   getMostRecentNonLocalMessageID,
   sortMessageInfoList,
 } from '../shared/message-utils.js';
 import {
   threadIsPending,
   threadIsTopLevel,
   threadInChatList,
 } from '../shared/thread-utils.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import {
   type MessageInfo,
   type MessageStore,
   type ComposableMessageInfo,
   type RobotextMessageInfo,
   type LocalMessageInfo,
   isComposableMessageType,
 } from '../types/message-types.js';
 import type {
   MinimallyEncodedRawThreadInfo,
   MinimallyEncodedThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import type { BaseAppState } from '../types/redux-types.js';
 import { threadTypes } from '../types/thread-types-enum.js';
 import {
   type ThreadInfo,
   type RawThreadInfo,
   type SidebarInfo,
   maxReadSidebars,
   maxUnreadSidebars,
 } from '../types/thread-types.js';
 import type {
   UserInfo,
   AccountUserInfo,
   RelativeUserInfo,
 } from '../types/user-types.js';
 import { threeDays } from '../utils/date-utils.js';
 import type { EntityText } from '../utils/entity-text.js';
 import memoize2 from '../utils/memoize.js';
+import { useSelector } from '../utils/redux-utils.js';
 
 export type SidebarItem =
   | {
       ...SidebarInfo,
       +type: 'sidebar',
     }
   | {
       +type: 'seeMore',
       +unread: boolean,
     }
   | { +type: 'spacer' };
 
 export type ChatThreadItem = {
   +type: 'chatThreadItem',
   +threadInfo: ThreadInfo,
   +mostRecentMessageInfo: ?MessageInfo,
   +mostRecentNonLocalMessage: ?string,
   +lastUpdatedTime: number,
   +lastUpdatedTimeIncludingSidebars: number,
   +sidebars: $ReadOnlyArray<SidebarItem>,
   +pendingPersonalThreadUserInfo?: UserInfo,
 };
 
 const messageInfoSelector: (state: BaseAppState<>) => {
   +[id: string]: ?MessageInfo,
 } = createObjectSelector(
   (state: BaseAppState<>) => state.messageStore.messages,
   (state: BaseAppState<>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<>) => state.userStore.userInfos,
   threadInfoSelector,
   createMessageInfo,
 );
 
 function isEmptyMediaMessage(messageInfo: MessageInfo): boolean {
   return (
     (messageInfo.type === messageTypes.MULTIMEDIA ||
       messageInfo.type === messageTypes.IMAGES) &&
     messageInfo.media.length === 0
   );
 }
 
 function getMostRecentMessageInfo(
   threadInfo: ThreadInfo | MinimallyEncodedThreadInfo,
   messageStore: MessageStore,
   messages: { +[id: string]: ?MessageInfo },
 ): ?MessageInfo {
   const thread = messageStore.threads[threadInfo.id];
   if (!thread) {
     return null;
   }
   for (const messageID of thread.messageIDs) {
     const messageInfo = messages[messageID];
     if (!messageInfo || isEmptyMediaMessage(messageInfo)) {
       continue;
     }
     return messageInfo;
   }
   return null;
 }
 
 function getLastUpdatedTime(
   threadInfo: ThreadInfo | MinimallyEncodedThreadInfo,
   mostRecentMessageInfo: ?MessageInfo,
 ): number {
   return mostRecentMessageInfo
     ? mostRecentMessageInfo.time
     : threadInfo.creationTime;
 }
 
 function createChatThreadItem(
   threadInfo: ThreadInfo,
   messageStore: MessageStore,
   messages: { +[id: string]: ?MessageInfo },
   sidebarInfos: ?$ReadOnlyArray<SidebarInfo>,
 ): ChatThreadItem {
   const mostRecentMessageInfo = getMostRecentMessageInfo(
     threadInfo,
     messageStore,
     messages,
   );
   const mostRecentNonLocalMessage = getMostRecentNonLocalMessageID(
     threadInfo.id,
     messageStore,
   );
   const lastUpdatedTime = getLastUpdatedTime(threadInfo, mostRecentMessageInfo);
 
   const sidebars = sidebarInfos ?? [];
   const allSidebarItems = sidebars.map(sidebarInfo => ({
     type: 'sidebar',
     ...sidebarInfo,
   }));
   const lastUpdatedTimeIncludingSidebars =
     allSidebarItems.length > 0
       ? Math.max(lastUpdatedTime, allSidebarItems[0].lastUpdatedTime)
       : lastUpdatedTime;
 
   const numUnreadSidebars = allSidebarItems.filter(
     sidebar => sidebar.threadInfo.currentUser.unread,
   ).length;
   let numReadSidebarsToShow = maxReadSidebars - numUnreadSidebars;
   const threeDaysAgo = Date.now() - threeDays;
 
   const sidebarItems = [];
   for (const sidebar of allSidebarItems) {
     if (sidebarItems.length >= maxUnreadSidebars) {
       break;
     } else if (sidebar.threadInfo.currentUser.unread) {
       sidebarItems.push(sidebar);
     } else if (
       sidebar.lastUpdatedTime > threeDaysAgo &&
       numReadSidebarsToShow > 0
     ) {
       sidebarItems.push(sidebar);
       numReadSidebarsToShow--;
     }
   }
 
   const numReadButRecentSidebars = allSidebarItems.filter(
     sidebar =>
       !sidebar.threadInfo.currentUser.unread &&
       sidebar.lastUpdatedTime > threeDaysAgo,
   ).length;
   if (
     sidebarItems.length < numUnreadSidebars + numReadButRecentSidebars ||
     (sidebarItems.length < allSidebarItems.length && sidebarItems.length > 0)
   ) {
     sidebarItems.push({
       type: 'seeMore',
       unread: numUnreadSidebars > maxUnreadSidebars,
     });
   }
   if (sidebarItems.length !== 0) {
     sidebarItems.push({
       type: 'spacer',
     });
   }
 
   return {
     type: 'chatThreadItem',
     threadInfo,
     mostRecentMessageInfo,
     mostRecentNonLocalMessage,
     lastUpdatedTime,
     lastUpdatedTimeIncludingSidebars,
     sidebars: sidebarItems,
   };
 }
 
 const chatListData: (state: BaseAppState<>) => $ReadOnlyArray<ChatThreadItem> =
   createSelector(
     threadInfoSelector,
     (state: BaseAppState<>) => state.messageStore,
     messageInfoSelector,
     sidebarInfoSelector,
     (
       threadInfos: { +[id: string]: ThreadInfo },
       messageStore: MessageStore,
       messageInfos: { +[id: string]: ?MessageInfo },
       sidebarInfos: { +[id: string]: $ReadOnlyArray<SidebarInfo> },
     ): $ReadOnlyArray<ChatThreadItem> =>
       getChatThreadItems(
         threadInfos,
         messageStore,
         messageInfos,
         sidebarInfos,
         threadIsTopLevel,
       ),
   );
 
 function useFlattenedChatListData(): $ReadOnlyArray<ChatThreadItem> {
   return useFilteredChatListData(threadInChatList);
 }
 
 function useFilteredChatListData(
   filterFunction: (
     threadInfo: ?(
       | ThreadInfo
       | RawThreadInfo
       | MinimallyEncodedThreadInfo
       | MinimallyEncodedRawThreadInfo
     ),
   ) => boolean,
 ): $ReadOnlyArray<ChatThreadItem> {
   const threadInfos = useSelector(threadInfoSelector);
   const messageInfos = useSelector(messageInfoSelector);
   const sidebarInfos = useSelector(sidebarInfoSelector);
   const messageStore = useSelector(state => state.messageStore);
 
   return React.useMemo(
     () =>
       getChatThreadItems(
         threadInfos,
         messageStore,
         messageInfos,
         sidebarInfos,
         filterFunction,
       ),
     [messageInfos, messageStore, sidebarInfos, filterFunction, threadInfos],
   );
 }
 
 function getChatThreadItems(
   threadInfos: { +[id: string]: ThreadInfo },
   messageStore: MessageStore,
   messageInfos: { +[id: string]: ?MessageInfo },
   sidebarInfos: { +[id: string]: $ReadOnlyArray<SidebarInfo> },
   filterFunction: (
     threadInfo: ?(
       | ThreadInfo
       | RawThreadInfo
       | MinimallyEncodedThreadInfo
       | MinimallyEncodedRawThreadInfo
     ),
   ) => boolean,
 ): $ReadOnlyArray<ChatThreadItem> {
   return _flow(
     _filter(filterFunction),
     _map((threadInfo: ThreadInfo): ChatThreadItem =>
       createChatThreadItem(
         threadInfo,
         messageStore,
         messageInfos,
         sidebarInfos[threadInfo.id],
       ),
     ),
     _orderBy('lastUpdatedTimeIncludingSidebars')('desc'),
   )(threadInfos);
 }
 
 export type RobotextChatMessageInfoItem = {
   +itemType: 'message',
   +messageInfoType: 'robotext',
   +messageInfo: RobotextMessageInfo,
   +startsConversation: boolean,
   +startsCluster: boolean,
   endsCluster: boolean,
   +robotext: EntityText,
   +threadCreatedFromMessage: ?ThreadInfo | ?MinimallyEncodedThreadInfo,
   +reactions: ReactionInfo,
 };
 export type ChatMessageInfoItem =
   | RobotextChatMessageInfoItem
   | {
       +itemType: 'message',
       +messageInfoType: 'composable',
       +messageInfo: ComposableMessageInfo,
       +localMessageInfo: ?LocalMessageInfo,
       +startsConversation: boolean,
       +startsCluster: boolean,
       endsCluster: boolean,
       +threadCreatedFromMessage: ?ThreadInfo | ?MinimallyEncodedThreadInfo,
       +reactions: ReactionInfo,
       +hasBeenEdited: boolean,
       +isPinned: boolean,
     };
 export type ChatMessageItem = { itemType: 'loader' } | ChatMessageInfoItem;
 
 export type ReactionInfo = { +[reaction: string]: MessageReactionInfo };
 type MessageReactionInfo = {
   +viewerReacted: boolean,
   +users: $ReadOnlyArray<RelativeUserInfo>,
 };
 type TargetMessageReactions = Map<string, Map<string, RelativeUserInfo>>;
 
 const msInFiveMinutes = 5 * 60 * 1000;
 function createChatMessageItems(
   threadID: string,
   messageStore: MessageStore,
   messageInfos: { +[id: string]: ?MessageInfo },
   threadInfos: { +[id: string]: ThreadInfo },
   threadInfoFromSourceMessageID: { +[id: string]: ThreadInfo },
   additionalMessages: $ReadOnlyArray<MessageInfo>,
   viewerID: string,
 ): ChatMessageItem[] {
   const thread = messageStore.threads[threadID];
 
   const threadMessageInfos = (thread?.messageIDs ?? [])
     .map((messageID: string) => messageInfos[messageID])
     .filter(Boolean);
   const messages =
     additionalMessages.length > 0
       ? sortMessageInfoList([...threadMessageInfos, ...additionalMessages])
       : threadMessageInfos;
 
   const targetMessageReactionsMap = new Map<string, TargetMessageReactions>();
 
   // We need to iterate backwards to put the order of messages in chronological
   // order, starting with the oldest. This avoids the scenario where the most
   // recent message with the remove_reaction action may try to remove a user
   // that hasn't been added to the messageReactionUsersInfoMap, causing it
   // to be skipped.
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
     if (messageInfo.type !== messageTypes.REACTION) {
       continue;
     }
 
     if (!targetMessageReactionsMap.has(messageInfo.targetMessageID)) {
       const reactsMap: TargetMessageReactions = new Map();
       targetMessageReactionsMap.set(messageInfo.targetMessageID, reactsMap);
     }
 
     const messageReactsMap = targetMessageReactionsMap.get(
       messageInfo.targetMessageID,
     );
     invariant(messageReactsMap, 'messageReactsInfo should be set');
 
     if (!messageReactsMap.has(messageInfo.reaction)) {
       const usersInfoMap = new Map<string, RelativeUserInfo>();
       messageReactsMap.set(messageInfo.reaction, usersInfoMap);
     }
 
     const messageReactionUsersInfoMap = messageReactsMap.get(
       messageInfo.reaction,
     );
     invariant(
       messageReactionUsersInfoMap,
       'messageReactionUsersInfoMap should be set',
     );
 
     if (messageInfo.action === 'add_reaction') {
       messageReactionUsersInfoMap.set(
         messageInfo.creator.id,
         messageInfo.creator,
       );
     } else {
       messageReactionUsersInfoMap.delete(messageInfo.creator.id);
     }
   }
 
   const targetMessageEditMap = new Map<string, string>();
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
     if (messageInfo.type !== messageTypes.EDIT_MESSAGE) {
       continue;
     }
     targetMessageEditMap.set(messageInfo.targetMessageID, messageInfo.text);
   }
 
   const targetMessagePinStatusMap = new Map<string, boolean>();
   // Once again, we iterate backwards to put the order of messages in
   // chronological order (i.e. oldest to newest) to handle pinned messages.
   // This is important because we want to make sure that the most recent pin
   // action is the one that is used to determine whether a message
   // is pinned or not.
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
     if (messageInfo.type !== messageTypes.TOGGLE_PIN) {
       continue;
     }
 
     targetMessagePinStatusMap.set(
       messageInfo.targetMessageID,
       messageInfo.action === 'pin',
     );
   }
 
   const chatMessageItems = [];
   let lastMessageInfo = null;
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
 
     if (
       messageInfo.type === messageTypes.REACTION ||
       messageInfo.type === messageTypes.EDIT_MESSAGE
     ) {
       continue;
     }
 
     let originalMessageInfo =
       messageInfo.type === messageTypes.SIDEBAR_SOURCE
         ? messageInfo.sourceMessage
         : messageInfo;
 
     if (isEmptyMediaMessage(originalMessageInfo)) {
       continue;
     }
 
     let hasBeenEdited = false;
     if (
       originalMessageInfo.type === messageTypes.TEXT &&
       originalMessageInfo.id
     ) {
       const newText = targetMessageEditMap.get(originalMessageInfo.id);
       if (newText !== undefined) {
         hasBeenEdited = true;
         originalMessageInfo = {
           ...originalMessageInfo,
           text: newText,
         };
       }
     }
 
     let startsConversation = true;
     let startsCluster = true;
     if (
       lastMessageInfo &&
       lastMessageInfo.time + msInFiveMinutes > originalMessageInfo.time
     ) {
       startsConversation = false;
       if (
         isComposableMessageType(lastMessageInfo.type) &&
         isComposableMessageType(originalMessageInfo.type) &&
         lastMessageInfo.creator.id === originalMessageInfo.creator.id
       ) {
         startsCluster = false;
       }
     }
     if (startsCluster && chatMessageItems.length > 0) {
       const lastMessageItem = chatMessageItems[chatMessageItems.length - 1];
       invariant(lastMessageItem.itemType === 'message', 'should be message');
       lastMessageItem.endsCluster = true;
     }
     const threadCreatedFromMessage =
       messageInfo.id && threadInfos[threadID]?.type !== threadTypes.SIDEBAR
         ? threadInfoFromSourceMessageID[messageInfo.id]
         : undefined;
 
     const isPinned = !!(
       originalMessageInfo.id &&
       targetMessagePinStatusMap.get(originalMessageInfo.id)
     );
 
     const renderedReactions: ReactionInfo = (() => {
       const result: { [string]: MessageReactionInfo } = {};
 
       let messageReactsMap;
       if (originalMessageInfo.id) {
         messageReactsMap = targetMessageReactionsMap.get(
           originalMessageInfo.id,
         );
       }
 
       if (!messageReactsMap) {
         return result;
       }
 
       for (const reaction of messageReactsMap.keys()) {
         const reactionUsersInfoMap = messageReactsMap.get(reaction);
         invariant(reactionUsersInfoMap, 'reactionUsersInfoMap should be set');
 
         if (reactionUsersInfoMap.size === 0) {
           continue;
         }
 
         const reactionUserInfos = [...reactionUsersInfoMap.values()];
 
         const messageReactionInfo = {
           users: reactionUserInfos,
           viewerReacted: reactionUsersInfoMap.has(viewerID),
         };
 
         result[reaction] = messageReactionInfo;
       }
 
       return result;
     })();
 
     if (isComposableMessageType(originalMessageInfo.type)) {
       // We use these invariants instead of just checking the messageInfo.type
       // directly in the conditional above so that isComposableMessageType can
       // be the source of truth
       invariant(
         originalMessageInfo.type === messageTypes.TEXT ||
           originalMessageInfo.type === messageTypes.IMAGES ||
           originalMessageInfo.type === messageTypes.MULTIMEDIA,
         "Flow doesn't understand isComposableMessageType above",
       );
       const localMessageInfo =
         messageStore.local[messageKey(originalMessageInfo)];
       chatMessageItems.push({
         itemType: 'message',
         messageInfoType: 'composable',
         messageInfo: originalMessageInfo,
         localMessageInfo,
         startsConversation,
         startsCluster,
         endsCluster: false,
         threadCreatedFromMessage,
         reactions: renderedReactions,
         hasBeenEdited,
         isPinned,
       });
     } else {
       invariant(
         originalMessageInfo.type !== messageTypes.TEXT &&
           originalMessageInfo.type !== messageTypes.IMAGES &&
           originalMessageInfo.type !== messageTypes.MULTIMEDIA,
         "Flow doesn't understand isComposableMessageType above",
       );
       const threadInfo = threadInfos[threadID];
       const parentThreadInfo = threadInfo?.parentThreadID
         ? threadInfos[threadInfo.parentThreadID]
         : null;
 
       const robotext = robotextForMessageInfo(
         originalMessageInfo,
         threadInfo,
         parentThreadInfo,
       );
       chatMessageItems.push({
         itemType: 'message',
         messageInfoType: 'robotext',
         messageInfo: originalMessageInfo,
         startsConversation,
         startsCluster,
         endsCluster: false,
         threadCreatedFromMessage,
         robotext,
         reactions: renderedReactions,
       });
     }
     lastMessageInfo = originalMessageInfo;
   }
   if (chatMessageItems.length > 0) {
     const lastMessageItem = chatMessageItems[chatMessageItems.length - 1];
     invariant(lastMessageItem.itemType === 'message', 'should be message');
     lastMessageItem.endsCluster = true;
   }
   chatMessageItems.reverse();
   const hideSpinner = thread ? thread.startReached : threadIsPending(threadID);
   if (hideSpinner) {
     return chatMessageItems;
   }
   return [...chatMessageItems, ({ itemType: 'loader' }: ChatMessageItem)];
 }
 
 const baseMessageListData = (
   threadID: ?string,
   additionalMessages: $ReadOnlyArray<MessageInfo>,
 ) =>
   createSelector(
     (state: BaseAppState<>) => state.messageStore,
     messageInfoSelector,
     threadInfoSelector,
     threadInfoFromSourceMessageIDSelector,
     (state: BaseAppState<>) =>
       state.currentUserInfo && state.currentUserInfo.id,
     (
       messageStore: MessageStore,
       messageInfos: { +[id: string]: ?MessageInfo },
       threadInfos: { +[id: string]: ThreadInfo },
       threadInfoFromSourceMessageID: { +[id: string]: ThreadInfo },
       viewerID: ?string,
     ): ?(ChatMessageItem[]) => {
       if (!threadID || !viewerID) {
         return null;
       }
       return createChatMessageItems(
         threadID,
         messageStore,
         messageInfos,
         threadInfos,
         threadInfoFromSourceMessageID,
         additionalMessages,
         viewerID,
       );
     },
   );
 export type MessageListData = ?(ChatMessageItem[]);
 const messageListData: (
   threadID: ?string,
   additionalMessages: $ReadOnlyArray<MessageInfo>,
 ) => (state: BaseAppState<>) => MessageListData = memoize2(baseMessageListData);
 
 export type UseMessageListDataArgs = {
   +searching: boolean,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
   +threadInfo: ?ThreadInfo | ?MinimallyEncodedThreadInfo,
 };
 
 function useMessageListData({
   searching,
   userInfoInputArray,
   threadInfo,
 }: UseMessageListDataArgs): MessageListData {
   const messageInfos = useSelector(messageInfoSelector);
 
   const containingThread = useSelector(state => {
     if (!threadInfo || threadInfo.type !== threadTypes.SIDEBAR) {
       return null;
     }
     return state.messageStore.threads[threadInfo.containingThreadID];
   });
 
   const pendingSidebarEditMessageInfo = React.useMemo(() => {
     const sourceMessageID = threadInfo?.sourceMessageID;
     const threadMessageInfos = (containingThread?.messageIDs ?? [])
       .map((messageID: string) => messageInfos[messageID])
       .filter(Boolean)
       .filter(
         message =>
           message.type === messageTypes.EDIT_MESSAGE &&
           message.targetMessageID === sourceMessageID,
       );
     if (threadMessageInfos.length === 0) {
       return null;
     }
     return threadMessageInfos[0];
   }, [threadInfo, containingThread, messageInfos]);
 
   const pendingSidebarSourceMessageInfo = useSelector(state => {
     const sourceMessageID = threadInfo?.sourceMessageID;
     if (
       !threadInfo ||
       threadInfo.type !== threadTypes.SIDEBAR ||
       !sourceMessageID
     ) {
       return null;
     }
     const thread = state.messageStore.threads[threadInfo.id];
     const shouldSourceBeAdded =
       !thread ||
       (thread.startReached &&
         thread.messageIDs.every(
           id => messageInfos[id]?.type !== messageTypes.SIDEBAR_SOURCE,
         ));
     return shouldSourceBeAdded ? messageInfos[sourceMessageID] : null;
   });
 
   invariant(
     !pendingSidebarSourceMessageInfo ||
       pendingSidebarSourceMessageInfo.type !== messageTypes.SIDEBAR_SOURCE,
     'sidebars can not be created from sidebar_source message',
   );
 
   const additionalMessages = React.useMemo(() => {
     if (!pendingSidebarSourceMessageInfo) {
       return [];
     }
     const result = [pendingSidebarSourceMessageInfo];
     if (pendingSidebarEditMessageInfo) {
       result.push(pendingSidebarEditMessageInfo);
     }
     return result;
   }, [pendingSidebarSourceMessageInfo, pendingSidebarEditMessageInfo]);
   const boundMessageListData = useSelector(
     messageListData(threadInfo?.id, additionalMessages),
   );
 
   return React.useMemo(() => {
     if (searching && userInfoInputArray.length === 0) {
       return [];
     }
     return boundMessageListData;
   }, [searching, userInfoInputArray.length, boundMessageListData]);
 }
 
 export {
   messageInfoSelector,
   createChatThreadItem,
   chatListData,
   createChatMessageItems,
   messageListData,
   useFlattenedChatListData,
   useFilteredChatListData,
   useMessageListData,
 };
diff --git a/lib/shared/lifecycle-utils.js b/lib/shared/lifecycle-utils.js
index 591f5222a..852cfcc50 100644
--- a/lib/shared/lifecycle-utils.js
+++ b/lib/shared/lifecycle-utils.js
@@ -1,15 +1,15 @@
 // @flow
 
-import { useSelector } from 'react-redux';
+import { useSelector } from '../utils/redux-utils.js';
 
 // Note: This hook mimics the prior state.foreground property
 // and considers `inactive` on iOS as equivalent to `active`
 function useIsAppForegrounded(): boolean {
   return useSelector(state => state.lifecycleState !== 'background');
 }
 
 function useIsAppBackgroundedOrInactive(): boolean {
   return useSelector(state => state.lifecycleState !== 'active');
 }
 
 export { useIsAppForegrounded, useIsAppBackgroundedOrInactive };
diff --git a/lib/shared/search-utils.js b/lib/shared/search-utils.js
index 4e7137ed4..cf597ad7a 100644
--- a/lib/shared/search-utils.js
+++ b/lib/shared/search-utils.js
@@ -1,347 +1,347 @@
 // @flow
 
 import * as React from 'react';
-import { useSelector } from 'react-redux';
 
 import SearchIndex from './search-index.js';
 import {
   userIsMember,
   threadMemberHasPermission,
   getContainingThreadID,
 } from './thread-utils.js';
 import {
   useSearchMessages as useSearchMessagesAction,
   searchMessagesActionTypes,
 } from '../actions/message-actions.js';
 import {
   searchUsers,
   searchUsersActionTypes,
 } from '../actions/user-actions.js';
 import genesis from '../facts/genesis.js';
 import type {
   ChatMessageInfoItem,
   MessageListData,
 } from '../selectors/chat-selectors';
 import type { MessageInfo, RawMessageInfo } from '../types/message-types';
 import { isComposableMessageType } from '../types/message-types.js';
 import type { MinimallyEncodedThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import { userRelationshipStatus } from '../types/relationship-types.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
 import { type ThreadType, threadTypes } from '../types/thread-types-enum.js';
 import { type ThreadInfo } from '../types/thread-types.js';
 import type {
   AccountUserInfo,
   UserListItem,
   GlobalAccountUserInfo,
 } from '../types/user-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from '../utils/action-utils.js';
 import { values } from '../utils/objects.js';
+import { useSelector } from '../utils/redux-utils.js';
 
 const notFriendNotice = 'not friend';
 
 function getPotentialMemberItems({
   text,
   userInfos,
   searchIndex,
   excludeUserIDs,
   includeServerSearchUsers,
   inputParentThreadInfo,
   inputCommunityThreadInfo,
   threadType,
 }: {
   +text: string,
   +userInfos: { +[id: string]: AccountUserInfo },
   +searchIndex: SearchIndex,
   +excludeUserIDs: $ReadOnlyArray<string>,
   +includeServerSearchUsers?: $ReadOnlyArray<GlobalAccountUserInfo>,
   +inputParentThreadInfo?: ?ThreadInfo | ?MinimallyEncodedThreadInfo,
   +inputCommunityThreadInfo?: ?ThreadInfo | ?MinimallyEncodedThreadInfo,
   +threadType?: ?ThreadType,
 }): UserListItem[] {
   const communityThreadInfo =
     inputCommunityThreadInfo && inputCommunityThreadInfo.id !== genesis.id
       ? inputCommunityThreadInfo
       : null;
   const parentThreadInfo =
     inputParentThreadInfo && inputParentThreadInfo.id !== genesis.id
       ? inputParentThreadInfo
       : null;
 
   const containgThreadID = threadType
     ? getContainingThreadID(parentThreadInfo, threadType)
     : null;
 
   let containingThreadInfo = null;
   if (containgThreadID === parentThreadInfo?.id) {
     containingThreadInfo = parentThreadInfo;
   } else if (containgThreadID === communityThreadInfo?.id) {
     containingThreadInfo = communityThreadInfo;
   }
 
   const results: {
     [id: string]: {
       ...AccountUserInfo | GlobalAccountUserInfo,
       isMemberOfParentThread: boolean,
       isMemberOfContainingThread: boolean,
     },
   } = {};
   const appendUserInfo = (
     userInfo: AccountUserInfo | GlobalAccountUserInfo,
   ) => {
     const { id } = userInfo;
     if (excludeUserIDs.includes(id) || id in results) {
       return;
     }
     if (
       communityThreadInfo &&
       !threadMemberHasPermission(
         communityThreadInfo,
         id,
         threadPermissions.KNOW_OF,
       )
     ) {
       return;
     }
     results[id] = {
       ...userInfo,
       isMemberOfParentThread: userIsMember(parentThreadInfo, id),
       isMemberOfContainingThread: userIsMember(containingThreadInfo, id),
     };
   };
   if (text === '') {
     for (const id in userInfos) {
       appendUserInfo(userInfos[id]);
     }
   } else {
     const ids = searchIndex.getSearchResults(text);
     for (const id of ids) {
       appendUserInfo(userInfos[id]);
     }
   }
 
   if (includeServerSearchUsers) {
     for (const userInfo of includeServerSearchUsers) {
       appendUserInfo(userInfo);
     }
   }
 
   const blockedRelationshipsStatuses = new Set([
     userRelationshipStatus.BLOCKED_BY_VIEWER,
     userRelationshipStatus.BLOCKED_VIEWER,
     userRelationshipStatus.BOTH_BLOCKED,
   ]);
 
   let userResults = values(results);
   if (text === '') {
     userResults = userResults.filter(userInfo =>
       containingThreadInfo
         ? userInfo.isMemberOfContainingThread &&
           !blockedRelationshipsStatuses.has(userInfo.relationshipStatus)
         : userInfo?.relationshipStatus === userRelationshipStatus.FRIEND,
     );
   }
 
   const nonFriends = [];
   const blockedUsers = [];
   const friends = [];
   const containingThreadMembers = [];
   const parentThreadMembers = [];
 
   for (const userResult of userResults) {
     const relationshipStatus = userResult.relationshipStatus;
     if (blockedRelationshipsStatuses.has(relationshipStatus)) {
       blockedUsers.push(userResult);
     } else if (userResult.isMemberOfParentThread) {
       parentThreadMembers.push(userResult);
     } else if (userResult.isMemberOfContainingThread) {
       containingThreadMembers.push(userResult);
     } else if (relationshipStatus === userRelationshipStatus.FRIEND) {
       friends.push(userResult);
     } else {
       nonFriends.push(userResult);
     }
   }
 
   const sortedResults = parentThreadMembers
     .concat(containingThreadMembers)
     .concat(friends)
     .concat(nonFriends)
     .concat(blockedUsers);
 
   return sortedResults.map(
     ({
       isMemberOfContainingThread,
       isMemberOfParentThread,
       relationshipStatus,
       ...result
     }) => {
       let notice, alert;
       const username = result.username;
       if (blockedRelationshipsStatuses.has(relationshipStatus)) {
         notice = 'user is blocked';
         alert = {
           title: 'User is blocked',
           text:
             `Before you add ${username} to this chat, ` +
             'you’ll need to unblock them. You can do this from the Block List ' +
             'in the Profile tab.',
         };
       } else if (!isMemberOfContainingThread && containingThreadInfo) {
         if (threadType !== threadTypes.SIDEBAR) {
           notice = 'not in community';
           alert = {
             title: 'Not in community',
             text: 'You can only add members of the community to this chat',
           };
         } else {
           notice = 'not in parent chat';
           alert = {
             title: 'Not in parent chat',
             text: 'You can only add members of the parent chat to a thread',
           };
         }
       } else if (
         !containingThreadInfo &&
         relationshipStatus !== userRelationshipStatus.FRIEND
       ) {
         notice = notFriendNotice;
         alert = {
           title: 'Not a friend',
           text:
             `Before you add ${username} to this chat, ` +
             'you’ll need to send them a friend request. ' +
             'You can do this from the Friend List in the Profile tab.',
         };
       } else if (parentThreadInfo && !isMemberOfParentThread) {
         notice = 'not in parent chat';
       }
       if (notice) {
         result = { ...result, notice };
       }
       if (alert) {
         result = { ...result, alert };
       }
       return result;
     },
   );
 }
 
 function useSearchMessages(): (
   query: string,
   threadID: string,
   onResultsReceived: (
     messages: $ReadOnlyArray<RawMessageInfo>,
     endReached: boolean,
     queryID: number,
     threadID: string,
   ) => mixed,
   queryID: number,
   cursor?: string,
 ) => void {
   const callSearchMessages = useSearchMessagesAction();
   const dispatchActionPromise = useDispatchActionPromise();
 
   return React.useCallback(
     (query, threadID, onResultsReceived, queryID, cursor) => {
       const searchMessagesPromise = (async () => {
         if (query === '') {
           onResultsReceived([], true, queryID, threadID);
           return;
         }
         const { messages, endReached } = await callSearchMessages({
           query,
           threadID,
           cursor,
         });
         onResultsReceived(messages, endReached, queryID, threadID);
       })();
 
       dispatchActionPromise(searchMessagesActionTypes, searchMessagesPromise);
     },
     [callSearchMessages, dispatchActionPromise],
   );
 }
 
 function useSearchUsers(
   usernameInputText: string,
 ): $ReadOnlyArray<GlobalAccountUserInfo> {
   const currentUserID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
 
   const [serverSearchResults, setServerSearchResults] = React.useState<
     $ReadOnlyArray<GlobalAccountUserInfo>,
   >([]);
   const callSearchUsers = useServerCall(searchUsers);
   const dispatchActionPromise = useDispatchActionPromise();
   React.useEffect(() => {
     const searchUsersPromise = (async () => {
       if (usernameInputText.length === 0) {
         setServerSearchResults([]);
       } else {
         try {
           const { userInfos } = await callSearchUsers(usernameInputText);
           setServerSearchResults(
             userInfos.filter(({ id }) => id !== currentUserID),
           );
         } catch (err) {
           setServerSearchResults([]);
         }
       }
     })();
     dispatchActionPromise(searchUsersActionTypes, searchUsersPromise);
   }, [
     callSearchUsers,
     currentUserID,
     dispatchActionPromise,
     usernameInputText,
   ]);
 
   return serverSearchResults;
 }
 
 function filterChatMessageInfosForSearch(
   chatMessageInfos: MessageListData,
   translatedSearchResults: $ReadOnlyArray<MessageInfo>,
 ): ?(ChatMessageInfoItem[]) {
   if (!chatMessageInfos) {
     return null;
   }
 
   const idSet = new Set(translatedSearchResults.map(item => item.id));
 
   const chatMessageInfoItems = chatMessageInfos.filter(
     item =>
       item.messageInfo &&
       idSet.has(item.messageInfo.id) &&
       isComposableMessageType(item.messageInfo.type),
   );
 
   const uniqueChatMessageInfoItemsMap = new Map();
   chatMessageInfoItems.forEach(
     item =>
       item.messageInfo &&
       item.messageInfo.id &&
       uniqueChatMessageInfoItemsMap.set(item.messageInfo.id, item),
   );
 
   const sortedChatMessageInfoItems = [];
   for (let i = 0; i < translatedSearchResults.length; i++) {
     sortedChatMessageInfoItems.push(
       uniqueChatMessageInfoItemsMap.get(translatedSearchResults[i].id),
     );
   }
 
   return sortedChatMessageInfoItems.filter(Boolean);
 }
 
 export {
   getPotentialMemberItems,
   notFriendNotice,
   useSearchMessages,
   useSearchUsers,
   filterChatMessageInfosForSearch,
 };
diff --git a/lib/socket/activity-handler.react.js b/lib/socket/activity-handler.react.js
index 2e8ed2623..fa61e227c 100644
--- a/lib/socket/activity-handler.react.js
+++ b/lib/socket/activity-handler.react.js
@@ -1,134 +1,133 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
-import { useDispatch } from 'react-redux';
 
 import {
   updateActivityActionTypes,
   useUpdateActivity,
 } from '../actions/activity-actions.js';
 import { connectionSelector } from '../selectors/keyserver-selectors.js';
 import { getMostRecentNonLocalMessageID } from '../shared/message-utils.js';
 import { threadIsPending } from '../shared/thread-utils.js';
 import { queueActivityUpdatesActionType } from '../types/activity-types.js';
 import type { ConnectionStatus } from '../types/socket-types.js';
 import { useDispatchActionPromise } from '../utils/action-utils.js';
-import { useSelector } from '../utils/redux-utils.js';
+import { useSelector, useDispatch } from '../utils/redux-utils.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 type Props = {
   +activeThread: ?string,
   +frozen: boolean,
 };
 function ActivityHandler(props: Props): React.Node {
   const { activeThread, frozen } = props;
 
   const prevActiveThreadRef = React.useRef<?string>();
   React.useEffect(() => {
     prevActiveThreadRef.current = activeThread;
   }, [activeThread]);
   const prevActiveThread = prevActiveThreadRef.current;
 
   const connection = useSelector(connectionSelector(ashoatKeyserverID));
   invariant(connection, 'keyserver missing from keyserverStore');
   const connectionStatus = connection.status;
   const prevConnectionStatusRef = React.useRef<?ConnectionStatus>();
   React.useEffect(() => {
     prevConnectionStatusRef.current = connectionStatus;
   }, [connectionStatus]);
   const prevConnectionStatus = prevConnectionStatusRef.current;
 
   const activeThreadLatestMessage = useSelector(state => {
     if (!activeThread) {
       return undefined;
     }
     return getMostRecentNonLocalMessageID(activeThread, state.messageStore);
   });
   const prevActiveThreadLatestMessageRef = React.useRef<?string>();
   React.useEffect(() => {
     prevActiveThreadLatestMessageRef.current = activeThreadLatestMessage;
   }, [activeThreadLatestMessage]);
   const prevActiveThreadLatestMessage =
     prevActiveThreadLatestMessageRef.current;
 
   const canSend = connectionStatus === 'connected' && !frozen;
   const prevCanSendRef = React.useRef<?boolean>();
   React.useEffect(() => {
     prevCanSendRef.current = canSend;
   }, [canSend]);
   const prevCanSend = prevCanSendRef.current;
 
   const dispatch = useDispatch();
   const dispatchActionPromise = useDispatchActionPromise();
   const callUpdateActivity = useUpdateActivity();
 
   React.useEffect(() => {
     const activityUpdates = [];
     const isActiveThreadPending = threadIsPending(activeThread);
 
     if (activeThread !== prevActiveThread) {
       const isPrevActiveThreadPending = threadIsPending(prevActiveThread);
 
       if (prevActiveThread && !isPrevActiveThreadPending) {
         activityUpdates.push({
           focus: false,
           threadID: prevActiveThread,
           latestMessage: prevActiveThreadLatestMessage,
         });
       }
       if (activeThread && !isActiveThreadPending) {
         activityUpdates.push({
           focus: true,
           threadID: activeThread,
           latestMessage: activeThreadLatestMessage,
         });
       }
     }
 
     if (
       !frozen &&
       connectionStatus !== 'connected' &&
       prevConnectionStatus === 'connected' &&
       activeThread &&
       !isActiveThreadPending
     ) {
       // When the server closes a socket it also deletes any activity rows
       // associated with that socket's session. If that activity is still
       // ongoing, we should make sure that we clarify that with the server once
       // we reconnect.
       activityUpdates.push({
         focus: true,
         threadID: activeThread,
         latestMessage: activeThreadLatestMessage,
       });
     }
 
     if (activityUpdates.length > 0) {
       dispatch({
         type: queueActivityUpdatesActionType,
         payload: { activityUpdates, keyserverID: ashoatKeyserverID },
       });
     }
 
     if (!canSend) {
       return;
     }
 
     if (!prevCanSend) {
       activityUpdates.unshift(...connection.queuedActivityUpdates);
     }
 
     if (activityUpdates.length === 0) {
       return;
     }
     dispatchActionPromise(
       updateActivityActionTypes,
       callUpdateActivity({ activityUpdates }),
     );
   });
 
   return null;
 }
 
 export default ActivityHandler;
diff --git a/lib/socket/message-handler.react.js b/lib/socket/message-handler.react.js
index 69336ad4a..7add19ca7 100644
--- a/lib/socket/message-handler.react.js
+++ b/lib/socket/message-handler.react.js
@@ -1,41 +1,41 @@
 // @flow
 
 import * as React from 'react';
-import { useDispatch } from 'react-redux';
 
 import { processMessagesActionType } from '../actions/message-actions.js';
 import {
   type ClientServerSocketMessage,
   serverSocketMessageTypes,
   type SocketListener,
 } from '../types/socket-types.js';
+import { useDispatch } from '../utils/redux-utils.js';
 
 type Props = {
   +addListener: (listener: SocketListener) => void,
   +removeListener: (listener: SocketListener) => void,
 };
 export default function MessageHandler(props: Props): React.Node {
   const { addListener, removeListener } = props;
 
   const dispatch = useDispatch();
   const onMessage = React.useCallback(
     (message: ClientServerSocketMessage) => {
       if (message.type !== serverSocketMessageTypes.MESSAGES) {
         return;
       }
       dispatch({
         type: processMessagesActionType,
         payload: message.payload,
       });
     },
     [dispatch],
   );
   React.useEffect(() => {
     addListener(onMessage);
     return () => {
       removeListener(onMessage);
     };
   }, [addListener, removeListener, onMessage]);
 
   return null;
 }
diff --git a/lib/socket/request-response-handler.react.js b/lib/socket/request-response-handler.react.js
index 98acf8d14..063a8aa77 100644
--- a/lib/socket/request-response-handler.react.js
+++ b/lib/socket/request-response-handler.react.js
@@ -1,154 +1,153 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
-import { useDispatch } from 'react-redux';
 
 import { InflightRequests } from './inflight-requests.js';
 import { connectionSelector } from '../selectors/keyserver-selectors.js';
 import type { CalendarQuery } from '../types/entry-types.js';
 import type { Dispatch } from '../types/redux-types.js';
 import {
   processServerRequestsActionType,
   type ClientClientResponse,
   type ClientServerRequest,
 } from '../types/request-types.js';
 import {
   type ClientRequestsServerSocketMessage,
   type ClientServerSocketMessage,
   clientSocketMessageTypes,
   serverSocketMessageTypes,
   type ClientSocketMessageWithoutID,
   type SocketListener,
   type ConnectionInfo,
 } from '../types/socket-types.js';
 import { ServerError, SocketTimeout } from '../utils/errors.js';
-import { useSelector } from '../utils/redux-utils.js';
+import { useSelector, useDispatch } from '../utils/redux-utils.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 type BaseProps = {
   +inflightRequests: ?InflightRequests,
   +sendMessage: (message: ClientSocketMessageWithoutID) => number,
   +addListener: (listener: SocketListener) => void,
   +removeListener: (listener: SocketListener) => void,
   +getClientResponses: (
     activeServerRequests: $ReadOnlyArray<ClientServerRequest>,
   ) => Promise<$ReadOnlyArray<ClientClientResponse>>,
   +currentCalendarQuery: () => CalendarQuery,
 };
 type Props = {
   ...BaseProps,
   +connection: ConnectionInfo,
   +dispatch: Dispatch,
 };
 class RequestResponseHandler extends React.PureComponent<Props> {
   componentDidMount() {
     this.props.addListener(this.onMessage);
   }
 
   componentWillUnmount() {
     this.props.removeListener(this.onMessage);
   }
 
   render() {
     return null;
   }
 
   onMessage = (message: ClientServerSocketMessage) => {
     if (message.type !== serverSocketMessageTypes.REQUESTS) {
       return;
     }
     const { serverRequests } = message.payload;
     if (serverRequests.length === 0) {
       return;
     }
     const calendarQuery = this.props.currentCalendarQuery();
     this.props.dispatch({
       type: processServerRequestsActionType,
       payload: {
         serverRequests,
         calendarQuery,
       },
     });
     if (this.props.inflightRequests) {
       const clientResponsesPromise =
         this.props.getClientResponses(serverRequests);
       this.sendAndHandleClientResponsesToServerRequests(clientResponsesPromise);
     }
   };
 
   sendClientResponses(
     clientResponses: $ReadOnlyArray<ClientClientResponse>,
   ): Promise<ClientRequestsServerSocketMessage> {
     const { inflightRequests } = this.props;
     invariant(
       inflightRequests,
       'inflightRequests falsey inside sendClientResponses',
     );
     const messageID = this.props.sendMessage({
       type: clientSocketMessageTypes.RESPONSES,
       payload: { clientResponses },
     });
     return inflightRequests.fetchResponse(
       messageID,
       serverSocketMessageTypes.REQUESTS,
     );
   }
 
   async sendAndHandleClientResponsesToServerRequests(
     clientResponsesPromise: Promise<$ReadOnlyArray<ClientClientResponse>>,
   ) {
     const clientResponses = await clientResponsesPromise;
     if (clientResponses.length === 0) {
       return;
     }
     const promise = this.sendClientResponses(clientResponses);
     this.handleClientResponsesToServerRequests(promise, clientResponses);
   }
 
   async handleClientResponsesToServerRequests(
     promise: Promise<ClientRequestsServerSocketMessage>,
     clientResponses: $ReadOnlyArray<ClientClientResponse>,
     retriesLeft: number = 1,
   ): Promise<void> {
     try {
       await promise;
     } catch (e) {
       console.log(e);
       if (
         !(e instanceof SocketTimeout) &&
         (!(e instanceof ServerError) || e.message === 'unknown_error') &&
         retriesLeft > 0 &&
         this.props.connection.status === 'connected' &&
         this.props.inflightRequests
       ) {
         // We'll only retry if the connection is healthy and the error is either
         // an unknown_error ServerError or something is neither a ServerError
         // nor a SocketTimeout.
         const newPromise = this.sendClientResponses(clientResponses);
         await this.handleClientResponsesToServerRequests(
           newPromise,
           clientResponses,
           retriesLeft - 1,
         );
       }
     }
   }
 }
 
 const ConnectedRequestResponseHandler: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedRequestResponseHandler(props) {
     const connection = useSelector(connectionSelector(ashoatKeyserverID));
     invariant(connection, 'keyserver missing from keyserverStore');
 
     const dispatch = useDispatch();
 
     return (
       <RequestResponseHandler
         {...props}
         connection={connection}
         dispatch={dispatch}
       />
     );
   });
 export default ConnectedRequestResponseHandler;
diff --git a/lib/socket/update-handler.react.js b/lib/socket/update-handler.react.js
index 7f5c602a6..52472d983 100644
--- a/lib/socket/update-handler.react.js
+++ b/lib/socket/update-handler.react.js
@@ -1,62 +1,61 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { useEffect } from 'react';
-import { useDispatch } from 'react-redux';
 
 import { connectionSelector } from '../selectors/keyserver-selectors.js';
 import {
   type ClientSocketMessageWithoutID,
   type SocketListener,
   type ClientServerSocketMessage,
   serverSocketMessageTypes,
   clientSocketMessageTypes,
 } from '../types/socket-types.js';
 import { processUpdatesActionType } from '../types/update-types.js';
-import { useSelector } from '../utils/redux-utils.js';
+import { useSelector, useDispatch } from '../utils/redux-utils.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 type Props = {
   +sendMessage: (message: ClientSocketMessageWithoutID) => number,
   +addListener: (listener: SocketListener) => void,
   +removeListener: (listener: SocketListener) => void,
   +keyserverID: string,
 };
 export default function UpdateHandler(props: Props): React.Node {
   const { addListener, removeListener, sendMessage, keyserverID } = props;
 
   const dispatch = useDispatch();
   const connection = useSelector(connectionSelector(ashoatKeyserverID));
   invariant(connection, 'keyserver missing from keyserverStore');
   const connectionStatus = connection.status;
   const onMessage = React.useCallback(
     (message: ClientServerSocketMessage) => {
       if (message.type !== serverSocketMessageTypes.UPDATES) {
         return;
       }
       dispatch({
         type: processUpdatesActionType,
         payload: { ...message.payload, keyserverID },
       });
       if (connectionStatus !== 'connected') {
         return;
       }
       sendMessage({
         type: clientSocketMessageTypes.ACK_UPDATES,
         payload: {
           currentAsOf: message.payload.updatesResult.currentAsOf,
         },
       });
     },
     [connectionStatus, dispatch, keyserverID, sendMessage],
   );
   useEffect(() => {
     addListener(onMessage);
     return () => {
       removeListener(onMessage);
     };
   }, [addListener, removeListener, onMessage]);
 
   return null;
 }
diff --git a/lib/utils/action-utils.js b/lib/utils/action-utils.js
index 49f446e16..8f2db44dc 100644
--- a/lib/utils/action-utils.js
+++ b/lib/utils/action-utils.js
@@ -1,587 +1,587 @@
 // @flow
 
 import invariant from 'invariant';
 import _memoize from 'lodash/memoize.js';
 import * as React from 'react';
-import { useSelector, useDispatch } from 'react-redux';
 import { createSelector } from 'reselect';
 
 import callServerEndpoint from './call-server-endpoint.js';
 import type {
   CallServerEndpoint,
   CallServerEndpointOptions,
 } from './call-server-endpoint.js';
 import { getConfig } from './config.js';
 import { promiseAll } from './promises.js';
+import { useSelector, useDispatch } from './redux-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 { LoadingOptions, LoadingInfo } from '../types/loading-types.js';
 import type {
   ActionPayload,
   Dispatch,
   PromisedAction,
   BaseAction,
 } from '../types/redux-types.js';
 import type {
   ClientSessionChange,
   PreRequestUserState,
 } from '../types/session-types.js';
 import type { ConnectionStatus } from '../types/socket-types.js';
 import type { CurrentUserInfo } from '../types/user-types.js';
 
 function extractKeyserverIDFromID(id: string): string {
   return id.split('|')[0];
 }
 
 let nextPromiseIndex = 0;
 
 export type ActionTypes<
   STARTED_ACTION_TYPE: string,
   SUCCESS_ACTION_TYPE: string,
   FAILED_ACTION_TYPE: string,
 > = {
   started: STARTED_ACTION_TYPE,
   success: SUCCESS_ACTION_TYPE,
   failed: FAILED_ACTION_TYPE,
 };
 
 function wrapActionPromise<
   STARTED_ACTION_TYPE: string,
   STARTED_PAYLOAD: ActionPayload,
   SUCCESS_ACTION_TYPE: string,
   SUCCESS_PAYLOAD: ActionPayload,
   FAILED_ACTION_TYPE: string,
 >(
   actionTypes: ActionTypes<
     STARTED_ACTION_TYPE,
     SUCCESS_ACTION_TYPE,
     FAILED_ACTION_TYPE,
   >,
   promise: Promise<SUCCESS_PAYLOAD>,
   loadingOptions: ?LoadingOptions,
   startingPayload: ?STARTED_PAYLOAD,
 ): PromisedAction {
   const loadingInfo: LoadingInfo = {
     fetchIndex: nextPromiseIndex++,
     trackMultipleRequests: !!loadingOptions?.trackMultipleRequests,
     customKeyName: loadingOptions?.customKeyName || null,
   };
   return async (dispatch: Dispatch): Promise<void> => {
     const startAction = startingPayload
       ? {
           type: (actionTypes.started: STARTED_ACTION_TYPE),
           loadingInfo,
           payload: (startingPayload: STARTED_PAYLOAD),
         }
       : {
           type: (actionTypes.started: STARTED_ACTION_TYPE),
           loadingInfo,
         };
     dispatch(startAction);
     try {
       const result = await promise;
       dispatch({
         type: (actionTypes.success: SUCCESS_ACTION_TYPE),
         payload: (result: SUCCESS_PAYLOAD),
         loadingInfo,
       });
     } catch (e) {
       console.log(e);
       dispatch({
         type: (actionTypes.failed: FAILED_ACTION_TYPE),
         error: true,
         payload: (e: Error),
         loadingInfo,
       });
     }
   };
 }
 
 export type DispatchActionPromise = <
   STARTED: BaseAction,
   SUCCESS: BaseAction,
   FAILED: BaseAction,
 >(
   actionTypes: ActionTypes<
     $PropertyType<STARTED, 'type'>,
     $PropertyType<SUCCESS, 'type'>,
     $PropertyType<FAILED, 'type'>,
   >,
   promise: Promise<$PropertyType<SUCCESS, 'payload'>>,
   loadingOptions?: LoadingOptions,
   startingPayload?: $PropertyType<STARTED, 'payload'>,
 ) => Promise<void>;
 
 function useDispatchActionPromise(): DispatchActionPromise {
   const dispatch = useDispatch();
   return React.useMemo(() => createDispatchActionPromise(dispatch), [dispatch]);
 }
 
 function createDispatchActionPromise(dispatch: Dispatch) {
   const dispatchActionPromise = function <
     STARTED: BaseAction,
     SUCCESS: BaseAction,
     FAILED: BaseAction,
   >(
     actionTypes: ActionTypes<
       $PropertyType<STARTED, 'type'>,
       $PropertyType<SUCCESS, 'type'>,
       $PropertyType<FAILED, 'type'>,
     >,
     promise: Promise<$PropertyType<SUCCESS, 'payload'>>,
     loadingOptions?: LoadingOptions,
     startingPayload?: $PropertyType<STARTED, 'payload'>,
   ): Promise<void> {
     return dispatch(
       wrapActionPromise(actionTypes, promise, loadingOptions, startingPayload),
     );
   };
   return dispatchActionPromise;
 }
 
 export type DispatchFunctions = {
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
 };
 
 let currentlyWaitingForNewCookie = false;
 let serverEndpointCallsWaitingForNewCookie: ((
   callServerEndpoint: ?CallServerEndpoint,
 ) => void)[] = [];
 
 export type DispatchRecoveryAttempt = (
   actionTypes: ActionTypes<'LOG_IN_STARTED', 'LOG_IN_SUCCESS', 'LOG_IN_FAILED'>,
   promise: Promise<LogInResult>,
   startingPayload: LogInStartingPayload,
 ) => Promise<boolean>;
 
 const setNewSessionActionType = 'SET_NEW_SESSION';
 function setNewSession(
   dispatch: Dispatch,
   sessionChange: ClientSessionChange,
   preRequestUserState: ?PreRequestUserState,
   error: ?string,
   logInActionSource: ?LogInActionSource,
   keyserverID: string,
 ) {
   dispatch({
     type: setNewSessionActionType,
     payload: {
       sessionChange,
       preRequestUserState,
       error,
       logInActionSource,
       keyserverID,
     },
   });
 }
 
 // This function calls resolveInvalidatedCookie, which dispatchs a log in action
 // using the native credentials. Note that we never actually specify a sessionID
 // here, on the assumption that only native clients will call this. (Native
 // clients don't specify a sessionID, indicating to the server that it should
 // use the cookieID as the sessionID.)
 async function fetchNewCookieFromNativeCredentials(
   dispatch: Dispatch,
   cookie: ?string,
   urlPrefix: string,
   logInActionSource: LogInActionSource,
   keyserverID: string,
   getInitialNotificationsEncryptedMessage?: () => Promise<string>,
 ): Promise<?ClientSessionChange> {
   const resolveInvalidatedCookie = getConfig().resolveInvalidatedCookie;
   if (!resolveInvalidatedCookie) {
     return null;
   }
   let newSessionChange = null;
   let callServerEndpointCallback = null;
   const boundCallServerEndpoint = async (
     endpoint: Endpoint,
     data: { +[key: string]: mixed },
     options?: ?CallServerEndpointOptions,
   ) => {
     const innerBoundSetNewSession = (
       sessionChange: ClientSessionChange,
       error: ?string,
     ) => {
       newSessionChange = sessionChange;
       setNewSession(
         dispatch,
         sessionChange,
         null,
         error,
         logInActionSource,
         keyserverID,
       );
     };
     try {
       const result = await callServerEndpoint(
         cookie,
         innerBoundSetNewSession,
         () => new Promise(r => r(null)),
         () => new Promise(r => r(null)),
         urlPrefix,
         null,
         'disconnected',
         null,
         null,
         endpoint,
         data,
         dispatch,
         options,
         false,
         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 };
     dispatch(wrapActionPromise(actionTypes, promise, null, startingPayload));
     return new Promise(r => (callServerEndpointCallback = r));
   };
   await resolveInvalidatedCookie(
     boundCallServerEndpoint,
     boundCallKeyserverEndpoint,
     dispatchRecoveryAttempt,
     logInActionSource,
     keyserverID,
     getInitialNotificationsEncryptedMessage,
   );
   return newSessionChange;
 }
 
 // Third param is optional and gets called with newCookie if we get a new cookie
 // Necessary to propagate cookie in cookieInvalidationRecovery below
 function bindCookieAndUtilsIntoCallServerEndpoint(
   params: BindServerCallsParams,
 ): CallServerEndpoint {
   const {
     dispatch,
     cookie,
     urlPrefix,
     sessionID,
     currentUserInfo,
     connectionStatus,
     lastCommunicatedPlatformDetails,
     keyserverID,
   } = params;
   const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true);
   const boundSetNewSession = (
     sessionChange: ClientSessionChange,
     error: ?string,
   ) =>
     setNewSession(
       dispatch,
       sessionChange,
       {
         currentUserInfo,
         cookiesAndSessions: { [keyserverID]: { cookie, sessionID } },
       },
       error,
       undefined,
       keyserverID,
     );
   // This function gets called before callServerEndpoint sends a request,
   // to make sure that we're not in the middle of trying to recover
   // an invalidated cookie
   const waitIfCookieInvalidated = () => {
     if (!getConfig().resolveInvalidatedCookie) {
       // If there is no resolveInvalidatedCookie function, just let the caller
       // callServerEndpoint instance continue
       return Promise.resolve(null);
     }
     if (!currentlyWaitingForNewCookie) {
       // Our cookie seems to be valid
       return Promise.resolve(null);
     }
     // Wait to run until we get our new cookie
     return new Promise(r => serverEndpointCallsWaitingForNewCookie.push(r));
   };
   // This function is a helper for the next function defined below
   const attemptToResolveInvalidation = async (
     sessionChange: ClientSessionChange,
   ) => {
     const newAnonymousCookie = sessionChange.cookie;
     const newSessionChange = await fetchNewCookieFromNativeCredentials(
       dispatch,
       newAnonymousCookie,
       urlPrefix,
       logInActionSources.cookieInvalidationResolutionAttempt,
       keyserverID,
     );
 
     currentlyWaitingForNewCookie = false;
     const currentWaitingCalls = serverEndpointCallsWaitingForNewCookie;
     serverEndpointCallsWaitingForNewCookie = [];
 
     const newCallServerEndpoint = newSessionChange
       ? bindCookieAndUtilsIntoCallServerEndpoint({
           ...params,
           cookie: newSessionChange.cookie,
           sessionID: newSessionChange.sessionID,
           currentUserInfo: newSessionChange.currentUserInfo,
         })
       : null;
     for (const func of currentWaitingCalls) {
       func(newCallServerEndpoint);
     }
     return newCallServerEndpoint;
   };
   // If this function is called, callServerEndpoint got a response invalidating
   // its cookie, and is wondering if it should just like... give up?
   // Or if there's a chance at redemption
   const cookieInvalidationRecovery = (sessionChange: ClientSessionChange) => {
     if (!getConfig().resolveInvalidatedCookie) {
       // If there is no resolveInvalidatedCookie function, just let the caller
       // callServerEndpoint instance continue
       return Promise.resolve(null);
     }
     if (!loggedIn) {
       // We don't want to attempt any use native credentials of a logged out
       // user to log-in after a cookieInvalidation while logged out
       return Promise.resolve(null);
     }
     if (currentlyWaitingForNewCookie) {
       return new Promise(r => serverEndpointCallsWaitingForNewCookie.push(r));
     }
     currentlyWaitingForNewCookie = true;
     return attemptToResolveInvalidation(sessionChange);
   };
 
   return (
     endpoint: Endpoint,
     data: Object,
     options?: ?CallServerEndpointOptions,
   ) =>
     callServerEndpoint(
       cookie,
       boundSetNewSession,
       waitIfCookieInvalidated,
       cookieInvalidationRecovery,
       urlPrefix,
       sessionID,
       connectionStatus,
       lastCommunicatedPlatformDetails,
       socketAPIHandler,
       endpoint,
       data,
       dispatch,
       options,
       loggedIn,
       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,
   +connectionStatus: ConnectionStatus,
   +lastCommunicatedPlatformDetails: ?PlatformDetails,
   +keyserverID: string,
 };
 
 // All server calls needs to include some information from the Redux state
 // (namely, the cookie). This information is used deep in the server call,
 // at the point where callServerEndpoint is called. We don't want to bother
 // propagating the cookie (and any future config info that callServerEndpoint
 // needs) through to the server calls so they can pass it to callServerEndpoint.
 // Instead, we "curry" the cookie onto callServerEndpoint within react-redux's
 // connect's mapStateToProps function, and then pass that "bound"
 // callServerEndpoint that no longer needs the cookie as a parameter on to
 // the server call.
 const baseCreateBoundServerCallsSelector = <F>(
   actionFunc: ActionFunc<F>,
 ): (BindServerCallsParams => F) =>
   createSelector(
     (state: BindServerCallsParams) => state.dispatch,
     (state: BindServerCallsParams) => state.cookie,
     (state: BindServerCallsParams) => state.urlPrefix,
     (state: BindServerCallsParams) => state.sessionID,
     (state: BindServerCallsParams) => state.currentUserInfo,
     (state: BindServerCallsParams) => state.connectionStatus,
     (state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
     (state: BindServerCallsParams) => state.keyserverID,
     (
       dispatch: Dispatch,
       cookie: ?string,
       urlPrefix: string,
       sessionID: ?string,
       currentUserInfo: ?CurrentUserInfo,
       connectionStatus: ConnectionStatus,
       lastCommunicatedPlatformDetails: ?PlatformDetails,
       keyserverID: string,
     ) => {
       const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({
         dispatch,
         cookie,
         urlPrefix,
         sessionID,
         currentUserInfo,
         connectionStatus,
         lastCommunicatedPlatformDetails,
         keyserverID,
       });
       return actionFunc(boundCallServerEndpoint);
     },
   );
 
 type CreateBoundServerCallsSelectorType = <F>(
   ActionFunc<F>,
 ) => BindServerCallsParams => F;
 const createBoundServerCallsSelector: CreateBoundServerCallsSelectorType =
   (_memoize(baseCreateBoundServerCallsSelector): any);
 
 function useServerCall<F>(
   serverCall: ActionFunc<F>,
   paramOverride?: ?$Shape<BindServerCallsParams>,
 ): F {
   const dispatch = useDispatch();
   const serverCallState = useSelector(
     serverCallStateSelector(ashoatKeyserverID),
   );
   return React.useMemo(() => {
     const { urlPrefix, connectionStatus } = serverCallState;
     invariant(
       !!urlPrefix && !!connectionStatus,
       'keyserver missing from keyserverStore',
     );
 
     return createBoundServerCallsSelector(serverCall)({
       ...serverCallState,
       urlPrefix,
       connectionStatus,
       dispatch,
       ...paramOverride,
       keyserverID: ashoatKeyserverID,
     });
   }, [serverCall, serverCallState, dispatch, paramOverride]);
 }
 
 let socketAPIHandler: ?SocketAPIHandler = null;
 function registerActiveSocket(passedSocketAPIHandler: ?SocketAPIHandler) {
   socketAPIHandler = passedSocketAPIHandler;
 }
 
 function sortThreadIDsPerKeyserver(threadIDs: $ReadOnlyArray<string>): {
   +[keyserverID: string]: $ReadOnlyArray<string>,
 } {
   const results = {};
   for (const threadID of threadIDs) {
     const keyserverID = extractKeyserverIDFromID(threadID);
     invariant(keyserverID, 'keyserver data missing from thread id');
     if (results[keyserverID] === undefined) {
       results[keyserverID] = [];
     }
     results[keyserverID].push(threadID);
   }
   return results;
 }
 
 function sortCalendarQueryPerKeyserver(
   calendarQuery: CalendarQuery,
   keyserverIDs: $ReadOnlyArray<string>,
 ): {
   +[keyserverID: string]: CalendarQuery,
 } {
   const { startDate, endDate, filters } = calendarQuery;
   const results = {};
 
   for (const keyserverID of keyserverIDs) {
     results[keyserverID] = {
       startDate,
       endDate,
       filters: [],
     };
   }
 
   for (const filter of filters) {
     if (filter.type === 'not_deleted') {
       for (const keyserverID in results) {
         results[keyserverID].filters.push({ type: 'not_deleted' });
       }
     } else if (filter.type === 'threads') {
       for (const threadID of filter.threadIDs) {
         const keyserverID = extractKeyserverIDFromID(threadID);
         if (results[keyserverID] === undefined) {
           continue;
         }
         let threadFilter = results[keyserverID].filters.find(
           flt => flt.type === 'threads',
         );
         if (!threadFilter) {
           threadFilter = { type: 'threads', threadIDs: [] };
           results[keyserverID].filters.push(threadFilter);
         }
 
         threadFilter.threadIDs.push(threadID);
       }
     } else {
       console.warn('unhandled filter in sortCalendarQueryPerKeyserver');
     }
   }
 
   return results;
 }
 
 export {
   useDispatchActionPromise,
   setNewSessionActionType,
   fetchNewCookieFromNativeCredentials,
   createBoundServerCallsSelector,
   registerActiveSocket,
   useServerCall,
   bindCookieAndUtilsIntoCallServerEndpoint,
   extractKeyserverIDFromID,
   sortThreadIDsPerKeyserver,
   sortCalendarQueryPerKeyserver,
 };
diff --git a/lib/utils/redux-utils.js b/lib/utils/redux-utils.js
index dcdffd23e..3694660f3 100644
--- a/lib/utils/redux-utils.js
+++ b/lib/utils/redux-utils.js
@@ -1,14 +1,21 @@
 // @flow
 
-import { useSelector as reactReduxUseSelector } from 'react-redux';
+import {
+  useSelector as reactReduxUseSelector,
+  useDispatch as reactReduxUseDispatch,
+} from 'react-redux';
 
-import type { AppState } from '../types/redux-types.js';
+import type { AppState, Dispatch } from '../types/redux-types.js';
 
 function useSelector<SS>(
   selector: (state: AppState) => SS,
   equalityFn?: (a: SS, b: SS) => boolean,
 ): SS {
   return reactReduxUseSelector(selector, equalityFn);
 }
 
-export { useSelector };
+function useDispatch(): Dispatch {
+  return reactReduxUseDispatch<Dispatch>();
+}
+
+export { useSelector, useDispatch };