diff --git a/landing/keyservers.react.js b/landing/keyservers.react.js
index 960334ce3..0d86ef559 100644
--- a/landing/keyservers.react.js
+++ b/landing/keyservers.react.js
@@ -1,165 +1,165 @@
 // @flow
 
 import { create } from '@lottiefiles/lottie-interactivity';
 import classNames from 'classnames';
 import * as React from 'react';
 
 import { useIsomorphicLayoutEffect } from 'lib/hooks/isomorphic-layout-effect.react.js';
 
 import { assetsCacheURLPrefix } from './asset-meta-data.js';
 import KeyserverFAQ from './keyserver-faq.react.js';
 import css from './keyservers.css';
 import ReadDocsButton from './read-docs-btn.react.js';
 import RequestAccess from './request-access.react.js';
 import typography from './typography.css';
 
 function Keyservers(): React.Node {
   React.useEffect(() => {
-    import('@lottiefiles/lottie-player');
+    void import('@lottiefiles/lottie-player');
   }, []);
 
   const onEyeIllustrationLoad = React.useCallback(() => {
     create({
       mode: 'scroll',
       player: '#eye-illustration',
       actions: [
         {
           visibility: [0, 1],
           type: 'seek',
           frames: [0, 720],
         },
       ],
     });
   }, []);
 
   const onCloudIllustrationLoad = React.useCallback(() => {
     create({
       mode: 'scroll',
       player: '#cloud-illustration',
       actions: [
         {
           visibility: [0, 0.2],
           type: 'stop',
           frames: [0],
         },
         {
           visibility: [0.2, 1],
           type: 'seek',
           frames: [0, 300],
         },
       ],
     });
   }, []);
 
   const [eyeNode, setEyeNode] = React.useState<?HTMLElement>(null);
   useIsomorphicLayoutEffect(() => {
     if (!eyeNode) {
       return undefined;
     }
     eyeNode.addEventListener('load', onEyeIllustrationLoad);
     return () => eyeNode.removeEventListener('load', onEyeIllustrationLoad);
   }, [eyeNode, onEyeIllustrationLoad]);
 
   const [cloudNode, setCloudNode] = React.useState<?HTMLElement>(null);
   useIsomorphicLayoutEffect(() => {
     if (!cloudNode) {
       return undefined;
     }
     cloudNode.addEventListener('load', onCloudIllustrationLoad);
     return () => cloudNode.removeEventListener('load', onCloudIllustrationLoad);
   }, [cloudNode, onCloudIllustrationLoad]);
 
   const headingClassName = classNames([typography.heading1, css.heading]);
   const descriptionClassName = classNames([
     typography.subheading2,
     css.description,
   ]);
 
   const heroHeadingClassName = classNames([headingClassName, css.heroText]);
   const heroDescriptionClassName = classNames([
     descriptionClassName,
     css.heroText,
   ]);
 
   return (
     <main>
       <section className={css.heroSection}>
         <div className={css.heroContainer}>
           <div className={css.heroImage}>
             <lottie-player
               id="eye-illustration"
               ref={setEyeNode}
               mode="normal"
               src={`${assetsCacheURLPrefix}/animated_eye.json`}
               speed={1}
             />
           </div>
           <h1 className={heroHeadingClassName}>
             Reclaim your
             <span className={css.purpleGradient}> digital&nbsp;identity</span>
           </h1>
           <p className={heroDescriptionClassName}>
             The Internet is broken today. Private user data is owned by
             mega-corporations and farmed for their benefit.
           </p>
           <p className={heroDescriptionClassName}>
             E2E encryption has the potential to change this equation. But
             it&rsquo;s constrained by a crucial limitation.
           </p>
         </div>
       </section>
       <section className={css.serversSection}>
         <div className={css.serversContainer}>
           <div className={css.serversImage}>
             <lottie-player
               id="cloud-illustration"
               ref={setCloudNode}
               mode="normal"
               src={`${assetsCacheURLPrefix}/animated_cloud.json`}
               speed={1}
             />
           </div>
           <div className={css.serversCopy}>
             <h1 className={headingClassName}>Apps need servers.</h1>
             <p className={descriptionClassName}>
               Sophisticated applications rely on servers to do things that your
               devices simply can&rsquo;t.
             </p>
             <p className={descriptionClassName}>
               That&rsquo;s why E2E encryption only works for simple chat apps
               today. There&rsquo;s no way to build a robust server layer that
               has access to your data without leaking that data to corporations.
             </p>
           </div>
         </div>
       </section>
       <section className={css.keyserverCompanySection}>
         <div className={css.keyserverCompanyContainer}>
           <div className={css.keyserverCompanyCopy}>
             <h1 className={headingClassName}>
               Comm is the
               <span className={css.purpleGradient}> keyserver </span>
               company.
             </h1>
             <p className={descriptionClassName}>
               In the future, people have their own servers.
             </p>
             <p className={descriptionClassName}>
               Your keyserver is the home of your digital identity. It owns your
               private keys and your personal data. It&rsquo;s your password
               manager, your crypto bank, your digital surrogate, and your second
               brain.
             </p>
           </div>
           <div className={css.readTheDocs}>
             <ReadDocsButton />
           </div>
         </div>
       </section>
       <KeyserverFAQ />
       <RequestAccess />
     </main>
   );
 }
 
 export default Keyservers;
diff --git a/landing/siwe.react.js b/landing/siwe.react.js
index 8c73d9da2..2dcdddde4 100644
--- a/landing/siwe.react.js
+++ b/landing/siwe.react.js
@@ -1,187 +1,187 @@
 // @flow
 
 import {
   useConnectModal,
   RainbowKitProvider,
   darkTheme,
   useModalState,
 } from '@rainbow-me/rainbowkit';
 import '@rainbow-me/rainbowkit/styles.css';
 import invariant from 'invariant';
 import _merge from 'lodash/fp/merge.js';
 import * as React from 'react';
 import { useAccount, useWalletClient, WagmiConfig } from 'wagmi';
 
 import ConnectedWalletInfo from 'lib/components/connected-wallet-info.react.js';
 import type { SIWEWebViewMessage } from 'lib/types/siwe-types.js';
 import {
   getSIWEStatementForPublicKey,
   siweMessageSigningExplanationStatements,
   createSIWEMessage,
 } from 'lib/utils/siwe-utils.js';
 import {
   AlchemyENSCacheProvider,
   wagmiConfig,
   wagmiChains,
 } from 'lib/utils/wagmi-utils.js';
 
 import { SIWEContext } from './siwe-context.js';
 import css from './siwe.css';
 import {
   useMonitorForWalletConnectModal,
   type WalletConnectModalUpdate,
 } from './walletconnect-hooks.js';
 
 function postMessageToNativeWebView(message: SIWEWebViewMessage) {
   window.ReactNativeWebView?.postMessage?.(JSON.stringify(message));
 }
 
 type Signer = {
   +signMessage: ({ +message: string, ... }) => Promise<string>,
   ...
 };
 async function signInWithEthereum(
   address: string,
   signer: Signer,
   nonce: string,
   statement: string,
 ) {
   invariant(nonce, 'nonce must be present in signInWithEthereum');
   const message = createSIWEMessage(address, statement, nonce);
   const signature = await signer.signMessage({ message });
   postMessageToNativeWebView({
     type: 'siwe_success',
     address,
     message,
     signature,
   });
 }
 
 function SIWE(): React.Node {
   const { address } = useAccount();
   const { data: signer } = useWalletClient();
   const { siweNonce, siwePrimaryIdentityPublicKey } =
     React.useContext(SIWEContext);
   const onClick = React.useCallback(() => {
     invariant(siweNonce, 'nonce must be present during SIWE attempt');
     invariant(
       siwePrimaryIdentityPublicKey,
       'primaryIdentityPublicKey must be present during SIWE attempt',
     );
     const statement = getSIWEStatementForPublicKey(
       siwePrimaryIdentityPublicKey,
     );
-    signInWithEthereum(address, signer, siweNonce, statement);
+    void signInWithEthereum(address, signer, siweNonce, statement);
   }, [address, signer, siweNonce, siwePrimaryIdentityPublicKey]);
 
   const { openConnectModal } = useConnectModal();
   const hasNonce = siweNonce !== null && siweNonce !== undefined;
   React.useEffect(() => {
     if (hasNonce && openConnectModal) {
       openConnectModal();
     }
   }, [hasNonce, openConnectModal]);
 
   const [wcModalOpen, setWCModalOpen] = React.useState(false);
 
   const prevConnectModalOpen = React.useRef(false);
   const modalState = useModalState();
   const closeTimeoutRef = React.useRef<?TimeoutID>();
   const { connectModalOpen } = modalState;
   React.useEffect(() => {
     if (
       !connectModalOpen &&
       !wcModalOpen &&
       prevConnectModalOpen.current &&
       !signer
     ) {
       closeTimeoutRef.current = setTimeout(
         () => postMessageToNativeWebView({ type: 'siwe_closed' }),
         250,
       );
     } else if (closeTimeoutRef.current) {
       clearTimeout(closeTimeoutRef.current);
       closeTimeoutRef.current = undefined;
     }
     prevConnectModalOpen.current = connectModalOpen;
   }, [connectModalOpen, wcModalOpen, signer]);
 
   const onWalletConnectModalUpdate = React.useCallback(
     (update: WalletConnectModalUpdate) => {
       if (update.state === 'closed') {
         setWCModalOpen(false);
         postMessageToNativeWebView({
           type: 'walletconnect_modal_update',
           ...update,
         });
       } else {
         setWCModalOpen(true);
         postMessageToNativeWebView({
           type: 'walletconnect_modal_update',
           ...update,
         });
       }
     },
     [],
   );
   useMonitorForWalletConnectModal(onWalletConnectModalUpdate);
 
   if (!hasNonce) {
     return (
       <div className={css.wrapper}>
         <h1 className={css.h1}>Unable to proceed: nonce not found.</h1>
       </div>
     );
   } else if (!signer) {
     return null;
   } else {
     return (
       <div className={css.wrapper}>
         <span className={css.walletDisplayText}>
           <p>Wallet Connected</p>
         </span>
         <div className={css.connectedWalletInfo}>
           <ConnectedWalletInfo />
         </div>
         <p>{siweMessageSigningExplanationStatements}</p>
         <p>
           By signing up, you agree to our{' '}
           <a href="https://comm.app/terms">Terms of Use</a> &{' '}
           <a href="https://comm.app/privacy">Privacy Policy</a>.
         </p>
         <div className={css.button} onClick={onClick}>
           Sign in using this wallet
         </div>
       </div>
     );
   }
 }
 
 function SIWEWrapper(): React.Node {
   const theme = React.useMemo(() => {
     return _merge(darkTheme())({
       radii: {
         modal: 0,
         modalMobile: 0,
       },
       colors: {
         modalBackdrop: '#242529',
       },
     });
   }, []);
   return (
     <WagmiConfig config={wagmiConfig}>
       <AlchemyENSCacheProvider>
         <RainbowKitProvider
           theme={theme}
           modalSize="compact"
           chains={wagmiChains}
         >
           <SIWE />
         </RainbowKitProvider>
       </AlchemyENSCacheProvider>
     </WagmiConfig>
   );
 }
 
 export default SIWEWrapper;
diff --git a/lib/components/base-edit-thread-avatar-provider.react.js b/lib/components/base-edit-thread-avatar-provider.react.js
index 2c567bad2..cfe084956 100644
--- a/lib/components/base-edit-thread-avatar-provider.react.js
+++ b/lib/components/base-edit-thread-avatar-provider.react.js
@@ -1,118 +1,118 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useChangeThreadSettings,
   changeThreadSettingsActionTypes,
 } from '../actions/thread-actions.js';
 import { createLoadingStatusSelector } from '../selectors/loading-selectors.js';
 import type { UpdateUserAvatarRequest } from '../types/avatar-types.js';
 import type { LoadingStatus } from '../types/loading-types.js';
 import type { UpdateThreadRequest } from '../types/thread-types.js';
 import { useDispatchActionPromise } from '../utils/action-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 export type EditThreadAvatarContextType = {
   +updateThreadAvatarMediaUploadInProgress: (inProgress: boolean) => void,
   +threadAvatarSaveInProgress: boolean,
   +baseSetThreadAvatar: (
     threadID: string,
     avatarRequest: UpdateUserAvatarRequest,
   ) => Promise<void>,
 };
 
 const EditThreadAvatarContext: React.Context<?EditThreadAvatarContextType> =
   React.createContext<?EditThreadAvatarContextType>();
 
 type Props = {
   +activeThreadID: string,
   +children: React.Node,
 };
 function BaseEditThreadAvatarProvider(props: Props): React.Node {
   const { activeThreadID, children } = props;
 
   const updateThreadAvatarLoadingStatus: LoadingStatus = useSelector(
     createLoadingStatusSelector(
       changeThreadSettingsActionTypes,
       `${changeThreadSettingsActionTypes.started}:${activeThreadID}:avatar`,
     ),
   );
 
   const dispatchActionPromise = useDispatchActionPromise();
   const changeThreadSettingsCall = useChangeThreadSettings();
 
   const [
     threadAvatarMediaUploadInProgress,
     setThreadAvatarMediaUploadInProgress,
   ] = React.useState<$ReadOnlySet<string>>(new Set<string>());
 
   const updateThreadAvatarMediaUploadInProgress = React.useCallback(
     (inProgress: boolean) =>
       setThreadAvatarMediaUploadInProgress(prevState => {
         const updatedSet = new Set(prevState);
         if (inProgress) {
           updatedSet.add(activeThreadID);
         } else {
           updatedSet.delete(activeThreadID);
         }
         return updatedSet;
       }),
     [activeThreadID],
   );
 
   const threadAvatarSaveInProgress =
     threadAvatarMediaUploadInProgress.has(activeThreadID) ||
     updateThreadAvatarLoadingStatus === 'loading';
 
   // NOTE: Do NOT consume `baseSetThreadAvatar` directly.
   //       Use platform-specific `[web/native]SetThreadAvatar` instead.
   const baseSetThreadAvatar = React.useCallback(
     async (threadID: string, avatarRequest: UpdateUserAvatarRequest) => {
       const updateThreadRequest: UpdateThreadRequest = {
         threadID,
         changes: {
           avatar: avatarRequest,
         },
       };
       const action = changeThreadSettingsActionTypes.started;
       if (
         avatarRequest.type === 'image' ||
         avatarRequest.type === 'encrypted_image'
       ) {
         updateThreadAvatarMediaUploadInProgress(false);
       }
       const promise = changeThreadSettingsCall(updateThreadRequest);
-      dispatchActionPromise(changeThreadSettingsActionTypes, promise, {
+      void dispatchActionPromise(changeThreadSettingsActionTypes, promise, {
         customKeyName: `${action}:${threadID}:avatar`,
       });
       await promise;
     },
     [
       changeThreadSettingsCall,
       dispatchActionPromise,
       updateThreadAvatarMediaUploadInProgress,
     ],
   );
 
   const context = React.useMemo(
     () => ({
       updateThreadAvatarMediaUploadInProgress,
       threadAvatarSaveInProgress,
       baseSetThreadAvatar,
     }),
     [
       updateThreadAvatarMediaUploadInProgress,
       threadAvatarSaveInProgress,
       baseSetThreadAvatar,
     ],
   );
 
   return (
     <EditThreadAvatarContext.Provider value={context}>
       {children}
     </EditThreadAvatarContext.Provider>
   );
 }
 
 export { EditThreadAvatarContext, BaseEditThreadAvatarProvider };
diff --git a/lib/components/edit-user-avatar-provider.react.js b/lib/components/edit-user-avatar-provider.react.js
index 750a642b5..53cbdff59 100644
--- a/lib/components/edit-user-avatar-provider.react.js
+++ b/lib/components/edit-user-avatar-provider.react.js
@@ -1,127 +1,127 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   updateUserAvatar,
   updateUserAvatarActionTypes,
 } from '../actions/user-actions.js';
 import { createLoadingStatusSelector } from '../selectors/loading-selectors.js';
 import type { UpdateUserAvatarRequest } from '../types/avatar-types.js';
 import type { SetState } from '../types/hook-types.js';
 import type { LoadingStatus } from '../types/loading-types.js';
 import type { NativeMediaSelection } from '../types/media-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from '../utils/action-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 export type UserAvatarSelection =
   | { +needsUpload: true, +mediaSelection: NativeMediaSelection }
   | { +needsUpload: false, +updateUserAvatarRequest: UpdateUserAvatarRequest };
 type RegistrationMode =
   | { +registrationMode: 'off' }
   | {
       +registrationMode: 'on',
       +successCallback: UserAvatarSelection => mixed,
     };
 const registrationModeOff = { registrationMode: 'off' };
 
 export type EditUserAvatarContextType = {
   +setUserAvatarMediaUploadInProgress: SetState<boolean>,
   +userAvatarSaveInProgress: boolean,
   +baseSetUserAvatar: (avatarRequest: UpdateUserAvatarRequest) => Promise<void>,
   +setRegistrationMode: (registrationMode: RegistrationMode) => void,
   +getRegistrationModeEnabled: () => boolean,
   +getRegistrationModeSuccessCallback: () => ?(UserAvatarSelection) => mixed,
 };
 
 const EditUserAvatarContext: React.Context<?EditUserAvatarContextType> =
   React.createContext<?EditUserAvatarContextType>();
 
 const updateUserAvatarLoadingStatusSelector = createLoadingStatusSelector(
   updateUserAvatarActionTypes,
 );
 
 type Props = {
   +children: React.Node,
 };
 function EditUserAvatarProvider(props: Props): React.Node {
   const { children } = props;
 
   const registrationModeRef =
     React.useRef<RegistrationMode>(registrationModeOff);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const updateUserAvatarCall = useServerCall(updateUserAvatar);
 
   const [userAvatarMediaUploadInProgress, setUserAvatarMediaUploadInProgress] =
     React.useState(false);
 
   const updateUserAvatarLoadingStatus: LoadingStatus = useSelector(
     updateUserAvatarLoadingStatusSelector,
   );
 
   const userAvatarSaveInProgress =
     userAvatarMediaUploadInProgress ||
     updateUserAvatarLoadingStatus === 'loading';
 
   // NOTE: Do **NOT** consume `baseSetUserAvatar` directly.
   //       Use platform-specific `[web/native]SetUserAvatar` instead.
   const baseSetUserAvatar = React.useCallback(
     async (request: UpdateUserAvatarRequest) => {
       const promise = (async () => {
         if (request.type === 'image' || request.type === 'encrypted_image') {
           setUserAvatarMediaUploadInProgress(false);
         }
         return await updateUserAvatarCall(request);
       })();
-      dispatchActionPromise(updateUserAvatarActionTypes, promise);
+      void dispatchActionPromise(updateUserAvatarActionTypes, promise);
       await promise;
     },
     [dispatchActionPromise, updateUserAvatarCall],
   );
 
   const setRegistrationMode = React.useCallback((mode: RegistrationMode) => {
     registrationModeRef.current = mode;
   }, []);
   const getRegistrationModeEnabled = React.useCallback(
     () => registrationModeRef.current.registrationMode === 'on',
     [],
   );
   const getRegistrationModeSuccessCallback = React.useCallback(
     () =>
       registrationModeRef.current.registrationMode === 'on'
         ? registrationModeRef.current.successCallback
         : null,
     [],
   );
 
   const context = React.useMemo(
     () => ({
       setUserAvatarMediaUploadInProgress,
       userAvatarSaveInProgress,
       baseSetUserAvatar,
       setRegistrationMode,
       getRegistrationModeEnabled,
       getRegistrationModeSuccessCallback,
     }),
     [
       setUserAvatarMediaUploadInProgress,
       userAvatarSaveInProgress,
       baseSetUserAvatar,
       setRegistrationMode,
       getRegistrationModeEnabled,
       getRegistrationModeSuccessCallback,
     ],
   );
 
   return (
     <EditUserAvatarContext.Provider value={context}>
       {children}
     </EditUserAvatarContext.Provider>
   );
 }
 
 export { EditUserAvatarContext, EditUserAvatarProvider };
diff --git a/lib/hooks/child-threads.js b/lib/hooks/child-threads.js
index 714f54679..0d21efb8d 100644
--- a/lib/hooks/child-threads.js
+++ b/lib/hooks/child-threads.js
@@ -1,122 +1,122 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useFetchSingleMostRecentMessagesFromThreads,
   fetchSingleMostRecentMessagesFromThreadsActionTypes,
 } from '../actions/message-actions.js';
 import {
   useFilteredChatListData,
   type ChatThreadItem,
 } from '../selectors/chat-selectors.js';
 import { useGlobalThreadSearchIndex } from '../selectors/nav-selectors.js';
 import { childThreadInfos } from '../selectors/thread-selectors.js';
 import { threadInChatList } from '../shared/thread-utils.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type { RawThreadInfo, ThreadInfo } from '../types/thread-types.js';
 import { useDispatchActionPromise } from '../utils/action-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 type ThreadFilter = {
   +predicate?: (thread: ThreadInfo) => boolean,
   +searchText?: string,
 };
 
 function useFilteredChildThreads(
   threadID: string,
   filter?: ThreadFilter,
 ): $ReadOnlyArray<ChatThreadItem> {
   const defaultPredicate = React.useCallback(() => true, []);
   const { predicate = defaultPredicate, searchText = '' } = filter ?? {};
   const childThreads = useSelector(state => childThreadInfos(state)[threadID]);
   const subchannelIDs = React.useMemo(() => {
     if (!childThreads) {
       return new Set<string>();
     }
     return new Set<string>(
       childThreads.filter(predicate).map(threadInfo => threadInfo.id),
     );
   }, [childThreads, predicate]);
 
   const filterSubchannels = React.useCallback(
     (thread: ?(RawThreadInfo | ThreadInfo)) => {
       const candidateThreadID = thread?.id;
       if (!candidateThreadID) {
         return false;
       }
       return subchannelIDs.has(candidateThreadID);
     },
     [subchannelIDs],
   );
   const allSubchannelsList = useFilteredChatListData(filterSubchannels);
 
   const searchIndex = useGlobalThreadSearchIndex();
 
   const searchResultIDs = React.useMemo(
     () => searchIndex.getSearchResults(searchText),
     [searchIndex, searchText],
   );
 
   const searchTextExists = !!searchText.length;
 
   const subchannelIDsNotInChatList = React.useMemo(
     () =>
       new Set(
         allSubchannelsList
           .filter(item => !threadInChatList(item.threadInfo))
           .map(item => item.threadInfo.id),
       ),
     [allSubchannelsList],
   );
 
   React.useEffect(() => {
     if (!subchannelIDsNotInChatList.size) {
       return undefined;
     }
     subchannelIDsNotInChatList.forEach(tID => threadWatcher.watchID(tID));
 
     return () =>
       subchannelIDsNotInChatList.forEach(tID => threadWatcher.removeID(tID));
   }, [subchannelIDsNotInChatList]);
 
   const filteredSubchannelsChatList = React.useMemo(() => {
     if (!searchTextExists) {
       return allSubchannelsList;
     }
     return allSubchannelsList.filter(item =>
       searchResultIDs.includes(item.threadInfo.id),
     );
   }, [allSubchannelsList, searchResultIDs, searchTextExists]);
 
   const threadIDsWithNoMessages = React.useMemo(
     () =>
       new Set(
         filteredSubchannelsChatList
           .filter(item => !item.mostRecentMessageInfo)
           .map(item => item.threadInfo.id),
       ),
     [filteredSubchannelsChatList],
   );
   const dispatchActionPromise = useDispatchActionPromise();
   const fetchSingleMostRecentMessages =
     useFetchSingleMostRecentMessagesFromThreads();
 
   React.useEffect(() => {
     if (!threadIDsWithNoMessages.size) {
       return;
     }
-    dispatchActionPromise(
+    void dispatchActionPromise(
       fetchSingleMostRecentMessagesFromThreadsActionTypes,
       fetchSingleMostRecentMessages(Array.from(threadIDsWithNoMessages)),
     );
   }, [
     threadIDsWithNoMessages,
     fetchSingleMostRecentMessages,
     dispatchActionPromise,
   ]);
 
   return filteredSubchannelsChatList;
 }
 
 export { useFilteredChildThreads };
diff --git a/lib/hooks/ens-cache.js b/lib/hooks/ens-cache.js
index 7a5ea2a23..5b983cbb8 100644
--- a/lib/hooks/ens-cache.js
+++ b/lib/hooks/ens-cache.js
@@ -1,206 +1,206 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { ENSCacheContext } from '../components/ens-cache-provider.react.js';
 import { getETHAddressForUserInfo } from '../shared/account-utils.js';
 import { stringForUser } from '../shared/user-utils.js';
 import { getENSNames } from '../utils/ens-helpers.js';
 
 type BaseUserInfo = { +username?: ?string, ... };
 export type UseENSNamesOptions = {
   +allAtOnce?: ?boolean,
 };
 function useENSNames<T: ?BaseUserInfo>(
   users: $ReadOnlyArray<T>,
   options?: ?UseENSNamesOptions,
 ): T[] {
   const cacheContext = React.useContext(ENSCacheContext);
   const { ensCache } = cacheContext;
   const allAtOnce = options?.allAtOnce ?? false;
 
   const cachedInfo = React.useMemo(
     () =>
       users.map(user => {
         if (!user) {
           return user;
         }
         const ethAddress = getETHAddressForUserInfo(user);
         const cachedResult =
           ethAddress && ensCache
             ? ensCache.getCachedNameForAddress(ethAddress)
             : null;
         return {
           input: user,
           ethAddress,
           cachedResult,
         };
       }),
     [users, ensCache],
   );
 
   const [fetchedAddresses, setFetchedAddresses] = React.useState<
     $ReadOnlySet<string>,
   >(new Set());
   const [ensNames, setENSNames] = React.useState<$ReadOnlyMap<string, string>>(
     new Map(),
   );
 
   React.useEffect(() => {
     if (!ensCache) {
       return;
     }
 
     const needFetchUsers: $ReadOnlyArray<{ +username: string }> = cachedInfo
       .map(user => {
         if (!user) {
           return null;
         }
         const { ethAddress, cachedResult } = user;
         if (cachedResult || !ethAddress || fetchedAddresses.has(ethAddress)) {
           return null;
         }
         return { username: ethAddress };
       })
       .filter(Boolean);
     if (needFetchUsers.length === 0) {
       return;
     }
 
     const needFetchAddresses = needFetchUsers.map(({ username }) => username);
     setFetchedAddresses(oldFetchedAddresses => {
       const newFetchedAddresses = new Set(oldFetchedAddresses);
       for (const ethAddress of needFetchAddresses) {
         newFetchedAddresses.add(ethAddress);
       }
       return newFetchedAddresses;
     });
 
     if (allAtOnce) {
-      (async () => {
+      void (async () => {
         const withENSNames = await getENSNames(ensCache, needFetchUsers);
         setENSNames(oldENSNames => {
           const newENSNames = new Map(oldENSNames);
           for (let i = 0; i < withENSNames.length; i++) {
             const ethAddress = needFetchAddresses[i];
             const result = withENSNames[i].username;
             newENSNames.set(ethAddress, result);
           }
           return newENSNames;
         });
       })();
       return;
     }
 
     for (const ethAddress of needFetchAddresses) {
-      (async () => {
+      void (async () => {
         const result = await ensCache.getNameForAddress(ethAddress);
         if (!result) {
           return;
         }
         setENSNames(oldENSNames => {
           const newENSNames = new Map(oldENSNames);
           newENSNames.set(ethAddress, result);
           return newENSNames;
         });
       })();
     }
   }, [cachedInfo, fetchedAddresses, ensCache, allAtOnce]);
 
   return React.useMemo(
     () =>
       cachedInfo.map(user => {
         if (!user) {
           return user;
         }
         const { input, ethAddress, cachedResult } = user;
         if (cachedResult) {
           return { ...input, username: cachedResult };
         } else if (!ethAddress) {
           return input;
         }
         const ensName = ensNames.get(ethAddress);
         if (ensName) {
           return { ...input, username: ensName };
         }
         return input;
       }),
     [cachedInfo, ensNames],
   );
 }
 
 function useENSName(username: string): string {
   const usersObjArr = React.useMemo(() => [{ username }], [username]);
   const [potentiallyENSUser] = useENSNames<{ +username: string }>(usersObjArr);
   return potentiallyENSUser.username;
 }
 
 function useStringForUser(
   user: ?{ +username?: ?string, +isViewer?: ?boolean, ... },
 ): ?string {
   const toFetch = user?.isViewer ? null : user;
   // stringForUser ignores username is isViewer, so we skip the ENS fetch
   const [result] = useENSNames([toFetch]);
   if (user?.isViewer) {
     return stringForUser(user);
   } else if (result) {
     return stringForUser(result);
   } else {
     invariant(
       !user,
       'the only way result can be falsey is if useENSNames is passed a ' +
         'falsey input, and that can only happen if useStringForUser input is ' +
         'falsey or isViewer is set',
     );
     return user;
   }
 }
 
 function useENSAvatar(ethAddress: ?string): ?string {
   const cacheContext = React.useContext(ENSCacheContext);
   const { ensCache } = cacheContext;
 
   const cachedAvatar = React.useMemo(() => {
     if (!ethAddress) {
       return ethAddress;
     }
     if (!ensCache) {
       return null;
     }
     return ensCache.getCachedAvatarURIForAddress(ethAddress);
   }, [ensCache, ethAddress]);
 
   const [ensAvatars, setENSAvatars] = React.useState<
     $ReadOnlyMap<string, string>,
   >(new Map());
 
   React.useEffect(() => {
     if (!ensCache || !ethAddress || cachedAvatar !== undefined) {
       return;
     }
-    (async () => {
+    void (async () => {
       const result = await ensCache.getAvatarURIForAddress(ethAddress);
       if (!result) {
         return;
       }
       setENSAvatars(oldENSAvatars => {
         const newENSAvatars = new Map(oldENSAvatars);
         newENSAvatars.set(ethAddress, result);
         return newENSAvatars;
       });
     })();
   }, [ensCache, cachedAvatar, ethAddress]);
 
   return React.useMemo(() => {
     if (!ethAddress) {
       return ethAddress;
     } else if (cachedAvatar !== undefined) {
       return cachedAvatar;
     } else {
       return ensAvatars.get(ethAddress);
     }
   }, [ethAddress, cachedAvatar, ensAvatars]);
 }
 
 export { useENSNames, useENSName, useStringForUser, useENSAvatar };
diff --git a/lib/hooks/invite-links.js b/lib/hooks/invite-links.js
index b07381901..90ce1bfdb 100644
--- a/lib/hooks/invite-links.js
+++ b/lib/hooks/invite-links.js
@@ -1,102 +1,102 @@
 // @flow
 
 import React from 'react';
 
 import {
   useCreateOrUpdatePublicLink,
   createOrUpdatePublicLinkActionTypes,
   useDisableInviteLink,
   disableInviteLinkLinkActionTypes,
 } from '../actions/link-actions.js';
 import { createLoadingStatusSelector } from '../selectors/loading-selectors.js';
 import type { SetState } from '../types/hook-types.js';
 import type { InviteLink } from '../types/link-types.js';
 import { useDispatchActionPromise } from '../utils/action-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 const createOrUpdatePublicLinkStatusSelector = createLoadingStatusSelector(
   createOrUpdatePublicLinkActionTypes,
 );
 const disableInviteLinkStatusSelector = createLoadingStatusSelector(
   disableInviteLinkLinkActionTypes,
 );
 
 function useInviteLinksActions(
   communityID: string,
   inviteLink: ?InviteLink,
 ): {
   +error: ?string,
   +isLoading: boolean,
   +name: string,
   +setName: SetState<string>,
   +createOrUpdateInviteLink: () => mixed,
   +disableInviteLink: () => mixed,
 } {
   const [name, setName] = React.useState(
     inviteLink?.name ?? Math.random().toString(36).slice(-9),
   );
   const [error, setError] = React.useState(null);
   const dispatchActionPromise = useDispatchActionPromise();
 
   const callCreateOrUpdatePublicLink = useCreateOrUpdatePublicLink();
   const createCreateOrUpdateActionPromise = React.useCallback(async () => {
     setError(null);
     try {
       return await callCreateOrUpdatePublicLink({
         name,
         communityID,
       });
     } catch (e) {
       setError(e.message);
       throw e;
     }
   }, [callCreateOrUpdatePublicLink, communityID, name]);
   const createOrUpdateInviteLink = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       createOrUpdatePublicLinkActionTypes,
       createCreateOrUpdateActionPromise(),
     );
   }, [createCreateOrUpdateActionPromise, dispatchActionPromise]);
 
   const disableInviteLinkServerCall = useDisableInviteLink();
   const createDisableLinkActionPromise = React.useCallback(async () => {
     setError(null);
     try {
       return await disableInviteLinkServerCall({
         name,
         communityID,
       });
     } catch (e) {
       setError(e.message);
       throw e;
     }
   }, [disableInviteLinkServerCall, communityID, name]);
   const disableInviteLink = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       disableInviteLinkLinkActionTypes,
       createDisableLinkActionPromise(),
     );
   }, [createDisableLinkActionPromise, dispatchActionPromise]);
   const disableInviteLinkStatus = useSelector(disableInviteLinkStatusSelector);
 
   const createOrUpdatePublicLinkStatus = useSelector(
     createOrUpdatePublicLinkStatusSelector,
   );
   const isLoading =
     createOrUpdatePublicLinkStatus === 'loading' ||
     disableInviteLinkStatus === 'loading';
 
   return React.useMemo(
     () => ({
       error,
       isLoading,
       name,
       setName,
       createOrUpdateInviteLink,
       disableInviteLink,
     }),
     [createOrUpdateInviteLink, disableInviteLink, error, isLoading, name],
   );
 }
 
 export { useInviteLinksActions };
diff --git a/lib/hooks/promote-sidebar.react.js b/lib/hooks/promote-sidebar.react.js
index fc858819b..5e8cce9b2 100644
--- a/lib/hooks/promote-sidebar.react.js
+++ b/lib/hooks/promote-sidebar.react.js
@@ -1,94 +1,94 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from '../actions/thread-actions.js';
 import { createLoadingStatusSelector } from '../selectors/loading-selectors.js';
 import { threadInfoSelector } from '../selectors/thread-selectors.js';
 import {
   threadHasPermission,
   threadIsSidebar,
 } from '../shared/thread-utils.js';
 import type { LoadingStatus } from '../types/loading-types.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
 import { threadTypes } from '../types/thread-types-enum.js';
 import type { ThreadInfo } from '../types/thread-types.js';
 import { useDispatchActionPromise } from '../utils/action-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 function canPromoteSidebar(
   sidebarThreadInfo: ThreadInfo,
   parentThreadInfo: ?ThreadInfo,
 ): boolean {
   if (!threadIsSidebar(sidebarThreadInfo)) {
     return false;
   }
 
   const canChangeThreadType = threadHasPermission(
     sidebarThreadInfo,
     threadPermissions.EDIT_PERMISSIONS,
   );
   const canCreateSubchannelsInParent = threadHasPermission(
     parentThreadInfo,
     threadPermissions.CREATE_SUBCHANNELS,
   );
   return canChangeThreadType && canCreateSubchannelsInParent;
 }
 
 type PromoteSidebarType = {
   +onPromoteSidebar: () => void,
   +loading: LoadingStatus,
   +canPromoteSidebar: boolean,
 };
 
 function usePromoteSidebar(
   threadInfo: ThreadInfo,
   onError?: () => mixed,
 ): PromoteSidebarType {
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useChangeThreadSettings();
   const loadingStatusSelector = createLoadingStatusSelector(
     changeThreadSettingsActionTypes,
   );
   const loadingStatus = useSelector(loadingStatusSelector);
 
   const { parentThreadID } = threadInfo;
   const parentThreadInfo: ?ThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
 
   const canPromote = canPromoteSidebar(threadInfo, parentThreadInfo);
 
   const onClick = React.useCallback(() => {
     try {
-      dispatchActionPromise(
+      void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         (async () => {
           return await callChangeThreadSettings({
             threadID: threadInfo.id,
             changes: { type: threadTypes.COMMUNITY_OPEN_SUBTHREAD },
           });
         })(),
       );
     } catch (e) {
       onError?.();
       throw e;
     }
   }, [threadInfo.id, callChangeThreadSettings, dispatchActionPromise, onError]);
 
   const returnValues = React.useMemo(
     () => ({
       onPromoteSidebar: onClick,
       loading: loadingStatus,
       canPromoteSidebar: canPromote,
     }),
     [onClick, loadingStatus, canPromote],
   );
 
   return returnValues;
 }
 
 export { usePromoteSidebar, canPromoteSidebar };
diff --git a/lib/hooks/relationship-prompt.js b/lib/hooks/relationship-prompt.js
index 286f33bc1..cd4d43ab2 100644
--- a/lib/hooks/relationship-prompt.js
+++ b/lib/hooks/relationship-prompt.js
@@ -1,127 +1,127 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   updateRelationships as serverUpdateRelationships,
   updateRelationshipsActionTypes,
 } from '../actions/relationship-actions.js';
 import { getSingleOtherUser } from '../shared/thread-utils.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,
   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(
+      void 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/toggle-unread-status.js b/lib/hooks/toggle-unread-status.js
index dad5cf202..5b19508ef 100644
--- a/lib/hooks/toggle-unread-status.js
+++ b/lib/hooks/toggle-unread-status.js
@@ -1,54 +1,54 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useSetThreadUnreadStatus,
   setThreadUnreadStatusActionTypes,
 } from '../actions/activity-actions.js';
 import type {
   SetThreadUnreadStatusPayload,
   SetThreadUnreadStatusRequest,
 } from '../types/activity-types.js';
 import type { ThreadInfo } from '../types/thread-types.js';
 import { useDispatchActionPromise } from '../utils/action-utils.js';
 
 function useToggleUnreadStatus(
   threadInfo: ThreadInfo,
   mostRecentNonLocalMessage: ?string,
   afterAction: () => void,
 ): () => void {
   const dispatchActionPromise = useDispatchActionPromise();
   const { currentUser } = threadInfo;
   const boundSetThreadUnreadStatus: (
     request: SetThreadUnreadStatusRequest,
   ) => Promise<SetThreadUnreadStatusPayload> = useSetThreadUnreadStatus();
   const toggleUnreadStatus = React.useCallback(() => {
     const request = {
       threadID: threadInfo.id,
       unread: !currentUser.unread,
       latestMessage: mostRecentNonLocalMessage,
     };
-    dispatchActionPromise(
+    void dispatchActionPromise(
       setThreadUnreadStatusActionTypes,
       boundSetThreadUnreadStatus(request),
       undefined,
       ({
         threadID: threadInfo.id,
         unread: !currentUser.unread,
       }: { +threadID: string, +unread: boolean }),
     );
     afterAction();
   }, [
     threadInfo.id,
     currentUser.unread,
     mostRecentNonLocalMessage,
     dispatchActionPromise,
     afterAction,
     boundSetThreadUnreadStatus,
   ]);
 
   return toggleUnreadStatus;
 }
 
 export default useToggleUnreadStatus;
diff --git a/lib/shared/crypto-utils.js b/lib/shared/crypto-utils.js
index 9ac40c226..ce43a7725 100644
--- a/lib/shared/crypto-utils.js
+++ b/lib/shared/crypto-utils.js
@@ -1,108 +1,108 @@
 //@flow
 
 import * as React from 'react';
 
 import {
   getOlmSessionInitializationData,
   getOlmSessionInitializationDataActionTypes,
 } from '../actions/user-actions.js';
 import type {
   OLMIdentityKeys,
   OLMOneTimeKeys,
   OLMPrekey,
 } from '../types/crypto-types';
 import type { OlmSessionInitializationInfo } from '../types/request-types';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from '../utils/action-utils.js';
 import type {
   CallServerEndpointOptions,
   CallServerEndpoint,
 } from '../utils/call-server-endpoint.js';
 import { values } from '../utils/objects.js';
 
 export type InitialNotifMessageOptions = {
   +callServerEndpoint?: ?CallServerEndpoint,
   +callServerEndpointOptions?: ?CallServerEndpointOptions,
 };
 
 const initialEncryptedMessageContent = {
   type: 'init',
 };
 
 function useInitialNotificationsEncryptedMessage(
   platformSpecificSessionCreator: (
     notificationsIdentityKeys: OLMIdentityKeys,
     notificationsInitializationInfo: OlmSessionInitializationInfo,
   ) => Promise<string>,
 ): (options?: ?InitialNotifMessageOptions) => Promise<string> {
   const callGetOlmSessionInitializationData = useServerCall(
     getOlmSessionInitializationData,
   );
   const dispatchActionPromise = useDispatchActionPromise();
 
   return React.useCallback(
     async options => {
       const callServerEndpoint = options?.callServerEndpoint;
       const callServerEndpointOptions = options?.callServerEndpointOptions;
 
       const initDataAction = callServerEndpoint
         ? getOlmSessionInitializationData(callServerEndpoint)
         : callGetOlmSessionInitializationData;
       const olmSessionDataPromise = initDataAction(callServerEndpointOptions);
 
-      dispatchActionPromise(
+      void dispatchActionPromise(
         getOlmSessionInitializationDataActionTypes,
         olmSessionDataPromise,
       );
 
       const { signedIdentityKeysBlob, notifInitializationInfo } =
         await olmSessionDataPromise;
 
       const { notificationIdentityPublicKeys } = JSON.parse(
         signedIdentityKeysBlob.payload,
       );
 
       return await platformSpecificSessionCreator(
         notificationIdentityPublicKeys,
         notifInitializationInfo,
       );
     },
     [
       callGetOlmSessionInitializationData,
       dispatchActionPromise,
       platformSpecificSessionCreator,
     ],
   );
 }
 
 function getOneTimeKeyValues(
   oneTimeKeys: OLMOneTimeKeys,
 ): $ReadOnlyArray<string> {
   return values(oneTimeKeys.curve25519);
 }
 
 function getPrekeyValue(prekey: OLMPrekey): string {
   const [prekeyValue] = values(prekey.curve25519);
   return prekeyValue;
 }
 
 function getOneTimeKeyValuesFromBlob(keyBlob: string): $ReadOnlyArray<string> {
   const oneTimeKeys: OLMOneTimeKeys = JSON.parse(keyBlob);
   return getOneTimeKeyValues(oneTimeKeys);
 }
 
 function getPrekeyValueFromBlob(prekeyBlob: string): string {
   const prekey: OLMPrekey = JSON.parse(prekeyBlob);
   return getPrekeyValue(prekey);
 }
 
 export {
   getOneTimeKeyValues,
   getPrekeyValue,
   getOneTimeKeyValuesFromBlob,
   getPrekeyValueFromBlob,
   initialEncryptedMessageContent,
   useInitialNotificationsEncryptedMessage,
 };
diff --git a/lib/shared/edit-messages-utils.js b/lib/shared/edit-messages-utils.js
index e6a04e421..8b4640ec9 100644
--- a/lib/shared/edit-messages-utils.js
+++ b/lib/shared/edit-messages-utils.js
@@ -1,85 +1,88 @@
 // @flow
 
 import * as React from 'react';
 
 import { threadIsPending, threadHasPermission } from './thread-utils.js';
 import {
   sendEditMessageActionTypes,
   useSendEditMessage,
 } from '../actions/message-actions.js';
 import type {
   SendEditMessageResult,
   RobotextMessageInfo,
   ComposableMessageInfo,
   RawMessageInfo,
 } from '../types/message-types';
 import { messageTypes } from '../types/message-types-enum.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
 import { type ThreadInfo } from '../types/thread-types.js';
 import { useDispatchActionPromise } from '../utils/action-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 function useEditMessage(): (
   messageID: string,
   newText: string,
 ) => Promise<SendEditMessageResult> {
   const callEditMessage = useSendEditMessage();
   const dispatchActionPromise = useDispatchActionPromise();
 
   return React.useCallback(
     (messageID, newText) => {
       const editMessagePromise = (async () => {
         const result = await callEditMessage({
           targetMessageID: messageID,
           text: newText,
         });
 
         return ({
           newMessageInfos: result.newMessageInfos,
         }: { +newMessageInfos: $ReadOnlyArray<RawMessageInfo> });
       })();
 
-      dispatchActionPromise(sendEditMessageActionTypes, editMessagePromise);
+      void dispatchActionPromise(
+        sendEditMessageActionTypes,
+        editMessagePromise,
+      );
 
       return editMessagePromise;
     },
     [dispatchActionPromise, callEditMessage],
   );
 }
 
 function useCanEditMessage(
   threadInfo: ThreadInfo,
   targetMessageInfo: ComposableMessageInfo | RobotextMessageInfo,
 ): boolean {
   const currentUserInfo = useSelector(state => state.currentUserInfo);
 
   if (targetMessageInfo.type !== messageTypes.TEXT) {
     return false;
   }
 
   if (!currentUserInfo || !currentUserInfo.id) {
     return false;
   }
 
   const currentUserId = currentUserInfo.id;
   const targetMessageCreatorId = targetMessageInfo.creator.id;
   if (currentUserId !== targetMessageCreatorId) {
     return false;
   }
 
   const hasPermission = threadHasPermission(
     threadInfo,
     threadPermissions.EDIT_MESSAGE,
   );
   return hasPermission;
 }
 
 function getMessageLabel(hasBeenEdited: ?boolean, threadID: string): ?string {
   const isPending = threadIsPending(threadID);
   if (hasBeenEdited && !isPending) {
     return 'Edited';
   }
   return null;
 }
 
 export { useCanEditMessage, useEditMessage, getMessageLabel };
diff --git a/lib/shared/keyserver-utils.js b/lib/shared/keyserver-utils.js
index 1217b7b2c..829265f6b 100644
--- a/lib/shared/keyserver-utils.js
+++ b/lib/shared/keyserver-utils.js
@@ -1,48 +1,48 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useGetVersion,
   getVersionActionTypes,
 } from '../actions/device-actions.js';
 import { useDispatchActionPromise } from '../utils/action-utils.js';
 
 function useIsKeyserverURLValid(keyserverURL?: string): () => Promise<boolean> {
   const serverCallParamOverride = React.useMemo(() => {
     if (!keyserverURL) {
       return undefined;
     }
 
     return {
       keyserverInfos: {
         [(keyserverURL: string)]: {
           urlPrefix: keyserverURL,
         },
       },
     };
   }, [keyserverURL]);
 
   const getVersionCall = useGetVersion(serverCallParamOverride);
 
   const dispatchActionPromise = useDispatchActionPromise();
 
   return React.useCallback(async () => {
     if (!keyserverURL) {
       return false;
     }
 
     const getVersionPromise = getVersionCall();
-    dispatchActionPromise(getVersionActionTypes, getVersionPromise);
+    void dispatchActionPromise(getVersionActionTypes, getVersionPromise);
 
     // We don't care about the result; just need to make sure this doesn't throw
     try {
       await getVersionPromise;
       return true;
     } catch (e) {
       return false;
     }
   }, [dispatchActionPromise, getVersionCall, keyserverURL]);
 }
 
 export { useIsKeyserverURLValid };
diff --git a/lib/shared/messages/text-message-spec.js b/lib/shared/messages/text-message-spec.js
index b7bcf0ef6..7df94f13b 100644
--- a/lib/shared/messages/text-message-spec.js
+++ b/lib/shared/messages/text-message-spec.js
@@ -1,331 +1,334 @@
 // @flow
 
 import invariant from 'invariant';
 import * as SimpleMarkdown from 'simple-markdown';
 
 import {
   pushTypes,
   type MessageSpec,
   type RawMessageInfoFromServerDBRowParams,
   type NotificationTextsParams,
 } from './message-spec.js';
 import { assertSingleMessageInfo, joinResult } from './utils.js';
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from '../../actions/thread-actions.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import type {
   MessageInfo,
   ClientDBMessageInfo,
 } from '../../types/message-types.js';
 import {
   type RawTextMessageInfo,
   type TextMessageData,
   type TextMessageInfo,
   rawTextMessageInfoValidator,
 } from '../../types/messages/text.js';
 import type { NotifTexts } from '../../types/notif-types.js';
 import { threadTypes } from '../../types/thread-types-enum.js';
 import type { ThreadInfo } from '../../types/thread-types.js';
 import type { RelativeUserInfo } from '../../types/user-types.js';
 import { useDispatchActionPromise } from '../../utils/action-utils.js';
 import { ET } from '../../utils/entity-text.js';
 import {
   type ASTNode,
   type SingleASTNode,
   stripSpoilersFromNotifications,
   stripSpoilersFromMarkdownAST,
 } from '../markdown.js';
 import {
   isUserMentioned,
   renderChatMentionsWithAltText,
 } from '../mention-utils.js';
 import { notifTextsForSidebarCreation } from '../notif-utils.js';
 import {
   threadIsGroupChat,
   extractNewMentionedParentMembers,
 } from '../thread-utils.js';
 
 /**
  * most of the markdown leaves contain `content` field
  * (it is an array or a string) apart from lists,
  * which have `items` field (that holds an array)
  */
 const rawTextFromMarkdownAST = (node: ASTNode): string => {
   if (Array.isArray(node)) {
     return node.map(rawTextFromMarkdownAST).join('');
   }
   const { content, items } = node;
   if (content && typeof content === 'string') {
     return content;
   } else if (items) {
     return rawTextFromMarkdownAST(items);
   } else if (content) {
     return rawTextFromMarkdownAST(content);
   }
   return '';
 };
 
 const getFirstNonQuotedRawLine = (
   nodes: $ReadOnlyArray<SingleASTNode>,
 ): string => {
   let result = 'message';
   for (const node of nodes) {
     if (node.type === 'blockQuote') {
       result = 'quoted message';
     } else {
       const rawText = rawTextFromMarkdownAST(node);
       if (!rawText || !rawText.replace(/\s/g, '')) {
         // handles the case of an empty(or containing only white spaces)
         // new line that usually occurs between a quote and the rest
         // of the message(we don't want it as a title, thus continue)
         continue;
       }
       return rawText;
     }
   }
   return result;
 };
 
 type TextMessageSpec = MessageSpec<
   TextMessageData,
   RawTextMessageInfo,
   TextMessageInfo,
 > & {
   // We need to explicitly type this as non-optional so that
   // it can be referenced from messageContentForClientDB below
   +messageContentForServerDB: (
     data: TextMessageData | RawTextMessageInfo,
   ) => string,
   ...
 };
 
 export const textMessageSpec: TextMessageSpec = Object.freeze({
   messageContentForServerDB(
     data: TextMessageData | RawTextMessageInfo,
   ): string {
     return data.text;
   },
 
   messageContentForClientDB(data: RawTextMessageInfo): string {
     return textMessageSpec.messageContentForServerDB(data);
   },
 
   messageTitle({ messageInfo, markdownRules }) {
     const { text } = messageInfo;
     const parser = SimpleMarkdown.parserFor(markdownRules);
     const ast = stripSpoilersFromMarkdownAST(
       parser(text, { disableAutoBlockNewlines: true }),
     );
     return ET`${getFirstNonQuotedRawLine(ast).trim()}`;
   },
 
   rawMessageInfoFromServerDBRow(
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ): RawTextMessageInfo {
     let rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       text: row.content,
     };
     if (params.localID) {
       rawTextMessageInfo = { ...rawTextMessageInfo, localID: params.localID };
     }
     return rawTextMessageInfo;
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawTextMessageInfo {
     let rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       text: clientDBMessageInfo.content ?? '',
     };
     if (clientDBMessageInfo.local_id) {
       rawTextMessageInfo = {
         ...rawTextMessageInfo,
         localID: clientDBMessageInfo.local_id,
       };
     }
     if (clientDBMessageInfo.id !== clientDBMessageInfo.local_id) {
       rawTextMessageInfo = {
         ...rawTextMessageInfo,
         id: clientDBMessageInfo.id,
       };
     }
     return rawTextMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawTextMessageInfo,
     creator: RelativeUserInfo,
   ): TextMessageInfo {
     let messageInfo: TextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       text: rawMessageInfo.text,
     };
     if (rawMessageInfo.id) {
       messageInfo = { ...messageInfo, id: rawMessageInfo.id };
     }
     if (rawMessageInfo.localID) {
       messageInfo = { ...messageInfo, localID: rawMessageInfo.localID };
     }
     return messageInfo;
   },
 
   rawMessageInfoFromMessageData(
     messageData: TextMessageData,
     id: ?string,
   ): RawTextMessageInfo {
     const { sidebarCreation, ...rest } = messageData;
     if (id) {
       return { ...rest, id };
     } else {
       return { ...rest };
     }
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): Promise<?NotifTexts> {
     // We special-case sidebarCreations. Usually we don't send any notifs in
     // that case to avoid a double-notif, but we need to update the original
     // notif if somebody was @-tagged in this message
     if (
       messageInfos.length === 3 &&
       messageInfos[2].type === messageTypes.SIDEBAR_SOURCE &&
       messageInfos[1].type === messageTypes.CREATE_SIDEBAR
     ) {
       const sidebarSourceMessageInfo = messageInfos[2];
       const createSidebarMessageInfo = messageInfos[1];
 
       const sourceMessage = messageInfos[2].sourceMessage;
       const { username } = params.notifTargetUserInfo;
       if (!username) {
         // If we couldn't fetch the username for some reason, we won't be able
         // to extract @-mentions anyways, so we'll give up on updating the notif
         return null;
       }
 
       if (
         sourceMessage.type === messageTypes.TEXT &&
         isUserMentioned(username, sourceMessage.text)
       ) {
         // If the notif target was already mentioned in the source message,
         // there's no need to update the notif
         return null;
       }
 
       const messageInfo = messageInfos[0];
       invariant(
         messageInfo.type === messageTypes.TEXT,
         'messageInfo should be messageTypes.TEXT!',
       );
       if (!isUserMentioned(username, messageInfo.text)) {
         // We only need to update the notif if the notif target is mentioned
         return null;
       }
 
       return notifTextsForSidebarCreation({
         createSidebarMessageInfo,
         sidebarSourceMessageInfo,
         firstSidebarMessageInfo: messageInfo,
         threadInfo,
         params,
       });
     }
 
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.TEXT,
       'messageInfo should be messageTypes.TEXT!',
     );
     const transformedNotificationText = stripSpoilersFromNotifications(
       renderChatMentionsWithAltText(messageInfo.text),
     );
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       const thread = ET.thread({ display: 'uiName', threadInfo });
       return {
         merged: ET`${thread}: ${transformedNotificationText}`,
         body: transformedNotificationText,
         title: threadInfo.uiName,
       };
     } else {
       const creator = ET.user({ userInfo: messageInfo.creator });
       const thread = ET.thread({ display: 'shortName', threadInfo });
       return {
         merged: ET`${creator} to ${thread}: ${transformedNotificationText}`,
         body: transformedNotificationText,
         title: threadInfo.uiName,
         prefix: ET`${creator}:`,
       };
     }
   },
 
   notificationCollapseKey(
     rawMessageInfo: RawTextMessageInfo,
     messageData: TextMessageData,
   ): ?string {
     if (!messageData.sidebarCreation) {
       return null;
     }
     return joinResult(messageTypes.CREATE_SIDEBAR, rawMessageInfo.threadID);
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   includedInRepliesCount: true,
 
   useCreationSideEffectsFunc: () => {
     const dispatchActionPromise = useDispatchActionPromise();
     const callChangeThreadSettings = useChangeThreadSettings();
     return async (
       messageInfo: RawTextMessageInfo,
       threadInfo: ThreadInfo,
       parentThreadInfo: ?ThreadInfo,
     ) => {
       if (threadInfo.type !== threadTypes.SIDEBAR) {
         return;
       }
       invariant(parentThreadInfo, 'all sidebars should have a parent thread');
 
       const mentionedNewMembers = extractNewMentionedParentMembers(
         messageInfo.text,
         threadInfo,
         parentThreadInfo,
       );
 
       if (mentionedNewMembers.length === 0) {
         return;
       }
 
       const newMemberIDs = mentionedNewMembers.map(({ id }) => id);
       const addMembersPromise = callChangeThreadSettings({
         threadID: threadInfo.id,
         changes: { newMemberIDs },
       });
 
-      dispatchActionPromise(changeThreadSettingsActionTypes, addMembersPromise);
+      void dispatchActionPromise(
+        changeThreadSettingsActionTypes,
+        addMembersPromise,
+      );
       await addMembersPromise;
     };
   },
 
   canBeSidebarSource: true,
 
   canBePinned: true,
 
   validator: rawTextMessageInfoValidator,
 });
diff --git a/lib/shared/search-utils.js b/lib/shared/search-utils.js
index ff29ee210..38d1f9e55 100644
--- a/lib/shared/search-utils.js
+++ b/lib/shared/search-utils.js
@@ -1,387 +1,390 @@
 // @flow
 
 import * as React from 'react';
 
 import { messageID } from './message-utils.js';
 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 { ENSCacheContext } from '../components/ens-cache-provider.react.js';
 import genesis from '../facts/genesis.js';
 import type {
   ChatMessageInfoItem,
   MessageListData,
 } from '../selectors/chat-selectors.js';
 import type { MessageInfo, RawMessageInfo } from '../types/message-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 { isValidENSName } from '../utils/ens-helpers.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,
   +inputCommunityThreadInfo?: ?ThreadInfo,
   +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 => {
       if (!containingThreadInfo) {
         return userInfo.relationshipStatus === userRelationshipStatus.FRIEND;
       }
       if (!userInfo.isMemberOfContainingThread) {
         return false;
       }
       const { relationshipStatus } = userInfo;
       if (!relationshipStatus) {
         return true;
       }
       return !blockedRelationshipsStatuses.has(relationshipStatus);
     });
   }
 
   const nonFriends = [];
   const blockedUsers = [];
   const friends = [];
   const containingThreadMembers = [];
   const parentThreadMembers = [];
 
   for (const userResult of userResults) {
     const { relationshipStatus } = userResult;
     if (
       relationshipStatus &&
       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 (
         relationshipStatus &&
         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);
+      void dispatchActionPromise(
+        searchMessagesActionTypes,
+        searchMessagesPromise,
+      );
     },
     [callSearchMessages, dispatchActionPromise],
   );
 }
 
 function useForwardLookupSearchText(originalText: string): string {
   const cacheContext = React.useContext(ENSCacheContext);
   const { ensCache } = cacheContext;
   const lowercaseText = originalText.toLowerCase();
 
   const [usernameToSearch, setUsernameToSearch] =
     React.useState<string>(lowercaseText);
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       if (!ensCache || !isValidENSName(lowercaseText)) {
         setUsernameToSearch(lowercaseText);
         return;
       }
 
       const address = await ensCache.getAddressForName(lowercaseText);
       if (address) {
         setUsernameToSearch(address);
       } else {
         setUsernameToSearch(lowercaseText);
       }
     })();
   }, [ensCache, lowercaseText]);
 
   return usernameToSearch;
 }
 
 function useSearchUsers(
   usernameInputText: string,
 ): $ReadOnlyArray<GlobalAccountUserInfo> {
   const currentUserID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const forwardLookupSearchText = useForwardLookupSearchText(usernameInputText);
 
   const [serverSearchResults, setServerSearchResults] = React.useState<
     $ReadOnlyArray<GlobalAccountUserInfo>,
   >([]);
   const callSearchUsers = useServerCall(searchUsers);
   const dispatchActionPromise = useDispatchActionPromise();
   React.useEffect(() => {
     const searchUsersPromise = (async () => {
       if (forwardLookupSearchText.length === 0) {
         setServerSearchResults([]);
       } else {
         try {
           const { userInfos } = await callSearchUsers(forwardLookupSearchText);
           setServerSearchResults(
             userInfos.filter(({ id }) => id !== currentUserID),
           );
         } catch (err) {
           setServerSearchResults([]);
         }
       }
     })();
-    dispatchActionPromise(searchUsersActionTypes, searchUsersPromise);
+    void dispatchActionPromise(searchUsersActionTypes, searchUsersPromise);
   }, [
     callSearchUsers,
     currentUserID,
     dispatchActionPromise,
     forwardLookupSearchText,
   ]);
 
   return serverSearchResults;
 }
 
 function filterChatMessageInfosForSearch(
   chatMessageInfos: MessageListData,
   translatedSearchResults: $ReadOnlyArray<MessageInfo>,
 ): ?(ChatMessageInfoItem[]) {
   if (!chatMessageInfos) {
     return null;
   }
 
   const idSet = new Set(translatedSearchResults.map(messageID));
 
   const uniqueChatMessageInfoItemsMap = new Map<string, ChatMessageInfoItem>();
   for (const item of chatMessageInfos) {
     if (item.itemType !== 'message' || item.messageInfoType !== 'composable') {
       continue;
     }
     const id = messageID(item.messageInfo);
     if (idSet.has(id)) {
       uniqueChatMessageInfoItemsMap.set(id, item);
     }
   }
 
   const sortedChatMessageInfoItems: ChatMessageInfoItem[] = [];
   for (let i = 0; i < translatedSearchResults.length; i++) {
     const id = messageID(translatedSearchResults[i]);
     const match = uniqueChatMessageInfoItemsMap.get(id);
     if (match) {
       sortedChatMessageInfoItems.push(match);
     }
   }
   return sortedChatMessageInfoItems;
 }
 
 export {
   getPotentialMemberItems,
   notFriendNotice,
   useSearchMessages,
   useSearchUsers,
   filterChatMessageInfosForSearch,
   useForwardLookupSearchText,
 };
diff --git a/lib/shared/thread-utils.js b/lib/shared/thread-utils.js
index dcc753ee3..a00554579 100644
--- a/lib/shared/thread-utils.js
+++ b/lib/shared/thread-utils.js
@@ -1,1823 +1,1823 @@
 // @flow
 
 import invariant from 'invariant';
 import _find from 'lodash/fp/find.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _omitBy from 'lodash/fp/omitBy.js';
 import * as React from 'react';
 
 import { generatePendingThreadColor } from './color-utils.js';
 import { type ParserRules } from './markdown.js';
 import { extractUserMentionsFromText } from './mention-utils.js';
 import { getMessageTitle, isInvalidSidebarSource } from './message-utils.js';
 import { relationshipBlockedInEitherDirection } from './relationship-utils.js';
 import { useForwardLookupSearchText } from './search-utils.js';
 import threadWatcher from './thread-watcher.js';
 import {
   fetchMostRecentMessagesActionTypes,
   useFetchMostRecentMessages,
 } from '../actions/message-actions.js';
 import type { RemoveUsersFromThreadInput } from '../actions/thread-actions';
 import {
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
 } from '../actions/thread-actions.js';
 import { searchUsers as searchUserCall } from '../actions/user-actions.js';
 import ashoat from '../facts/ashoat.js';
 import genesis from '../facts/genesis.js';
 import { useLoggedInUserInfo } from '../hooks/account-hooks.js';
 import {
   hasPermission,
   permissionsToBitmaskHex,
   threadPermissionsFromBitmaskHex,
 } from '../permissions/minimally-encoded-thread-permissions.js';
 import {
   permissionLookup,
   getAllThreadPermissions,
   makePermissionsBlob,
 } from '../permissions/thread-permissions.js';
 import type {
   ChatThreadItem,
   ChatMessageInfoItem,
 } from '../selectors/chat-selectors.js';
 import { useGlobalThreadSearchIndex } from '../selectors/nav-selectors.js';
 import {
   threadInfoSelector,
   pendingToRealizedThreadIDsSelector,
   threadInfosSelectorForThreadType,
 } from '../selectors/thread-selectors.js';
 import {
   getRelativeMemberInfos,
   usersWithPersonalThreadSelector,
 } from '../selectors/user-selectors.js';
 import { getUserAvatarForThread } from '../shared/avatar-utils.js';
 import type { CalendarQuery } from '../types/entry-types.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import {
   type RobotextMessageInfo,
   type ComposableMessageInfo,
 } from '../types/message-types.js';
 import type {
   MinimallyEncodedRawThreadInfo,
   MinimallyEncodedThreadCurrentUserInfo,
   MinimallyEncodedThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import { decodeMinimallyEncodedRoleInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import { userRelationshipStatus } from '../types/relationship-types.js';
 import {
   threadPermissionPropagationPrefixes,
   threadPermissions,
   configurableCommunityPermissions,
   type ThreadPermission,
   type ThreadPermissionsInfo,
   type UserSurfacedPermission,
   threadPermissionFilterPrefixes,
 } from '../types/thread-permission-types.js';
 import {
   type ThreadType,
   threadTypes,
   threadTypeIsCommunityRoot,
   assertThreadType,
 } from '../types/thread-types-enum.js';
 import {
   type LegacyRawThreadInfo,
   type LegacyThreadInfo,
   type MemberInfo,
   type ServerThreadInfo,
   type ThreadCurrentUserInfo,
   type RoleInfo,
   type ServerMemberInfo,
   type ClientNewThreadRequest,
   type NewThreadResult,
   type ChangeThreadSettingsPayload,
   type UserProfileThreadInfo,
   type RelativeMemberInfo,
   type RawThreadInfo,
   type ThreadInfo,
 } from '../types/thread-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { type ClientUpdateInfo } from '../types/update-types.js';
 import type {
   GlobalAccountUserInfo,
   UserInfos,
   AccountUserInfo,
   LoggedInUserInfo,
   UserInfo,
 } from '../types/user-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from '../utils/action-utils.js';
 import type { DispatchActionPromise } from '../utils/action-utils.js';
 import type { GetENSNames } from '../utils/ens-helpers.js';
 import {
   ET,
   entityTextToRawString,
   getEntityTextAsString,
   type ThreadEntity,
   type UserEntity,
 } from '../utils/entity-text.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { firstLine } from '../utils/string-utils.js';
 import { trimText } from '../utils/text-utils.js';
 import { pendingThreadIDRegex } from '../utils/validation-utils.js';
 
 function threadHasPermission(
   threadInfo: ?(ThreadInfo | RawThreadInfo),
   permission: ThreadPermission,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   invariant(
     !permissionsDisabledByBlock.has(permission) || threadInfo?.uiName,
     `${permission} can be disabled by a block, but threadHasPermission can't ` +
       'check for a block on RawThreadInfo. Please pass in ThreadInfo instead!',
   );
   if (threadInfo.minimallyEncoded) {
     return hasPermission(threadInfo.currentUser.permissions, permission);
   }
   return permissionLookup(threadInfo.currentUser.permissions, permission);
 }
 
 function viewerIsMember(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(
     threadInfo &&
     threadInfo.currentUser.role !== null &&
     threadInfo.currentUser.role !== undefined
   );
 }
 
 function threadIsInHome(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && threadInfo.currentUser.subscription.home);
 }
 
 // Can have messages
 function threadInChatList(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return (
     viewerIsMember(threadInfo) &&
     threadHasPermission(threadInfo, threadPermissions.VISIBLE)
   );
 }
 
 function threadIsTopLevel(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return threadInChatList(threadInfo) && threadIsChannel(threadInfo);
 }
 
 function threadIsChannel(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && threadInfo.type !== threadTypes.SIDEBAR);
 }
 
 function threadIsSidebar(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return threadInfo?.type === threadTypes.SIDEBAR;
 }
 
 function threadInBackgroundChatList(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && !threadIsInHome(threadInfo);
 }
 
 function threadInHomeChatList(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && threadIsInHome(threadInfo);
 }
 
 // Can have Calendar entries,
 // does appear as a top-level entity in the thread list
 function threadInFilterList(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
 ): boolean {
   return (
     threadInChatList(threadInfo) &&
     !!threadInfo &&
     threadInfo.type !== threadTypes.SIDEBAR
   );
 }
 
 function userIsMember(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
   userID: string,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   if (threadInfo.id === genesis.id) {
     return true;
   }
   return threadInfo.members.some(member => member.id === userID && member.role);
 }
 
 function threadActualMembers(
   memberInfos: $ReadOnlyArray<MemberInfo | RelativeMemberInfo>,
 ): $ReadOnlyArray<string> {
   return memberInfos
     .filter(memberInfo => memberInfo.role)
     .map(memberInfo => memberInfo.id);
 }
 
 function threadOtherMembers<T: MemberInfo | RelativeMemberInfo>(
   memberInfos: $ReadOnlyArray<T>,
   viewerID: ?string,
 ): $ReadOnlyArray<T> {
   return memberInfos.filter(
     memberInfo => memberInfo.role && memberInfo.id !== viewerID,
   );
 }
 
 function threadMembersWithoutAddedAshoat<T: RawThreadInfo | ThreadInfo>(
   threadInfo: T,
 ): $PropertyType<T, 'members'> {
   if (threadInfo.community !== genesis.id) {
     return threadInfo.members;
   }
   return threadInfo.members.filter(
     member => member.id !== ashoat.id || member.role,
   );
 }
 
 function threadIsGroupChat(threadInfo: ThreadInfo): boolean {
   return threadInfo.members.length > 2;
 }
 
 function threadOrParentThreadIsGroupChat(
   threadInfo: RawThreadInfo | ThreadInfo,
 ) {
   return threadMembersWithoutAddedAshoat(threadInfo).length > 2;
 }
 
 function threadIsPending(threadID: ?string): boolean {
   return !!threadID?.startsWith('pending');
 }
 
 function threadIsPendingSidebar(threadID: ?string): boolean {
   return !!threadID?.startsWith('pending/sidebar/');
 }
 
 function getSingleOtherUser(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
 ): ?string {
   if (!viewerID) {
     return undefined;
   }
   const otherMembers = threadOtherMembers(threadInfo.members, viewerID);
   if (otherMembers.length !== 1) {
     return undefined;
   }
   return otherMembers[0].id;
 }
 
 function getPendingThreadID(
   threadType: ThreadType,
   memberIDs: $ReadOnlyArray<string>,
   sourceMessageID: ?string,
 ): string {
   const pendingThreadKey = sourceMessageID
     ? `sidebar/${sourceMessageID}`
     : [...memberIDs].sort().join('+');
   const pendingThreadTypeString = sourceMessageID ? '' : `type${threadType}/`;
   return `pending/${pendingThreadTypeString}${pendingThreadKey}`;
 }
 
 type PendingThreadIDContents = {
   +threadType: ThreadType,
   +memberIDs: $ReadOnlyArray<string>,
   +sourceMessageID: ?string,
 };
 
 function parsePendingThreadID(
   pendingThreadID: string,
 ): ?PendingThreadIDContents {
   const pendingRegex = new RegExp(`^${pendingThreadIDRegex}$`);
   const pendingThreadIDMatches = pendingRegex.exec(pendingThreadID);
   if (!pendingThreadIDMatches) {
     return null;
   }
   const [threadTypeString, threadKey] = pendingThreadIDMatches[1].split('/');
   const threadType =
     threadTypeString === 'sidebar'
       ? threadTypes.SIDEBAR
       : assertThreadType(Number(threadTypeString.replace('type', '')));
   const memberIDs = threadTypeString === 'sidebar' ? [] : threadKey.split('+');
   const sourceMessageID = threadTypeString === 'sidebar' ? threadKey : null;
   return {
     threadType,
     memberIDs,
     sourceMessageID,
   };
 }
 
 type UserIDAndUsername = {
   +id: string,
   +username: string,
   ...
 };
 type CreatePendingThreadArgs = {
   +viewerID: string,
   +threadType: ThreadType,
   +members: $ReadOnlyArray<UserIDAndUsername>,
   +parentThreadInfo?: ?ThreadInfo,
   +threadColor?: ?string,
   +name?: ?string,
   +sourceMessageID?: string,
 };
 
 function createPendingThread({
   viewerID,
   threadType,
   members,
   parentThreadInfo,
   threadColor,
   name,
   sourceMessageID,
 }: CreatePendingThreadArgs): LegacyThreadInfo {
   const now = Date.now();
   if (!members.some(member => member.id === viewerID)) {
     throw new Error(
       'createPendingThread should be called with the viewer as a member',
     );
   }
 
   const memberIDs = members.map(member => member.id);
   const threadID = getPendingThreadID(threadType, memberIDs, sourceMessageID);
 
   const permissions = {
     [threadPermissions.KNOW_OF]: true,
     [threadPermissions.VISIBLE]: true,
     [threadPermissions.VOICED]: true,
   };
 
   const membershipPermissions = getAllThreadPermissions(
     makePermissionsBlob(permissions, null, threadID, threadType),
     threadID,
   );
   const role = {
     id: `${threadID}/role`,
     name: 'Members',
     permissions,
     isDefault: true,
   };
 
   const rawThreadInfo = {
     id: threadID,
     type: threadType,
     name: name ?? null,
     description: null,
     color: threadColor ?? generatePendingThreadColor(memberIDs),
     creationTime: now,
     parentThreadID: parentThreadInfo?.id ?? null,
     containingThreadID: getContainingThreadID(parentThreadInfo, threadType),
     community: getCommunity(parentThreadInfo),
     members: members.map(member => ({
       id: member.id,
       role: role.id,
       permissions: membershipPermissions,
       isSender: false,
     })),
     roles: {
       [role.id]: role,
     },
     currentUser: {
       role: role.id,
       permissions: membershipPermissions,
       subscription: {
         pushNotifs: false,
         home: false,
       },
       unread: false,
     },
     repliesCount: 0,
     sourceMessageID,
     pinnedCount: 0,
   };
 
   const userInfos: { [string]: UserInfo } = {};
   for (const member of members) {
     const { id, username } = member;
     userInfos[id] = { id, username };
   }
 
   return threadInfoFromRawThreadInfo(rawThreadInfo, viewerID, userInfos);
 }
 
 type PendingPersonalThread = {
   +threadInfo: ThreadInfo,
   +pendingPersonalThreadUserInfo: UserInfo,
 };
 
 function createPendingPersonalThread(
   loggedInUserInfo: LoggedInUserInfo,
   userID: string,
   username: string,
 ): PendingPersonalThread {
   const pendingPersonalThreadUserInfo = {
     id: userID,
     username: username,
   };
 
   const threadInfo = createPendingThread({
     viewerID: loggedInUserInfo.id,
     threadType: threadTypes.PERSONAL,
     members: [loggedInUserInfo, pendingPersonalThreadUserInfo],
   });
 
   return { threadInfo, pendingPersonalThreadUserInfo };
 }
 
 function createPendingThreadItem(
   loggedInUserInfo: LoggedInUserInfo,
   user: UserIDAndUsername,
 ): ChatThreadItem {
   const { threadInfo, pendingPersonalThreadUserInfo } =
     createPendingPersonalThread(loggedInUserInfo, user.id, user.username);
 
   return {
     type: 'chatThreadItem',
     threadInfo,
     mostRecentMessageInfo: null,
     mostRecentNonLocalMessage: null,
     lastUpdatedTime: threadInfo.creationTime,
     lastUpdatedTimeIncludingSidebars: threadInfo.creationTime,
     sidebars: [],
     pendingPersonalThreadUserInfo,
   };
 }
 
 // Returns map from lowercase username to AccountUserInfo
 function memberLowercaseUsernameMap(
   members: $ReadOnlyArray<RelativeMemberInfo>,
 ): Map<string, AccountUserInfo> {
   const memberMap = new Map<string, AccountUserInfo>();
   for (const member of members) {
     const { id, role, username } = member;
     if (!role || !username) {
       continue;
     }
     memberMap.set(username.toLowerCase(), { id, username });
   }
   return memberMap;
 }
 
 // Returns map from user ID to AccountUserInfo
 function extractMentionedMembers(
   text: string,
   threadInfo: ThreadInfo,
 ): Map<string, AccountUserInfo> {
   const memberMap = memberLowercaseUsernameMap(threadInfo.members);
   const mentions = extractUserMentionsFromText(text);
 
   const mentionedMembers = new Map<string, AccountUserInfo>();
   for (const mention of mentions) {
     const userInfo = memberMap.get(mention.toLowerCase());
     if (userInfo) {
       mentionedMembers.set(userInfo.id, userInfo);
     }
   }
   return mentionedMembers;
 }
 
 // When a member of the parent is mentioned in a sidebar,
 // they will be automatically added to that sidebar
 function extractNewMentionedParentMembers(
   messageText: string,
   threadInfo: ThreadInfo,
   parentThreadInfo: ThreadInfo,
 ): AccountUserInfo[] {
   const mentionedMembersOfParent = extractMentionedMembers(
     messageText,
     parentThreadInfo,
   );
   for (const member of threadInfo.members) {
     if (member.role) {
       mentionedMembersOfParent.delete(member.id);
     }
   }
   return [...mentionedMembersOfParent.values()];
 }
 
 type SharedCreatePendingSidebarInput = {
   +sourceMessageInfo: ComposableMessageInfo | RobotextMessageInfo,
   +parentThreadInfo: ThreadInfo,
   +loggedInUserInfo: LoggedInUserInfo,
 };
 
 type BaseCreatePendingSidebarInput = {
   ...SharedCreatePendingSidebarInput,
   +messageTitle: string,
 };
 function baseCreatePendingSidebar(
   input: BaseCreatePendingSidebarInput,
 ): LegacyThreadInfo {
   const {
     sourceMessageInfo,
     parentThreadInfo,
     loggedInUserInfo,
     messageTitle,
   } = input;
   const { color, type: parentThreadType } = parentThreadInfo;
   const threadName = trimText(messageTitle, 30);
 
   const initialMembers = new Map<string, UserIDAndUsername>();
 
   const { id: viewerID, username: viewerUsername } = loggedInUserInfo;
   initialMembers.set(viewerID, { id: viewerID, username: viewerUsername });
 
   if (userIsMember(parentThreadInfo, sourceMessageInfo.creator.id)) {
     const { id: sourceAuthorID, username: sourceAuthorUsername } =
       sourceMessageInfo.creator;
     invariant(
       sourceAuthorUsername,
       'sourceAuthorUsername should be set in createPendingSidebar',
     );
     const initialMemberUserInfo = {
       id: sourceAuthorID,
       username: sourceAuthorUsername,
     };
     initialMembers.set(sourceAuthorID, initialMemberUserInfo);
   }
 
   const singleOtherUser = getSingleOtherUser(parentThreadInfo, viewerID);
   if (parentThreadType === threadTypes.PERSONAL && singleOtherUser) {
     const singleOtherUsername = parentThreadInfo.members.find(
       member => member.id === singleOtherUser,
     )?.username;
     invariant(
       singleOtherUsername,
       'singleOtherUsername should be set in createPendingSidebar',
     );
     const singleOtherUserInfo = {
       id: singleOtherUser,
       username: singleOtherUsername,
     };
     initialMembers.set(singleOtherUser, singleOtherUserInfo);
   }
 
   if (sourceMessageInfo.type === messageTypes.TEXT) {
     const mentionedMembersOfParent = extractMentionedMembers(
       sourceMessageInfo.text,
       parentThreadInfo,
     );
     for (const [memberID, member] of mentionedMembersOfParent) {
       initialMembers.set(memberID, member);
     }
   }
 
   return createPendingThread({
     viewerID,
     threadType: threadTypes.SIDEBAR,
     members: [...initialMembers.values()],
     parentThreadInfo,
     threadColor: color,
     name: threadName,
     sourceMessageID: sourceMessageInfo.id,
   });
 }
 
 // The message title here may have ETH addresses that aren't resolved to ENS
 // names. This function should only be used in cases where we're sure that we
 // don't care about the thread title. We should prefer createPendingSidebar
 // wherever possible
 type CreateUnresolvedPendingSidebarInput = {
   ...SharedCreatePendingSidebarInput,
   +markdownRules: ParserRules,
 };
 function createUnresolvedPendingSidebar(
   input: CreateUnresolvedPendingSidebarInput,
 ): LegacyThreadInfo {
   const {
     sourceMessageInfo,
     parentThreadInfo,
     loggedInUserInfo,
     markdownRules,
   } = input;
 
   const messageTitleEntityText = getMessageTitle(
     sourceMessageInfo,
     parentThreadInfo,
     parentThreadInfo,
     markdownRules,
   );
   const messageTitle = entityTextToRawString(messageTitleEntityText, {
     ignoreViewer: true,
   });
 
   return baseCreatePendingSidebar({
     sourceMessageInfo,
     parentThreadInfo,
     messageTitle,
     loggedInUserInfo,
   });
 }
 
 type CreatePendingSidebarInput = {
   ...SharedCreatePendingSidebarInput,
   +markdownRules: ParserRules,
   +getENSNames: ?GetENSNames,
 };
 async function createPendingSidebar(
   input: CreatePendingSidebarInput,
 ): Promise<LegacyThreadInfo> {
   const {
     sourceMessageInfo,
     parentThreadInfo,
     loggedInUserInfo,
     markdownRules,
     getENSNames,
   } = input;
 
   const messageTitleEntityText = getMessageTitle(
     sourceMessageInfo,
     parentThreadInfo,
     parentThreadInfo,
     markdownRules,
   );
   const messageTitle = await getEntityTextAsString(
     messageTitleEntityText,
     getENSNames,
     { ignoreViewer: true },
   );
   invariant(
     messageTitle !== null && messageTitle !== undefined,
     'getEntityTextAsString only returns falsey when passed falsey',
   );
 
   return baseCreatePendingSidebar({
     sourceMessageInfo,
     parentThreadInfo,
     messageTitle,
     loggedInUserInfo,
   });
 }
 
 function pendingThreadType(numberOfOtherMembers: number): 4 | 6 | 7 {
   if (numberOfOtherMembers === 0) {
     return threadTypes.PRIVATE;
   } else if (numberOfOtherMembers === 1) {
     return threadTypes.PERSONAL;
   } else {
     return threadTypes.LOCAL;
   }
 }
 
 function threadTypeCanBePending(threadType: ThreadType): boolean {
   return (
     threadType === threadTypes.PERSONAL ||
     threadType === threadTypes.LOCAL ||
     threadType === threadTypes.SIDEBAR ||
     threadType === threadTypes.PRIVATE
   );
 }
 
 type CreateRealThreadParameters = {
   +threadInfo: ThreadInfo,
   +dispatchActionPromise: DispatchActionPromise,
   +createNewThread: ClientNewThreadRequest => Promise<NewThreadResult>,
   +sourceMessageID: ?string,
   +viewerID: ?string,
   +handleError?: () => mixed,
   +calendarQuery: CalendarQuery,
 };
 async function createRealThreadFromPendingThread({
   threadInfo,
   dispatchActionPromise,
   createNewThread,
   sourceMessageID,
   viewerID,
   calendarQuery,
 }: CreateRealThreadParameters): Promise<string> {
   if (!threadIsPending(threadInfo.id)) {
     return threadInfo.id;
   }
 
   const otherMemberIDs = threadOtherMembers(threadInfo.members, viewerID).map(
     member => member.id,
   );
   let resultPromise;
   if (threadInfo.type !== threadTypes.SIDEBAR) {
     invariant(
       otherMemberIDs.length > 0,
       'otherMemberIDs should not be empty for threads',
     );
     resultPromise = createNewThread({
       type: pendingThreadType(otherMemberIDs.length),
       initialMemberIDs: otherMemberIDs,
       color: threadInfo.color,
       calendarQuery,
     });
   } else {
     invariant(
       sourceMessageID,
       'sourceMessageID should be set when creating a sidebar',
     );
     resultPromise = createNewThread({
       type: threadTypes.SIDEBAR,
       initialMemberIDs: otherMemberIDs,
       color: threadInfo.color,
       sourceMessageID,
       parentThreadID: threadInfo.parentThreadID,
       name: threadInfo.name,
       calendarQuery,
     });
   }
-  dispatchActionPromise(newThreadActionTypes, resultPromise);
+  void dispatchActionPromise(newThreadActionTypes, resultPromise);
   const { newThreadID } = await resultPromise;
   return newThreadID;
 }
 
 type RawThreadInfoOptions = {
   +filterThreadEditAvatarPermission?: boolean,
   +excludePinInfo?: boolean,
   +filterManageInviteLinksPermission?: boolean,
   +filterVoicedInAnnouncementChannelsPermission?: boolean,
 };
 function rawThreadInfoFromServerThreadInfo(
   serverThreadInfo: ServerThreadInfo,
   viewerID: string,
   options?: RawThreadInfoOptions,
 ): ?LegacyRawThreadInfo {
   const filterThreadEditAvatarPermission =
     options?.filterThreadEditAvatarPermission;
   const excludePinInfo = options?.excludePinInfo;
   const filterManageInviteLinksPermission =
     options?.filterManageInviteLinksPermission;
   const filterVoicedInAnnouncementChannelsPermission =
     options?.filterVoicedInAnnouncementChannelsPermission;
 
   const filterThreadPermissions = _omitBy(
     (v, k) =>
       (filterThreadEditAvatarPermission &&
         [
           threadPermissions.EDIT_THREAD_AVATAR,
           threadPermissionPropagationPrefixes.DESCENDANT +
             threadPermissions.EDIT_THREAD_AVATAR,
         ].includes(k)) ||
       (excludePinInfo &&
         [
           threadPermissions.MANAGE_PINS,
           threadPermissionPropagationPrefixes.DESCENDANT +
             threadPermissions.MANAGE_PINS,
         ].includes(k)) ||
       (filterManageInviteLinksPermission &&
         [threadPermissions.MANAGE_INVITE_LINKS].includes(k)) ||
       (filterVoicedInAnnouncementChannelsPermission &&
         [
           threadPermissions.VOICED_IN_ANNOUNCEMENT_CHANNELS,
           threadPermissionPropagationPrefixes.DESCENDANT +
             threadPermissionFilterPrefixes.TOP_LEVEL +
             threadPermissions.VOICED_IN_ANNOUNCEMENT_CHANNELS,
         ].includes(k)),
   );
 
   const members = [];
   let currentUser;
   for (const serverMember of serverThreadInfo.members) {
     if (
       serverThreadInfo.id === genesis.id &&
       serverMember.id !== viewerID &&
       serverMember.id !== ashoat.id
     ) {
       continue;
     }
 
     const memberPermissions = filterThreadPermissions(serverMember.permissions);
 
     members.push({
       id: serverMember.id,
       role: serverMember.role,
       permissions: memberPermissions,
       isSender: serverMember.isSender,
     });
     if (serverMember.id === viewerID) {
       currentUser = {
         role: serverMember.role,
         permissions: memberPermissions,
         subscription: serverMember.subscription,
         unread: serverMember.unread,
       };
     }
   }
 
   let currentUserPermissions;
   if (currentUser) {
     currentUserPermissions = currentUser.permissions;
   } else {
     currentUserPermissions = filterThreadPermissions(
       getAllThreadPermissions(null, serverThreadInfo.id),
     );
     currentUser = {
       role: null,
       permissions: currentUserPermissions,
       subscription: {
         home: false,
         pushNotifs: false,
       },
       unread: null,
     };
   }
   if (!permissionLookup(currentUserPermissions, threadPermissions.KNOW_OF)) {
     return null;
   }
 
   const rolesWithFilteredThreadPermissions = _mapValues(role => ({
     ...role,
     permissions: filterThreadPermissions(role.permissions),
   }))(serverThreadInfo.roles);
 
   let rawThreadInfo: any = {
     id: serverThreadInfo.id,
     type: serverThreadInfo.type,
     name: serverThreadInfo.name,
     description: serverThreadInfo.description,
     color: serverThreadInfo.color,
     creationTime: serverThreadInfo.creationTime,
     parentThreadID: serverThreadInfo.parentThreadID,
     members,
     roles: rolesWithFilteredThreadPermissions,
     currentUser,
     repliesCount: serverThreadInfo.repliesCount,
     containingThreadID: serverThreadInfo.containingThreadID,
     community: serverThreadInfo.community,
   };
   const sourceMessageID = serverThreadInfo.sourceMessageID;
   if (sourceMessageID) {
     rawThreadInfo = { ...rawThreadInfo, sourceMessageID };
   }
   if (serverThreadInfo.avatar) {
     rawThreadInfo = { ...rawThreadInfo, avatar: serverThreadInfo.avatar };
   }
   if (!excludePinInfo) {
     return {
       ...rawThreadInfo,
       pinnedCount: serverThreadInfo.pinnedCount,
     };
   }
   return rawThreadInfo;
 }
 
 function threadUIName(threadInfo: ThreadInfo): string | ThreadEntity {
   if (threadInfo.name) {
     return firstLine(threadInfo.name);
   }
 
   let threadMembers: $ReadOnlyArray<RelativeMemberInfo>;
   let memberEntities: $ReadOnlyArray<UserEntity>;
   // Branching below is to appease flow
   if (threadInfo.minimallyEncoded) {
     threadMembers = threadInfo.members.filter(memberInfo => memberInfo.role);
     memberEntities = threadMembers.map(member => ET.user({ userInfo: member }));
   } else {
     threadMembers = threadInfo.members.filter(memberInfo => memberInfo.role);
     memberEntities = threadMembers.map(member => ET.user({ userInfo: member }));
   }
 
   return {
     type: 'thread',
     id: threadInfo.id,
     name: threadInfo.name,
     display: 'uiName',
     uiName: memberEntities,
     ifJustViewer:
       threadInfo.type === threadTypes.PRIVATE
         ? 'viewer_username'
         : 'just_you_string',
   };
 }
 
 function threadInfoFromRawThreadInfo(
   rawThreadInfo: LegacyRawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): LegacyThreadInfo {
   let threadInfo: LegacyThreadInfo = {
     id: rawThreadInfo.id,
     type: rawThreadInfo.type,
     name: rawThreadInfo.name,
     uiName: '',
     description: rawThreadInfo.description,
     color: rawThreadInfo.color,
     creationTime: rawThreadInfo.creationTime,
     parentThreadID: rawThreadInfo.parentThreadID,
     containingThreadID: rawThreadInfo.containingThreadID,
     community: rawThreadInfo.community,
     members: getRelativeMemberInfos(rawThreadInfo, viewerID, userInfos),
     roles: rawThreadInfo.roles,
     currentUser: getCurrentUser(rawThreadInfo, viewerID, userInfos),
     repliesCount: rawThreadInfo.repliesCount,
   };
   threadInfo = {
     ...threadInfo,
     uiName: threadUIName(threadInfo),
   };
   const { sourceMessageID, avatar, pinnedCount } = rawThreadInfo;
   if (sourceMessageID) {
     threadInfo = { ...threadInfo, sourceMessageID };
   }
 
   if (avatar) {
     threadInfo = { ...threadInfo, avatar };
   } else if (
     rawThreadInfo.type === threadTypes.PERSONAL ||
     rawThreadInfo.type === threadTypes.PRIVATE
   ) {
     threadInfo = {
       ...threadInfo,
       avatar: getUserAvatarForThread(rawThreadInfo, viewerID, userInfos),
     };
   }
 
   if (pinnedCount) {
     threadInfo = { ...threadInfo, pinnedCount };
   }
 
   return threadInfo;
 }
 
 function getCurrentUser(
   threadInfo: LegacyRawThreadInfo | LegacyThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): ThreadCurrentUserInfo {
   if (!threadFrozenDueToBlock(threadInfo, viewerID, userInfos)) {
     return threadInfo.currentUser;
   }
 
   return {
     ...threadInfo.currentUser,
     permissions: {
       ...threadInfo.currentUser.permissions,
       ...disabledPermissions,
     },
   };
 }
 
 function getMinimallyEncodedCurrentUser(
   threadInfo: MinimallyEncodedRawThreadInfo | MinimallyEncodedThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): MinimallyEncodedThreadCurrentUserInfo {
   if (!threadFrozenDueToBlock(threadInfo, viewerID, userInfos)) {
     return threadInfo.currentUser;
   }
   const decodedPermissions = threadPermissionsFromBitmaskHex(
     threadInfo.currentUser.permissions,
   );
   const updatedPermissions = {
     ...decodedPermissions,
     ...disabledPermissions,
   };
   const encodedUpdatedPermissions = permissionsToBitmaskHex(updatedPermissions);
   return {
     ...threadInfo.currentUser,
     permissions: encodedUpdatedPermissions,
   };
 }
 
 function threadIsWithBlockedUserOnly(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock?: boolean,
 ): boolean {
   if (
     threadOrParentThreadIsGroupChat(threadInfo) ||
     threadOrParentThreadHasAdminRole(threadInfo)
   ) {
     return false;
   }
 
   const otherUserID = getSingleOtherUser(threadInfo, viewerID);
   if (!otherUserID) {
     return false;
   }
   const otherUserRelationshipStatus =
     userInfos[otherUserID]?.relationshipStatus;
 
   if (checkOnlyViewerBlock) {
     return (
       otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_BY_VIEWER
     );
   }
 
   return (
     !!otherUserRelationshipStatus &&
     relationshipBlockedInEitherDirection(otherUserRelationshipStatus)
   );
 }
 
 function threadFrozenDueToBlock(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   return threadIsWithBlockedUserOnly(threadInfo, viewerID, userInfos);
 }
 
 function threadFrozenDueToViewerBlock(
   threadInfo: RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   return threadIsWithBlockedUserOnly(threadInfo, viewerID, userInfos, true);
 }
 
 const threadTypeDescriptions: { [ThreadType]: string } = {
   [threadTypes.COMMUNITY_OPEN_SUBTHREAD]:
     'Anybody in the parent channel can see an open subchannel.',
   [threadTypes.COMMUNITY_SECRET_SUBTHREAD]:
     'Only visible to its members and admins of ancestor channels.',
 };
 
 function memberIsAdmin(
   memberInfo: RelativeMemberInfo | MemberInfo,
   threadInfo: RawThreadInfo | ThreadInfo,
 ): boolean {
   return !!(
     memberInfo.role && roleIsAdminRole(threadInfo.roles[memberInfo.role])
   );
 }
 
 // Since we don't have access to all of the ancestor ThreadInfos, we approximate
 // "parent admin" as anybody with CHANGE_ROLE permissions.
 function memberHasAdminPowers(
   memberInfo: RelativeMemberInfo | MemberInfo | ServerMemberInfo,
 ): boolean {
   if (memberInfo.minimallyEncoded) {
     return hasPermission(memberInfo.permissions, threadPermissions.CHANGE_ROLE);
   }
   return !!memberInfo.permissions[threadPermissions.CHANGE_ROLE]?.value;
 }
 
 function roleIsAdminRole(roleInfo: ?RoleInfo): boolean {
   return !!(roleInfo && !roleInfo.isDefault && roleInfo.name === 'Admins');
 }
 
 function threadHasAdminRole(
   threadInfo: ?(RawThreadInfo | ThreadInfo | ServerThreadInfo),
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   return !!_find({ name: 'Admins' })(threadInfo.roles);
 }
 
 function threadOrParentThreadHasAdminRole(
   threadInfo: RawThreadInfo | ThreadInfo,
 ) {
   return (
     threadMembersWithoutAddedAshoat(threadInfo).filter(member =>
       memberHasAdminPowers(member),
     ).length > 0
   );
 }
 
 function identifyInvalidatedThreads(
   updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
 ): Set<string> {
   const invalidated = new Set<string>();
   for (const updateInfo of updateInfos) {
     if (updateInfo.type === updateTypes.DELETE_THREAD) {
       invalidated.add(updateInfo.threadID);
     }
   }
   return invalidated;
 }
 
 const permissionsDisabledByBlockArray = [
   threadPermissions.VOICED,
   threadPermissions.EDIT_ENTRIES,
   threadPermissions.EDIT_THREAD_NAME,
   threadPermissions.EDIT_THREAD_COLOR,
   threadPermissions.EDIT_THREAD_DESCRIPTION,
   threadPermissions.CREATE_SUBCHANNELS,
   threadPermissions.CREATE_SIDEBARS,
   threadPermissions.JOIN_THREAD,
   threadPermissions.EDIT_PERMISSIONS,
   threadPermissions.ADD_MEMBERS,
   threadPermissions.REMOVE_MEMBERS,
 ];
 
 const permissionsDisabledByBlock: Set<ThreadPermission> = new Set(
   permissionsDisabledByBlockArray,
 );
 
 const disabledPermissions: ThreadPermissionsInfo =
   permissionsDisabledByBlockArray.reduce(
     (permissions: ThreadPermissionsInfo, permission: string) => ({
       ...permissions,
       [permission]: { value: false, source: null },
     }),
     {},
   );
 
 // Consider updating itemHeight in native/chat/chat-thread-list.react.js
 // if you change this
 const emptyItemText: string =
   `Background chats are just like normal chats, except they don't ` +
   `contribute to your unread count.\n\n` +
   `To move a chat over here, switch the “Background” option in its settings.`;
 
 function threadNoun(threadType: ThreadType, parentThreadID: ?string): string {
   if (threadType === threadTypes.SIDEBAR) {
     return 'thread';
   } else if (
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD &&
     parentThreadID === genesis.id
   ) {
     return 'chat';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.GENESIS
   ) {
     return 'channel';
   } else {
     return 'chat';
   }
 }
 
 function threadLabel(threadType: ThreadType): string {
   if (
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD
   ) {
     return 'Open';
   } else if (threadType === threadTypes.PERSONAL) {
     return 'Personal';
   } else if (threadType === threadTypes.SIDEBAR) {
     return 'Thread';
   } else if (threadType === threadTypes.PRIVATE) {
     return 'Private';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.GENESIS
   ) {
     return 'Community';
   } else {
     return 'Secret';
   }
 }
 
 function useWatchThread(threadInfo: ?ThreadInfo) {
   const dispatchActionPromise = useDispatchActionPromise();
   const callFetchMostRecentMessages = useFetchMostRecentMessages();
 
   const threadID = threadInfo?.id;
   const threadNotInChatList = !threadInChatList(threadInfo);
   React.useEffect(() => {
     if (threadID && threadNotInChatList) {
       threadWatcher.watchID(threadID);
-      dispatchActionPromise(
+      void dispatchActionPromise(
         fetchMostRecentMessagesActionTypes,
         callFetchMostRecentMessages({ threadID }),
       );
     }
     return () => {
       if (threadID && threadNotInChatList) {
         threadWatcher.removeID(threadID);
       }
     };
   }, [
     callFetchMostRecentMessages,
     dispatchActionPromise,
     threadNotInChatList,
     threadID,
   ]);
 }
 
 type ExistingThreadInfoFinderParams = {
   +searching: boolean,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
 };
 type ExistingThreadInfoFinder = (
   params: ExistingThreadInfoFinderParams,
 ) => ?ThreadInfo;
 // TODO (atul): Parameterize function once `createPendingThread` is updated.
 function useExistingThreadInfoFinder(
   baseThreadInfo: ?ThreadInfo,
 ): ExistingThreadInfoFinder {
   const threadInfos = useSelector(threadInfoSelector);
   const loggedInUserInfo = useLoggedInUserInfo();
   const userInfos = useSelector(state => state.userStore.userInfos);
 
   const pendingToRealizedThreadIDs = useSelector(state =>
     pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
   );
   return React.useCallback(
     (params: ExistingThreadInfoFinderParams): ?ThreadInfo => {
       if (!baseThreadInfo) {
         return null;
       }
 
       const realizedThreadInfo = threadInfos[baseThreadInfo.id];
       if (realizedThreadInfo) {
         return realizedThreadInfo;
       }
 
       if (!loggedInUserInfo || !threadIsPending(baseThreadInfo.id)) {
         return baseThreadInfo;
       }
       const viewerID = loggedInUserInfo?.id;
 
       invariant(
         threadTypeCanBePending(baseThreadInfo.type),
         `ThreadInfo has pending ID ${baseThreadInfo.id}, but type that ` +
           `should not be pending ${baseThreadInfo.type}`,
       );
 
       const { searching, userInfoInputArray } = params;
 
       const { sourceMessageID } = baseThreadInfo;
       const pendingThreadID = searching
         ? getPendingThreadID(
             pendingThreadType(userInfoInputArray.length),
             [...userInfoInputArray.map(user => user.id), viewerID],
             sourceMessageID,
           )
         : getPendingThreadID(
             baseThreadInfo.type,
             baseThreadInfo.members.map(member => member.id),
             sourceMessageID,
           );
 
       const realizedThreadID = pendingToRealizedThreadIDs.get(pendingThreadID);
       if (realizedThreadID && threadInfos[realizedThreadID]) {
         return threadInfos[realizedThreadID];
       }
 
       const updatedThread = searching
         ? createPendingThread({
             viewerID,
             threadType: pendingThreadType(userInfoInputArray.length),
             members: [loggedInUserInfo, ...userInfoInputArray],
           })
         : baseThreadInfo;
 
       if (updatedThread.minimallyEncoded) {
         return {
           ...updatedThread,
           currentUser: getMinimallyEncodedCurrentUser(
             updatedThread,
             viewerID,
             userInfos,
           ),
         };
       } else {
         return {
           ...updatedThread,
           currentUser: getCurrentUser(updatedThread, viewerID, userInfos),
         };
       }
     },
     [
       baseThreadInfo,
       threadInfos,
       loggedInUserInfo,
       pendingToRealizedThreadIDs,
       userInfos,
     ],
   );
 }
 
 type ThreadTypeParentRequirement = 'optional' | 'required' | 'disabled';
 function getThreadTypeParentRequirement(
   threadType: ThreadType,
 ): ThreadTypeParentRequirement {
   if (
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD ||
     //threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.SIDEBAR
   ) {
     return 'required';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.GENESIS ||
     threadType === threadTypes.PERSONAL ||
     threadType === threadTypes.PRIVATE
   ) {
     return 'disabled';
   } else {
     return 'optional';
   }
 }
 
 function threadMemberHasPermission(
   threadInfo: ServerThreadInfo | RawThreadInfo | ThreadInfo,
   memberID: string,
   permission: ThreadPermission,
 ): boolean {
   for (const member of threadInfo.members) {
     if (member.id !== memberID) {
       continue;
     }
     if (member.minimallyEncoded) {
       return hasPermission(member.permissions, permission);
     }
     return permissionLookup(member.permissions, permission);
   }
   return false;
 }
 
 function useCanCreateSidebarFromMessage(
   threadInfo: ThreadInfo,
   messageInfo: ComposableMessageInfo | RobotextMessageInfo,
 ): boolean {
   const messageCreatorUserInfo = useSelector(
     state => state.userStore.userInfos[messageInfo.creator.id],
   );
 
   if (
     !messageInfo.id ||
     threadInfo.sourceMessageID === messageInfo.id ||
     isInvalidSidebarSource(messageInfo)
   ) {
     return false;
   }
 
   const messageCreatorRelationship = messageCreatorUserInfo?.relationshipStatus;
   const creatorRelationshipHasBlock =
     messageCreatorRelationship &&
     relationshipBlockedInEitherDirection(messageCreatorRelationship);
 
   const hasCreateSidebarsPermission = threadHasPermission(
     threadInfo,
     threadPermissions.CREATE_SIDEBARS,
   );
 
   return hasCreateSidebarsPermission && !creatorRelationshipHasBlock;
 }
 
 function useSidebarExistsOrCanBeCreated(
   threadInfo: ThreadInfo,
   messageItem: ChatMessageInfoItem,
 ): boolean {
   const canCreateSidebarFromMessage = useCanCreateSidebarFromMessage(
     threadInfo,
     messageItem.messageInfo,
   );
   return !!messageItem.threadCreatedFromMessage || canCreateSidebarFromMessage;
 }
 
 function checkIfDefaultMembersAreVoiced(threadInfo: ThreadInfo): boolean {
   const defaultRoleID = Object.keys(threadInfo.roles).find(
     roleID => threadInfo.roles[roleID].isDefault,
   );
   invariant(
     defaultRoleID !== undefined,
     'all threads should have a default role',
   );
   const defaultRole = threadInfo.roles[defaultRoleID];
   const defaultRolePermissions = defaultRole.minimallyEncoded
     ? decodeMinimallyEncodedRoleInfo(defaultRole).permissions
     : defaultRole.permissions;
 
   return !!defaultRolePermissions[threadPermissions.VOICED];
 }
 
 const draftKeySuffix = '/message_composer';
 
 function draftKeyFromThreadID(threadID: string): string {
   return `${threadID}${draftKeySuffix}`;
 }
 
 function getContainingThreadID(
   parentThreadInfo: ?ServerThreadInfo | RawThreadInfo | ThreadInfo,
   threadType: ThreadType,
 ): ?string {
   if (!parentThreadInfo) {
     return null;
   }
   if (threadType === threadTypes.SIDEBAR) {
     return parentThreadInfo.id;
   }
   if (!parentThreadInfo.containingThreadID) {
     return parentThreadInfo.id;
   }
   return parentThreadInfo.containingThreadID;
 }
 
 function getCommunity(
   parentThreadInfo: ?ServerThreadInfo | RawThreadInfo | ThreadInfo,
 ): ?string {
   if (!parentThreadInfo) {
     return null;
   }
   const { id, community, type } = parentThreadInfo;
   if (community !== null && community !== undefined) {
     return community;
   }
   if (threadTypeIsCommunityRoot(type)) {
     return id;
   }
   return null;
 }
 
 function getThreadListSearchResults(
   chatListData: $ReadOnlyArray<ChatThreadItem>,
   searchText: string,
   threadFilter: ThreadInfo => boolean,
   threadSearchResults: $ReadOnlySet<string>,
   usersSearchResults: $ReadOnlyArray<GlobalAccountUserInfo>,
   loggedInUserInfo: ?LoggedInUserInfo,
 ): $ReadOnlyArray<ChatThreadItem> {
   if (!searchText) {
     return chatListData.filter(
       item =>
         threadIsTopLevel(item.threadInfo) && threadFilter(item.threadInfo),
     );
   }
 
   const privateThreads = [];
   const personalThreads = [];
   const otherThreads = [];
   for (const item of chatListData) {
     if (!threadSearchResults.has(item.threadInfo.id)) {
       continue;
     }
     if (item.threadInfo.type === threadTypes.PRIVATE) {
       privateThreads.push({ ...item, sidebars: [] });
     } else if (item.threadInfo.type === threadTypes.PERSONAL) {
       personalThreads.push({ ...item, sidebars: [] });
     } else {
       otherThreads.push({ ...item, sidebars: [] });
     }
   }
 
   const chatItems: ChatThreadItem[] = [
     ...privateThreads,
     ...personalThreads,
     ...otherThreads,
   ];
   if (loggedInUserInfo) {
     chatItems.push(
       ...usersSearchResults.map(user =>
         createPendingThreadItem(loggedInUserInfo, user),
       ),
     );
   }
   return chatItems;
 }
 
 type ThreadListSearchResult = {
   +threadSearchResults: $ReadOnlySet<string>,
   +usersSearchResults: $ReadOnlyArray<GlobalAccountUserInfo>,
 };
 function useThreadListSearch(
   searchText: string,
   viewerID: ?string,
 ): ThreadListSearchResult {
   const callSearchUsers = useServerCall(searchUserCall);
   const usersWithPersonalThread = useSelector(usersWithPersonalThreadSelector);
   const forwardLookupSearchText = useForwardLookupSearchText(searchText);
   const searchUsers = React.useCallback(
     async (usernamePrefix: string) => {
       if (usernamePrefix.length === 0) {
         return ([]: GlobalAccountUserInfo[]);
       }
 
       const { userInfos } = await callSearchUsers(usernamePrefix);
       return userInfos.filter(
         info => !usersWithPersonalThread.has(info.id) && info.id !== viewerID,
       );
     },
     [callSearchUsers, usersWithPersonalThread, viewerID],
   );
 
   const [threadSearchResults, setThreadSearchResults] = React.useState(
     new Set<string>(),
   );
   const [usersSearchResults, setUsersSearchResults] = React.useState<
     $ReadOnlyArray<GlobalAccountUserInfo>,
   >([]);
   const threadSearchIndex = useGlobalThreadSearchIndex();
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       const results = threadSearchIndex.getSearchResults(searchText);
       setThreadSearchResults(new Set<string>(results));
       const usersResults = await searchUsers(forwardLookupSearchText);
       setUsersSearchResults(usersResults);
     })();
   }, [searchText, forwardLookupSearchText, threadSearchIndex, searchUsers]);
 
   return { threadSearchResults, usersSearchResults };
 }
 
 function removeMemberFromThread(
   threadInfo: ThreadInfo,
   memberInfo: RelativeMemberInfo,
   dispatchActionPromise: DispatchActionPromise,
   removeUserFromThreadServerCall: (
     input: RemoveUsersFromThreadInput,
   ) => Promise<ChangeThreadSettingsPayload>,
 ) {
   const customKeyName = `${removeUsersFromThreadActionTypes.started}:${memberInfo.id}`;
-  dispatchActionPromise(
+  void dispatchActionPromise(
     removeUsersFromThreadActionTypes,
     removeUserFromThreadServerCall({
       threadID: threadInfo.id,
       memberIDs: [memberInfo.id],
     }),
     { customKeyName },
   );
 }
 
 function getAvailableThreadMemberActions(
   memberInfo: RelativeMemberInfo,
   threadInfo: ThreadInfo,
   canEdit: ?boolean = true,
 ): $ReadOnlyArray<'change_role' | 'remove_user'> {
   const role = memberInfo.role;
   if (!canEdit || !role) {
     return [];
   }
 
   const canRemoveMembers = threadHasPermission(
     threadInfo,
     threadPermissions.REMOVE_MEMBERS,
   );
   const canChangeRoles = threadHasPermission(
     threadInfo,
     threadPermissions.CHANGE_ROLE,
   );
 
   const result = [];
 
   if (canChangeRoles && memberInfo.username && threadHasAdminRole(threadInfo)) {
     result.push('change_role');
   }
 
   if (
     canRemoveMembers &&
     !memberInfo.isViewer &&
     (canChangeRoles || threadInfo.roles[role]?.isDefault)
   ) {
     result.push('remove_user');
   }
 
   return result;
 }
 
 function patchThreadInfoToIncludeMentionedMembersOfParent(
   threadInfo: ThreadInfo,
   parentThreadInfo: ThreadInfo,
   messageText: string,
   viewerID: string,
 ): ThreadInfo {
   const members: UserIDAndUsername[] = threadInfo.members
     .map(({ id, username }) =>
       username ? ({ id, username }: UserIDAndUsername) : null,
     )
     .filter(Boolean);
   const mentionedNewMembers = extractNewMentionedParentMembers(
     messageText,
     threadInfo,
     parentThreadInfo,
   );
   if (mentionedNewMembers.length === 0) {
     return threadInfo;
   }
   members.push(...mentionedNewMembers);
   return createPendingThread({
     viewerID,
     threadType: threadTypes.SIDEBAR,
     members,
     parentThreadInfo,
     threadColor: threadInfo.color,
     name: threadInfo.name,
     sourceMessageID: threadInfo.sourceMessageID,
   });
 }
 
 function threadInfoInsideCommunity(
   threadInfo: RawThreadInfo | ThreadInfo,
   communityID: string,
 ): boolean {
   return threadInfo.community === communityID || threadInfo.id === communityID;
 }
 
 type RoleAndMemberCount = {
   [roleName: string]: number,
 };
 
 function useRoleMemberCountsForCommunity(
   threadInfo: ThreadInfo,
 ): RoleAndMemberCount {
   return React.useMemo(() => {
     const roleIDsToNames: { [string]: string } = {};
 
     Object.keys(threadInfo.roles).forEach(roleID => {
       roleIDsToNames[roleID] = threadInfo.roles[roleID].name;
     });
 
     const roleNamesToMemberCount: RoleAndMemberCount = {};
 
     threadInfo.members.forEach(({ role: roleID }) => {
       invariant(roleID, 'Community member should have a role');
       const roleName = roleIDsToNames[roleID];
 
       roleNamesToMemberCount[roleName] =
         (roleNamesToMemberCount[roleName] ?? 0) + 1;
     });
 
     // For all community roles with no members, add them to the list with 0
     Object.keys(roleIDsToNames).forEach(roleName => {
       if (roleNamesToMemberCount[roleIDsToNames[roleName]] === undefined) {
         roleNamesToMemberCount[roleIDsToNames[roleName]] = 0;
       }
     });
 
     return roleNamesToMemberCount;
   }, [threadInfo]);
 }
 
 type RoleUserSurfacedPermissions = {
   +[roleName: string]: $ReadOnlySet<UserSurfacedPermission>,
 };
 // Iterates through the existing roles in the community and 'reverse maps'
 // the set of permission literals for each role to user-facing permission enums
 // to help pre-populate the permission checkboxes when editing roles.
 function useRoleUserSurfacedPermissions(
   threadInfo: ThreadInfo,
 ): RoleUserSurfacedPermissions {
   return React.useMemo(() => {
     const roleNamesToPermissions: { [string]: Set<UserSurfacedPermission> } =
       {};
 
     Object.keys(threadInfo.roles).forEach(roleID => {
       const roleName = threadInfo.roles[roleID].name;
       const rolePermissions = threadInfo.minimallyEncoded
         ? Object.keys(
             decodeMinimallyEncodedRoleInfo(threadInfo.roles[roleID])
               .permissions,
           )
         : Object.keys(threadInfo.roles[roleID].permissions);
       const setOfUserSurfacedPermissions = new Set<UserSurfacedPermission>();
 
       rolePermissions.forEach(rolePermission => {
         const userSurfacedPermission = Object.keys(
           configurableCommunityPermissions,
         ).find(key =>
           configurableCommunityPermissions[key].has(rolePermission),
         );
 
         if (userSurfacedPermission) {
           setOfUserSurfacedPermissions.add(userSurfacedPermission);
         }
       });
       roleNamesToPermissions[roleName] = setOfUserSurfacedPermissions;
     });
 
     return roleNamesToPermissions;
   }, [threadInfo]);
 }
 
 function communityOrThreadNoun(threadInfo: RawThreadInfo | ThreadInfo): string {
   return threadTypeIsCommunityRoot(threadInfo.type)
     ? 'community'
     : threadNoun(threadInfo.type, threadInfo.parentThreadID);
 }
 
 function getThreadsToDeleteText(
   threadInfo: RawThreadInfo | ThreadInfo,
 ): string {
   return `${
     threadTypeIsCommunityRoot(threadInfo.type)
       ? 'Subchannels and threads'
       : 'Threads'
   } within this ${communityOrThreadNoun(threadInfo)}`;
 }
 
 function useUserProfileThreadInfo(userInfo: ?UserInfo): ?UserProfileThreadInfo {
   const userID = userInfo?.id;
   const username = userInfo?.username;
 
   const loggedInUserInfo = useLoggedInUserInfo();
   const isViewerProfile = loggedInUserInfo?.id === userID;
 
   const privateThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.PRIVATE,
   );
   const privateThreadInfos = useSelector(privateThreadInfosSelector);
 
   const personalThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.PERSONAL,
   );
 
   const personalThreadInfos = useSelector(personalThreadInfosSelector);
 
   const usersWithPersonalThread = useSelector(usersWithPersonalThreadSelector);
 
   return React.useMemo(() => {
     if (!loggedInUserInfo || !userID || !username) {
       return null;
     }
 
     if (isViewerProfile) {
       const privateThreadInfo: ?ThreadInfo = privateThreadInfos[0];
 
       return privateThreadInfo ? { threadInfo: privateThreadInfo } : null;
     }
 
     if (usersWithPersonalThread.has(userID)) {
       const personalThreadInfo: ?ThreadInfo = personalThreadInfos.find(
         threadInfo =>
           userID === getSingleOtherUser(threadInfo, loggedInUserInfo.id),
       );
 
       return personalThreadInfo ? { threadInfo: personalThreadInfo } : null;
     }
 
     const pendingPersonalThreadInfo = createPendingPersonalThread(
       loggedInUserInfo,
       userID,
       username,
     );
 
     return pendingPersonalThreadInfo;
   }, [
     isViewerProfile,
     loggedInUserInfo,
     personalThreadInfos,
     privateThreadInfos,
     userID,
     username,
     usersWithPersonalThread,
   ]);
 }
 
 export {
   threadHasPermission,
   viewerIsMember,
   threadInChatList,
   threadIsTopLevel,
   threadIsChannel,
   threadIsSidebar,
   threadInBackgroundChatList,
   threadInHomeChatList,
   threadIsInHome,
   threadInFilterList,
   userIsMember,
   threadActualMembers,
   threadOtherMembers,
   threadIsGroupChat,
   threadIsPending,
   threadIsPendingSidebar,
   getSingleOtherUser,
   getPendingThreadID,
   parsePendingThreadID,
   createPendingThread,
   createUnresolvedPendingSidebar,
   extractNewMentionedParentMembers,
   createPendingSidebar,
   pendingThreadType,
   createRealThreadFromPendingThread,
   getCurrentUser,
   getMinimallyEncodedCurrentUser,
   threadFrozenDueToBlock,
   threadFrozenDueToViewerBlock,
   rawThreadInfoFromServerThreadInfo,
   threadUIName,
   threadInfoFromRawThreadInfo,
   threadTypeDescriptions,
   memberIsAdmin,
   memberHasAdminPowers,
   roleIsAdminRole,
   threadHasAdminRole,
   identifyInvalidatedThreads,
   permissionsDisabledByBlock,
   emptyItemText,
   threadNoun,
   threadLabel,
   useWatchThread,
   useExistingThreadInfoFinder,
   getThreadTypeParentRequirement,
   threadMemberHasPermission,
   useCanCreateSidebarFromMessage,
   useSidebarExistsOrCanBeCreated,
   checkIfDefaultMembersAreVoiced,
   draftKeySuffix,
   draftKeyFromThreadID,
   threadTypeCanBePending,
   getContainingThreadID,
   getCommunity,
   getThreadListSearchResults,
   useThreadListSearch,
   removeMemberFromThread,
   getAvailableThreadMemberActions,
   threadMembersWithoutAddedAshoat,
   patchThreadInfoToIncludeMentionedMembersOfParent,
   threadInfoInsideCommunity,
   useRoleMemberCountsForCommunity,
   useRoleUserSurfacedPermissions,
   getThreadsToDeleteText,
   useUserProfileThreadInfo,
 };
diff --git a/lib/socket/activity-handler.react.js b/lib/socket/activity-handler.react.js
index 3e9701f9c..a20e41a64 100644
--- a/lib/socket/activity-handler.react.js
+++ b/lib/socket/activity-handler.react.js
@@ -1,136 +1,136 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 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,
   type ActivityUpdate,
 } from '../types/activity-types.js';
 import type { ConnectionStatus } from '../types/socket-types.js';
 import { useDispatchActionPromise } from '../utils/action-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: ActivityUpdate[] = [];
     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(
+    void dispatchActionPromise(
       updateActivityActionTypes,
       callUpdateActivity({ activityUpdates }),
     );
   });
 
   return null;
 }
 
 export default ActivityHandler;
diff --git a/lib/socket/calendar-query-handler.react.js b/lib/socket/calendar-query-handler.react.js
index 95a0f962a..ff320e666 100644
--- a/lib/socket/calendar-query-handler.react.js
+++ b/lib/socket/calendar-query-handler.react.js
@@ -1,154 +1,154 @@
 // @flow
 
 import invariant from 'invariant';
 import _isEqual from 'lodash/fp/isEqual.js';
 import * as React from 'react';
 
 import {
   updateCalendarQueryActionTypes,
   useUpdateCalendarQuery,
 } from '../actions/entry-actions.js';
 import type { UpdateCalendarQueryInput } from '../actions/entry-actions.js';
 import { connectionSelector } from '../selectors/keyserver-selectors.js';
 import { timeUntilCalendarRangeExpiration } from '../selectors/nav-selectors.js';
 import { useIsAppForegrounded } from '../shared/lifecycle-utils.js';
 import type {
   CalendarQuery,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
 } from '../types/entry-types.js';
 import { type ConnectionInfo } from '../types/socket-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from '../utils/action-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 type BaseProps = {
   +currentCalendarQuery: () => CalendarQuery,
   +frozen: boolean,
 };
 type Props = {
   ...BaseProps,
   +connection: ConnectionInfo,
   +calendarQuery: CalendarQuery,
   +lastUserInteractionCalendar: number,
   +foreground: boolean,
   +dispatchActionPromise: DispatchActionPromise,
   +updateCalendarQuery: (
     input: UpdateCalendarQueryInput,
   ) => Promise<CalendarQueryUpdateResult>,
 };
 class CalendarQueryHandler extends React.PureComponent<Props> {
   serverCalendarQuery: CalendarQuery;
   expirationTimeoutID: ?TimeoutID;
 
   constructor(props: Props) {
     super(props);
     this.serverCalendarQuery = this.props.calendarQuery;
   }
 
   componentDidMount() {
     if (this.props.connection.status === 'connected') {
       this.possiblyUpdateCalendarQuery();
     }
   }
 
   componentDidUpdate(prevProps: Props) {
     const { calendarQuery } = this.props;
     if (this.props.connection.status !== 'connected') {
       if (!_isEqual(this.serverCalendarQuery)(calendarQuery)) {
         this.serverCalendarQuery = calendarQuery;
       }
       return;
     }
 
     if (
       !_isEqual(this.serverCalendarQuery)(calendarQuery) &&
       _isEqual(this.props.currentCalendarQuery())(calendarQuery)
     ) {
       this.serverCalendarQuery = calendarQuery;
     }
 
     const shouldUpdate =
       (this.isExpired ||
         prevProps.connection.status !== 'connected' ||
         this.props.currentCalendarQuery !== prevProps.currentCalendarQuery) &&
       this.shouldUpdateCalendarQuery;
 
     if (shouldUpdate) {
       this.updateCalendarQuery();
     }
   }
 
   render(): React.Node {
     return null;
   }
 
   get isExpired(): boolean {
     const timeUntilExpiration = timeUntilCalendarRangeExpiration(
       this.props.lastUserInteractionCalendar,
     );
     return (
       timeUntilExpiration !== null &&
       timeUntilExpiration !== undefined &&
       timeUntilExpiration <= 0
     );
   }
 
   get shouldUpdateCalendarQuery(): boolean {
     if (this.props.connection.status !== 'connected' || this.props.frozen) {
       return false;
     }
     const calendarQuery = this.props.currentCalendarQuery();
     return !_isEqual(calendarQuery)(this.serverCalendarQuery);
   }
 
   updateCalendarQuery() {
     const calendarQuery = this.props.currentCalendarQuery();
     this.serverCalendarQuery = calendarQuery;
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       updateCalendarQueryActionTypes,
       this.props.updateCalendarQuery({
         calendarQuery,
         reduxAlreadyUpdated: true,
       }),
       undefined,
       ({ calendarQuery }: CalendarQueryUpdateStartingPayload),
     );
   }
 
   possiblyUpdateCalendarQuery = () => {
     if (this.shouldUpdateCalendarQuery) {
       this.updateCalendarQuery();
     }
   };
 }
 
 const ConnectedCalendarQueryHandler: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedCalendarQueryHandler(props) {
     const connection = useSelector(connectionSelector(ashoatKeyserverID));
     invariant(connection, 'keyserver missing from keyserverStore');
     const lastUserInteractionCalendar = useSelector(
       state => state.entryStore.lastUserInteractionCalendar,
     );
     // We include this so that componentDidUpdate will be called on foreground
     const foreground = useIsAppForegrounded();
     const callUpdateCalendarQuery = useUpdateCalendarQuery();
     const dispatchActionPromise = useDispatchActionPromise();
     const calendarQuery = useSelector(state => state.actualizedCalendarQuery);
 
     return (
       <CalendarQueryHandler
         {...props}
         connection={connection}
         calendarQuery={calendarQuery}
         lastUserInteractionCalendar={lastUserInteractionCalendar}
         foreground={foreground}
         updateCalendarQuery={callUpdateCalendarQuery}
         dispatchActionPromise={dispatchActionPromise}
       />
     );
   });
 export default ConnectedCalendarQueryHandler;
diff --git a/lib/socket/report-handler.react.js b/lib/socket/report-handler.react.js
index 573e5cd37..06e391b4b 100644
--- a/lib/socket/report-handler.react.js
+++ b/lib/socket/report-handler.react.js
@@ -1,91 +1,91 @@
 // @flow
 
 import * as React from 'react';
 
 import { sendReportsActionTypes } from '../actions/report-actions.js';
 import { queuedReports as queuedReportsSelector } from '../selectors/socket-selectors.js';
 import {
   type ClientReportCreationRequest,
   type ClearDeliveredReportsPayload,
 } from '../types/report-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from '../utils/action-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { sendReports } from '../utils/reports-service.js';
 
 type BaseProps = {
   +canSendReports: boolean,
 };
 type Props = {
   ...BaseProps,
   +queuedReports: $ReadOnlyArray<ClientReportCreationRequest>,
   +dispatchActionPromise: DispatchActionPromise,
 };
 class ReportHandler extends React.PureComponent<Props> {
   componentDidMount() {
     if (this.props.canSendReports) {
       this.dispatchSendReports(this.props.queuedReports);
     }
   }
 
   componentDidUpdate(prevProps: Props) {
     if (!this.props.canSendReports) {
       return;
     }
 
     const couldSend = prevProps.canSendReports;
     const curReports = this.props.queuedReports;
     if (!couldSend) {
       this.dispatchSendReports(curReports);
       return;
     }
 
     const prevReports = prevProps.queuedReports;
     if (curReports !== prevReports) {
       const prevResponses = new Set(prevReports);
       const newResponses = curReports.filter(
         response => !prevResponses.has(response),
       );
       this.dispatchSendReports(newResponses);
     }
   }
 
   render(): React.Node {
     return null;
   }
 
   dispatchSendReports(reports: $ReadOnlyArray<ClientReportCreationRequest>) {
     if (reports.length === 0) {
       return;
     }
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       sendReportsActionTypes,
       this.sendReports(reports),
     );
   }
 
   async sendReports(
     reports: $ReadOnlyArray<ClientReportCreationRequest>,
   ): Promise<ClearDeliveredReportsPayload> {
     await sendReports(reports);
     return { reports };
   }
 }
 
 const ConnectedReportHandler: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedReportHandler(props) {
     const queuedReports = useSelector(queuedReportsSelector);
     const dispatchActionPromise = useDispatchActionPromise();
 
     return (
       <ReportHandler
         {...props}
         queuedReports={queuedReports}
         dispatchActionPromise={dispatchActionPromise}
       />
     );
   });
 
 export default ConnectedReportHandler;
diff --git a/lib/socket/request-response-handler.react.js b/lib/socket/request-response-handler.react.js
index de785d3ba..936f861eb 100644
--- a/lib/socket/request-response-handler.react.js
+++ b/lib/socket/request-response-handler.react.js
@@ -1,153 +1,155 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 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, 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(): React.Node {
     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);
+      void 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);
+    void 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/socket.react.js b/lib/socket/socket.react.js
index 840ca5b0b..c172fa8ed 100644
--- a/lib/socket/socket.react.js
+++ b/lib/socket/socket.react.js
@@ -1,822 +1,822 @@
 // @flow
 
 import invariant from 'invariant';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _throttle from 'lodash/throttle.js';
 import * as React from 'react';
 
 import ActivityHandler from './activity-handler.react.js';
 import APIRequestHandler from './api-request-handler.react.js';
 import CalendarQueryHandler from './calendar-query-handler.react.js';
 import { InflightRequests } from './inflight-requests.js';
 import MessageHandler from './message-handler.react.js';
 import ReportHandler from './report-handler.react.js';
 import RequestResponseHandler from './request-response-handler.react.js';
 import UpdateHandler from './update-handler.react.js';
 import { updateActivityActionTypes } from '../actions/activity-actions.js';
 import { updateLastCommunicatedPlatformDetailsActionType } from '../actions/device-actions.js';
 import { logOutActionTypes } from '../actions/user-actions.js';
 import { unsupervisedBackgroundActionType } from '../reducers/lifecycle-state-reducer.js';
 import {
   pingFrequency,
   serverRequestSocketTimeout,
   clientRequestVisualTimeout,
   clientRequestSocketTimeout,
 } from '../shared/timeouts.js';
 import {
   logInActionSources,
   type LogOutResult,
 } from '../types/account-types.js';
 import type { CompressedData } from '../types/compression-types.js';
 import { type PlatformDetails } from '../types/device-types.js';
 import type { CalendarQuery } from '../types/entry-types.js';
 import { forcePolicyAcknowledgmentActionType } from '../types/policy-types.js';
 import type { Dispatch } from '../types/redux-types.js';
 import {
   serverRequestTypes,
   type ClientClientResponse,
   type ClientServerRequest,
 } from '../types/request-types.js';
 import {
   type SessionState,
   type SessionIdentification,
   type PreRequestUserState,
 } from '../types/session-types.js';
 import {
   clientSocketMessageTypes,
   type ClientClientSocketMessage,
   serverSocketMessageTypes,
   type ClientServerSocketMessage,
   stateSyncPayloadTypes,
   fullStateSyncActionType,
   incrementalStateSyncActionType,
   updateConnectionStatusActionType,
   type ConnectionInfo,
   type ClientInitialClientSocketMessage,
   type ClientResponsesClientSocketMessage,
   type PingClientSocketMessage,
   type AckUpdatesClientSocketMessage,
   type APIRequestClientSocketMessage,
   type ClientSocketMessageWithoutID,
   type SocketListener,
   type ConnectionStatus,
   setLateResponseActionType,
   type CommTransportLayer,
   type ActivityUpdateResponseServerSocketMessage,
   type ClientStateSyncServerSocketMessage,
   type PongServerSocketMessage,
 } from '../types/socket-types.js';
 import { actionLogger } from '../utils/action-logger.js';
 import type { DispatchActionPromise } from '../utils/action-utils.js';
 import {
   setNewSessionActionType,
   fetchNewCookieFromNativeCredentials,
 } from '../utils/action-utils.js';
 import { getConfig } from '../utils/config.js';
 import { ServerError, SocketTimeout, SocketOffline } from '../utils/errors.js';
 import { promiseAll } from '../utils/promises.js';
 import sleep from '../utils/sleep.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 const remainingTimeAfterVisualTimeout =
   clientRequestSocketTimeout - clientRequestVisualTimeout;
 
 export type BaseSocketProps = {
   +detectUnsupervisedBackgroundRef?: (
     detectUnsupervisedBackground: (alreadyClosed: boolean) => boolean,
   ) => void,
 };
 type Props = {
   ...BaseSocketProps,
   // Redux state
   +active: boolean,
   +openSocket: () => CommTransportLayer,
   +getClientResponses: (
     activeServerRequests: $ReadOnlyArray<ClientServerRequest>,
   ) => Promise<$ReadOnlyArray<ClientClientResponse>>,
   +activeThread: ?string,
   +sessionStateFunc: () => SessionState,
   +sessionIdentification: SessionIdentification,
   +cookie: ?string,
   +urlPrefix: string,
   +connection: ConnectionInfo,
   +currentCalendarQuery: () => CalendarQuery,
   +canSendReports: boolean,
   +frozen: boolean,
   +preRequestUserState: PreRequestUserState,
   +noDataAfterPolicyAcknowledgment?: boolean,
   +lastCommunicatedPlatformDetails: ?PlatformDetails,
   +decompressSocketMessage: CompressedData => string,
   // Redux dispatch functions
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +logOut: (preRequestUserState: PreRequestUserState) => Promise<LogOutResult>,
   +socketCrashLoopRecovery?: () => Promise<void>,
   // keyserver olm sessions specific props
   +getInitialNotificationsEncryptedMessage?: () => Promise<string>,
 };
 type State = {
   +inflightRequests: ?InflightRequests,
 };
 class Socket extends React.PureComponent<Props, State> {
   state: State = {
     inflightRequests: null,
   };
   socket: ?CommTransportLayer;
   nextClientMessageID: number = 0;
   listeners: Set<SocketListener> = new Set();
   pingTimeoutID: ?TimeoutID;
   messageLastReceived: ?number;
   reopenConnectionAfterClosing: boolean = false;
   invalidationRecoveryInProgress: boolean = false;
   initializedWithUserState: ?PreRequestUserState;
   failuresAfterPolicyAcknowledgment: number = 0;
 
   openSocket(newStatus: ConnectionStatus) {
     if (
       this.props.frozen ||
       !this.props.cookie ||
       !this.props.cookie.startsWith('user=')
     ) {
       return;
     }
     if (this.socket) {
       const { status } = this.props.connection;
       if (status === 'forcedDisconnecting') {
         this.reopenConnectionAfterClosing = true;
         return;
       } else if (status === 'disconnecting' && this.socket.readyState === 1) {
         this.markSocketInitialized();
         return;
       } else if (
         status === 'connected' ||
         status === 'connecting' ||
         status === 'reconnecting'
       ) {
         return;
       }
       if (this.socket.readyState < 2) {
         this.socket.close();
         console.log(`this.socket seems open, but Redux thinks it's ${status}`);
       }
     }
     this.props.dispatch({
       type: updateConnectionStatusActionType,
       payload: { status: newStatus, keyserverID: ashoatKeyserverID },
     });
 
     const socket = this.props.openSocket();
     const openObject: { initializeMessageSent?: true } = {};
     socket.onopen = () => {
       if (this.socket === socket) {
-        this.initializeSocket();
+        void this.initializeSocket();
         openObject.initializeMessageSent = true;
       }
     };
     socket.onmessage = this.receiveMessage;
     socket.onclose = () => {
       if (this.socket === socket) {
         this.onClose();
       }
     };
     this.socket = socket;
 
-    (async () => {
+    void (async () => {
       await sleep(clientRequestVisualTimeout);
       if (this.socket !== socket || openObject.initializeMessageSent) {
         return;
       }
       this.setLateResponse(-1, true);
       await sleep(remainingTimeAfterVisualTimeout);
       if (this.socket !== socket || openObject.initializeMessageSent) {
         return;
       }
       this.finishClosingSocket();
     })();
 
     this.setState({
       inflightRequests: new InflightRequests({
         timeout: () => {
           if (this.socket === socket) {
             this.finishClosingSocket();
           }
         },
         setLateResponse: (messageID: number, isLate: boolean) => {
           if (this.socket === socket) {
             this.setLateResponse(messageID, isLate);
           }
         },
       }),
     });
   }
 
   markSocketInitialized() {
     this.props.dispatch({
       type: updateConnectionStatusActionType,
       payload: { status: 'connected', keyserverID: ashoatKeyserverID },
     });
     this.resetPing();
   }
 
   closeSocket(
     // This param is a hack. When closing a socket there is a race between this
     // function and the one to propagate the activity update. We make sure that
     // the activity update wins the race by passing in this param.
     activityUpdatePending: boolean,
   ) {
     const { status } = this.props.connection;
     if (status === 'disconnected') {
       return;
     } else if (status === 'disconnecting' || status === 'forcedDisconnecting') {
       this.reopenConnectionAfterClosing = false;
       return;
     }
     this.stopPing();
     this.props.dispatch({
       type: updateConnectionStatusActionType,
       payload: { status: 'disconnecting', keyserverID: ashoatKeyserverID },
     });
     if (!activityUpdatePending) {
       this.finishClosingSocket();
     }
   }
 
   forceCloseSocket() {
     this.stopPing();
     const { status } = this.props.connection;
     if (status !== 'forcedDisconnecting' && status !== 'disconnected') {
       this.props.dispatch({
         type: updateConnectionStatusActionType,
         payload: {
           status: 'forcedDisconnecting',
           keyserverID: ashoatKeyserverID,
         },
       });
     }
     this.finishClosingSocket();
   }
 
   finishClosingSocket(receivedResponseTo?: ?number) {
     const { inflightRequests } = this.state;
     if (
       inflightRequests &&
       !inflightRequests.allRequestsResolvedExcept(receivedResponseTo)
     ) {
       return;
     }
     if (this.socket && this.socket.readyState < 2) {
       // If it's not closing already, close it
       this.socket.close();
     }
     this.socket = null;
     this.stopPing();
     this.setState({ inflightRequests: null });
     if (this.props.connection.status !== 'disconnected') {
       this.props.dispatch({
         type: updateConnectionStatusActionType,
         payload: { status: 'disconnected', keyserverID: ashoatKeyserverID },
       });
     }
     if (this.reopenConnectionAfterClosing) {
       this.reopenConnectionAfterClosing = false;
       if (this.props.active) {
         this.openSocket('connecting');
       }
     }
   }
 
   reconnect: $Call<typeof _throttle, () => void, number> = _throttle(
     () => this.openSocket('reconnecting'),
     2000,
   );
 
   componentDidMount() {
     if (this.props.detectUnsupervisedBackgroundRef) {
       this.props.detectUnsupervisedBackgroundRef(
         this.detectUnsupervisedBackground,
       );
     }
     if (this.props.active) {
       this.openSocket('connecting');
     }
   }
 
   componentWillUnmount() {
     this.closeSocket(false);
     this.reconnect.cancel();
   }
 
   componentDidUpdate(prevProps: Props) {
     if (this.props.active && !prevProps.active) {
       this.openSocket('connecting');
     } else if (!this.props.active && prevProps.active) {
       this.closeSocket(!!prevProps.activeThread);
     } else if (
       this.props.active &&
       prevProps.openSocket !== this.props.openSocket
     ) {
       // This case happens when the baseURL/urlPrefix is changed
       this.reopenConnectionAfterClosing = true;
       this.forceCloseSocket();
     } else if (
       this.props.active &&
       this.props.connection.status === 'disconnected' &&
       prevProps.connection.status !== 'disconnected' &&
       !this.invalidationRecoveryInProgress
     ) {
       this.reconnect();
     }
   }
 
   render(): React.Node {
     // It's important that APIRequestHandler get rendered first here. This is so
     // that it is registered with Redux first, so that its componentDidUpdate
     // processes before the other Handlers. This allows APIRequestHandler to
     // register itself with action-utils before other Handlers call
     // dispatchActionPromise in response to the componentDidUpdate triggered by
     // the same Redux change (state.connection.status).
     return (
       <React.Fragment>
         <APIRequestHandler
           inflightRequests={this.state.inflightRequests}
           sendMessage={this.sendMessageWithoutID}
         />
         <ActivityHandler
           activeThread={this.props.activeThread}
           frozen={this.props.frozen}
         />
         <RequestResponseHandler
           inflightRequests={this.state.inflightRequests}
           sendMessage={this.sendMessageWithoutID}
           addListener={this.addListener}
           removeListener={this.removeListener}
           getClientResponses={this.props.getClientResponses}
           currentCalendarQuery={this.props.currentCalendarQuery}
         />
         <UpdateHandler
           sendMessage={this.sendMessageWithoutID}
           addListener={this.addListener}
           removeListener={this.removeListener}
           keyserverID={ashoatKeyserverID}
         />
         <MessageHandler
           addListener={this.addListener}
           removeListener={this.removeListener}
         />
         <CalendarQueryHandler
           currentCalendarQuery={this.props.currentCalendarQuery}
           frozen={this.props.frozen}
         />
         <ReportHandler canSendReports={this.props.canSendReports} />
       </React.Fragment>
     );
   }
 
   sendMessageWithoutID: (message: ClientSocketMessageWithoutID) => number =
     message => {
       const id = this.nextClientMessageID++;
       // These conditions all do the same thing and the runtime checks are only
       // necessary for Flow
       if (message.type === clientSocketMessageTypes.INITIAL) {
         this.sendMessage(
           ({ ...message, id }: ClientInitialClientSocketMessage),
         );
       } else if (message.type === clientSocketMessageTypes.RESPONSES) {
         this.sendMessage(
           ({ ...message, id }: ClientResponsesClientSocketMessage),
         );
       } else if (message.type === clientSocketMessageTypes.PING) {
         this.sendMessage(({ ...message, id }: PingClientSocketMessage));
       } else if (message.type === clientSocketMessageTypes.ACK_UPDATES) {
         this.sendMessage(({ ...message, id }: AckUpdatesClientSocketMessage));
       } else if (message.type === clientSocketMessageTypes.API_REQUEST) {
         this.sendMessage(({ ...message, id }: APIRequestClientSocketMessage));
       }
       return id;
     };
 
   sendMessage(message: ClientClientSocketMessage) {
     const socket = this.socket;
     invariant(socket, 'should be set');
     socket.send(JSON.stringify(message));
   }
 
   messageFromEvent(event: MessageEvent): ?ClientServerSocketMessage {
     if (typeof event.data !== 'string') {
       console.log('socket received a non-string message');
       return null;
     }
 
     let rawMessage;
     try {
       rawMessage = JSON.parse(event.data);
     } catch (e) {
       console.log(e);
       return null;
     }
 
     if (rawMessage.type !== serverSocketMessageTypes.COMPRESSED_MESSAGE) {
       return rawMessage;
     }
 
     const result = this.props.decompressSocketMessage(rawMessage.payload);
     try {
       return JSON.parse(result);
     } catch (e) {
       console.log(e);
       return null;
     }
   }
 
   receiveMessage: (event: MessageEvent) => Promise<void> = async event => {
     const message = this.messageFromEvent(event);
     if (!message) {
       return;
     }
     this.failuresAfterPolicyAcknowledgment = 0;
 
     const { inflightRequests } = this.state;
     if (!inflightRequests) {
       // inflightRequests can be falsey here if we receive a message after we've
       // begun shutting down the socket. It's possible for a React Native
       // WebSocket to deliver a message even after close() is called on it. In
       // this case the message is probably a PONG, which we can safely ignore.
       // If it's not a PONG, it has to be something server-initiated (like
       // UPDATES or MESSAGES), since InflightRequests.allRequestsResolvedExcept
       // will wait for all responses to client-initiated requests to be
       // delivered before closing a socket. UPDATES and MESSAGES are both
       // checkpointed on the client, so should be okay to just ignore here and
       // redownload them later, probably in an incremental STATE_SYNC.
       return;
     }
 
     // If we receive any message, that indicates that our connection is healthy,
     // so we can reset the ping timeout.
     this.resetPing();
 
     inflightRequests.resolveRequestsForMessage(message);
     const { status } = this.props.connection;
     if (status === 'disconnecting' || status === 'forcedDisconnecting') {
       this.finishClosingSocket(
         // We do this for Flow
         message.responseTo !== undefined ? message.responseTo : null,
       );
     }
 
     for (const listener of this.listeners) {
       listener(message);
     }
 
     if (message.type === serverSocketMessageTypes.ERROR) {
       const { message: errorMessage, payload } = message;
       if (payload) {
         console.log(`socket sent error ${errorMessage} with payload`, payload);
       } else {
         console.log(`socket sent error ${errorMessage}`);
       }
       if (errorMessage === 'policies_not_accepted' && this.props.active) {
         this.props.dispatch({
           type: forcePolicyAcknowledgmentActionType,
           payload,
         });
       }
     } else if (message.type === serverSocketMessageTypes.AUTH_ERROR) {
       const { sessionChange } = message;
       const cookie = sessionChange ? sessionChange.cookie : this.props.cookie;
       this.invalidationRecoveryInProgress = true;
 
       const recoverySessionChange = await fetchNewCookieFromNativeCredentials(
         this.props.dispatch,
         cookie,
         this.props.urlPrefix,
         logInActionSources.socketAuthErrorResolutionAttempt,
         ashoatKeyserverID,
         this.props.getInitialNotificationsEncryptedMessage,
       );
 
       if (!recoverySessionChange && sessionChange) {
         const { cookie: newerCookie, currentUserInfo } = sessionChange;
         this.props.dispatch({
           type: setNewSessionActionType,
           payload: {
             sessionChange: {
               cookieInvalidated: true,
               currentUserInfo,
               cookie: newerCookie,
             },
             preRequestUserState: this.initializedWithUserState,
             error: null,
             logInActionSource:
               logInActionSources.socketAuthErrorResolutionAttempt,
             keyserverID: ashoatKeyserverID,
           },
         });
       } else if (!recoverySessionChange) {
-        this.props.dispatchActionPromise(
+        void this.props.dispatchActionPromise(
           logOutActionTypes,
           this.props.logOut(this.props.preRequestUserState),
         );
       }
       this.invalidationRecoveryInProgress = false;
     }
   };
 
   addListener: (listener: SocketListener) => void = listener => {
     this.listeners.add(listener);
   };
 
   removeListener: (listener: SocketListener) => void = listener => {
     this.listeners.delete(listener);
   };
 
   onClose: () => void = () => {
     const { status } = this.props.connection;
     this.socket = null;
     this.stopPing();
     if (this.state.inflightRequests) {
       this.state.inflightRequests.rejectAll(new Error('socket closed'));
       this.setState({ inflightRequests: null });
     }
     const handled = this.detectUnsupervisedBackground(true);
     if (!handled && status !== 'disconnected') {
       this.props.dispatch({
         type: updateConnectionStatusActionType,
         payload: { status: 'disconnected', keyserverID: ashoatKeyserverID },
       });
     }
   };
 
   async sendInitialMessage() {
     const { inflightRequests } = this.state;
     invariant(
       inflightRequests,
       'inflightRequests falsey inside sendInitialMessage',
     );
     const messageID = this.nextClientMessageID++;
 
     const shouldSendInitialPlatformDetails = !_isEqual(
       this.props.lastCommunicatedPlatformDetails,
     )(getConfig().platformDetails);
 
     const clientResponses: ClientClientResponse[] = [];
     if (shouldSendInitialPlatformDetails) {
       clientResponses.push({
         type: serverRequestTypes.PLATFORM_DETAILS,
         platformDetails: getConfig().platformDetails,
       });
     }
 
     let activityUpdatePromise;
     const { queuedActivityUpdates } = this.props.connection;
     if (queuedActivityUpdates.length > 0) {
       clientResponses.push({
         type: serverRequestTypes.INITIAL_ACTIVITY_UPDATES,
         activityUpdates: queuedActivityUpdates,
       });
       activityUpdatePromise =
         inflightRequests.fetchResponse<ActivityUpdateResponseServerSocketMessage>(
           messageID,
           serverSocketMessageTypes.ACTIVITY_UPDATE_RESPONSE,
         );
     }
 
     const sessionState = this.props.sessionStateFunc();
     const { sessionIdentification } = this.props;
     const initialMessage = {
       type: clientSocketMessageTypes.INITIAL,
       id: messageID,
       payload: {
         clientResponses,
         sessionState,
         sessionIdentification,
       },
     };
     this.initializedWithUserState = this.props.preRequestUserState;
     this.sendMessage(initialMessage);
 
     const stateSyncPromise =
       inflightRequests.fetchResponse<ClientStateSyncServerSocketMessage>(
         messageID,
         serverSocketMessageTypes.STATE_SYNC,
       );
 
     // https://flow.org/try/#1N4Igxg9gdgZglgcxALlAJwKYEMwBcD6aArlLnALYYrgA2WAzvXGCADQgYAeOBARgJ74AJhhhYiNXClzEM7DFCLl602QF92kEdQb8oYAAQwSeONAMAHNBHJx6GAII0aAHgAqyA8AMBqANoA1hj8nvQycFAIALqetpwYQgZqAHwAFAA6UAYGERZEuJ4AJABK2EIA8lA0-O7JrJkAlJ4ACta29i6F5bwAVgCyWBburAa4-BYYEDAGhVgA7lhwuMnJXpnZkFBhlm12GPQGALwGflEA3OsGm9tB-AfH3T0YeAB0t-SpufkNF1lGEGgDKkaBhcDkjgYAAxncEuAzvF4gyK4AAWMLgPh8DTWfw20BuwQh7z8cHOlzxWzBVhsewhX1wgWCZNxOxp9noLzy9BRqWp7QwP0uaku1zBmHoElw9wM80WYNabIwLywzl5u3Zgr+ooMAgAclhKJ5gH4wmgItFYnB4kI1BDgGpftkYACgSCwXAIdDYfDghykQhUejMdjgOSrviwbcib6Sczstk9QaMIz+FEIeLJfRY46kpdMLgiGgsonKL9hVBMrp9EYTGRzPYoEIAJJQJZwFV9fb0LAIDCpEOXN2jfa4BX8nNwaYZEAojDOCDpEAvMJYNBSgDqSx5i4Ci4aA5ZuBHY9pxxP9he4ogNAAbn2ZEQBTny5dZUtWfynDRUt4j2FzxgSSamobAgHeaBMNA1A3pCLwAEwAIwACwvJCIBqEAA
     // $FlowFixMe fixed in Flow 0.214
     const { stateSyncMessage, activityUpdateMessage } = await promiseAll({
       activityUpdateMessage: activityUpdatePromise,
       stateSyncMessage: stateSyncPromise,
     });
 
     if (shouldSendInitialPlatformDetails) {
       this.props.dispatch({
         type: updateLastCommunicatedPlatformDetailsActionType,
         payload: {
           platformDetails: getConfig().platformDetails,
           keyserverID: ashoatKeyserverID,
         },
       });
     }
 
     if (activityUpdateMessage) {
       this.props.dispatch({
         type: updateActivityActionTypes.success,
         payload: {
           activityUpdates: { [ashoatKeyserverID]: queuedActivityUpdates },
           result: activityUpdateMessage.payload,
         },
       });
     }
 
     if (stateSyncMessage.payload.type === stateSyncPayloadTypes.FULL) {
       const { sessionID, type, ...actionPayload } = stateSyncMessage.payload;
       this.props.dispatch({
         type: fullStateSyncActionType,
         payload: {
           ...actionPayload,
           calendarQuery: sessionState.calendarQuery,
           keyserverID: ashoatKeyserverID,
         },
       });
       if (sessionID !== null && sessionID !== undefined) {
         invariant(
           this.initializedWithUserState,
           'initializedWithUserState should be set when state sync received',
         );
         this.props.dispatch({
           type: setNewSessionActionType,
           payload: {
             sessionChange: { cookieInvalidated: false, sessionID },
             preRequestUserState: this.initializedWithUserState,
             error: null,
             logInActionSource: undefined,
             keyserverID: ashoatKeyserverID,
           },
         });
       }
     } else {
       const { type, ...actionPayload } = stateSyncMessage.payload;
       this.props.dispatch({
         type: incrementalStateSyncActionType,
         payload: {
           ...actionPayload,
           calendarQuery: sessionState.calendarQuery,
           keyserverID: ashoatKeyserverID,
         },
       });
     }
 
     const currentAsOf =
       stateSyncMessage.payload.type === stateSyncPayloadTypes.FULL
         ? stateSyncMessage.payload.updatesCurrentAsOf
         : stateSyncMessage.payload.updatesResult.currentAsOf;
     this.sendMessageWithoutID({
       type: clientSocketMessageTypes.ACK_UPDATES,
       payload: { currentAsOf },
     });
 
     this.markSocketInitialized();
   }
 
   initializeSocket: (retriesLeft?: number) => Promise<void> = async (
     retriesLeft = 1,
   ) => {
     try {
       await this.sendInitialMessage();
     } catch (e) {
       if (this.props.noDataAfterPolicyAcknowledgment) {
         this.failuresAfterPolicyAcknowledgment++;
       } else {
         this.failuresAfterPolicyAcknowledgment = 0;
       }
       if (
         this.failuresAfterPolicyAcknowledgment >= 2 &&
         this.props.socketCrashLoopRecovery
       ) {
         this.failuresAfterPolicyAcknowledgment = 0;
         try {
           await this.props.socketCrashLoopRecovery();
         } catch (error) {
           console.log(error);
-          this.props.dispatchActionPromise(
+          void this.props.dispatchActionPromise(
             logOutActionTypes,
             this.props.logOut(this.props.preRequestUserState),
           );
         }
         return;
       }
 
       console.log(e);
       const { status } = this.props.connection;
       if (
         e instanceof SocketTimeout ||
         e instanceof SocketOffline ||
         (status !== 'connecting' && status !== 'reconnecting')
       ) {
         // This indicates that the socket will be closed. Do nothing, since the
         // connection status update will trigger a reconnect.
       } else if (
         retriesLeft === 0 ||
         (e instanceof ServerError && e.message !== 'unknown_error')
       ) {
         if (e.message === 'not_logged_in') {
-          this.props.dispatchActionPromise(
+          void this.props.dispatchActionPromise(
             logOutActionTypes,
             this.props.logOut(this.props.preRequestUserState),
           );
         } else if (this.socket) {
           this.socket.close();
         }
       } else {
         await this.initializeSocket(retriesLeft - 1);
       }
     }
   };
 
   stopPing() {
     if (this.pingTimeoutID) {
       clearTimeout(this.pingTimeoutID);
       this.pingTimeoutID = null;
     }
   }
 
   resetPing() {
     this.stopPing();
     const socket = this.socket;
     this.messageLastReceived = Date.now();
     this.pingTimeoutID = setTimeout(() => {
       if (this.socket === socket) {
-        this.sendPing();
+        void this.sendPing();
       }
     }, pingFrequency);
   }
 
   async sendPing() {
     if (this.props.connection.status !== 'connected') {
       // This generally shouldn't happen because anything that changes the
       // connection status should call stopPing(), but it's good to make sure
       return;
     }
     const messageID = this.sendMessageWithoutID({
       type: clientSocketMessageTypes.PING,
     });
     try {
       invariant(
         this.state.inflightRequests,
         'inflightRequests falsey inside sendPing',
       );
       await this.state.inflightRequests.fetchResponse<PongServerSocketMessage>(
         messageID,
         serverSocketMessageTypes.PONG,
       );
     } catch (e) {}
   }
 
   setLateResponse: (messageID: number, isLate: boolean) => void = (
     messageID,
     isLate,
   ) => {
     this.props.dispatch({
       type: setLateResponseActionType,
       payload: { messageID, isLate, keyserverID: ashoatKeyserverID },
     });
   };
 
   cleanUpServerTerminatedSocket() {
     if (this.socket && this.socket.readyState < 2) {
       this.socket.close();
     } else {
       this.onClose();
     }
   }
 
   detectUnsupervisedBackground: (alreadyClosed: boolean) => boolean =
     alreadyClosed => {
       // On native, sometimes the app is backgrounded without the proper
       // callbacks getting triggered. This leaves us in an incorrect state for
       // two reasons:
       // (1) The connection is still considered to be active, causing API
       //     requests to be processed via socket and failing.
       // (2) We rely on flipping foreground state in Redux to detect activity
       //     changes, and thus won't think we need to update activity.
       if (
         this.props.connection.status !== 'connected' ||
         !this.messageLastReceived ||
         this.messageLastReceived + serverRequestSocketTimeout >= Date.now() ||
         (actionLogger.mostRecentActionTime &&
           actionLogger.mostRecentActionTime + 3000 < Date.now())
       ) {
         return false;
       }
       if (!alreadyClosed) {
         this.cleanUpServerTerminatedSocket();
       }
       this.props.dispatch({
         type: unsupervisedBackgroundActionType,
         payload: { keyserverID: ashoatKeyserverID },
       });
       return true;
     };
 }
 
 export default Socket;
diff --git a/lib/utils/action-utils.js b/lib/utils/action-utils.js
index 6c70e07c5..4ba3290ee 100644
--- a/lib/utils/action-utils.js
+++ b/lib/utils/action-utils.js
@@ -1,608 +1,610 @@
 // @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 { 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 { 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));
+    void dispatch(
+      wrapActionPromise(actionTypes, promise, null, startingPayload),
+    );
     return new Promise<boolean>(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<?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 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<?CallServerEndpoint>(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?: ?Partial<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: { [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,
   fetchNewCookieFromNativeCredentials,
   createBoundServerCallsSelector,
   registerActiveSocket,
   useServerCall,
   bindCookieAndUtilsIntoCallServerEndpoint,
   extractKeyserverIDFromID,
   sortThreadIDsPerKeyserver,
   sortCalendarQueryPerKeyserver,
 };
diff --git a/lib/utils/policy-acknowledge-utlis.js b/lib/utils/policy-acknowledge-utlis.js
index 26d69e5e2..d8466472a 100644
--- a/lib/utils/policy-acknowledge-utlis.js
+++ b/lib/utils/policy-acknowledge-utlis.js
@@ -1,32 +1,32 @@
 // @flow
 
 import type { DispatchActionPromise } from './action-utils.js';
 import { policyAcknowledgmentActionTypes } from '../actions/user-actions.js';
 import type { PolicyType } from '../facts/policies.js';
 import type { PolicyAcknowledgmentRequest } from '../types/account-types.js';
 
 function acknowledgePolicy(
   policy: PolicyType,
   dispatchActionPromise: DispatchActionPromise,
   acknowledgmentServerCall: (
     request: PolicyAcknowledgmentRequest,
   ) => Promise<void>,
   onError: (message: string) => void,
 ) {
   const acknowledgePolicyPromise = (async () => {
     try {
       await acknowledgmentServerCall({ policy });
       return { policy };
     } catch (e) {
       console.warn('error acknowledging policy', e);
       onError('unknown error');
       throw e;
     }
   })();
-  dispatchActionPromise(
+  void dispatchActionPromise(
     policyAcknowledgmentActionTypes,
     acknowledgePolicyPromise,
   );
 }
 
 export { acknowledgePolicy };
diff --git a/native/account/log-in-panel.react.js b/native/account/log-in-panel.react.js
index d345eacfb..d7485e90c 100644
--- a/native/account/log-in-panel.react.js
+++ b/native/account/log-in-panel.react.js
@@ -1,405 +1,405 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, StyleSheet, Keyboard, Platform } from 'react-native';
 import Animated from 'react-native-reanimated';
 
 import {
   logInActionTypes,
   useLogIn,
   getOlmSessionInitializationDataActionTypes,
 } from 'lib/actions/user-actions.js';
 import {
   createLoadingStatusSelector,
   combineLoadingStatuses,
 } from 'lib/selectors/loading-selectors.js';
 import {
   validEmailRegex,
   oldValidUsernameRegex,
 } from 'lib/shared/account-utils.js';
 import { useInitialNotificationsEncryptedMessage } from 'lib/shared/crypto-utils.js';
 import {
   type LogInInfo,
   type LogInExtraInfo,
   type LogInResult,
   type LogInStartingPayload,
   logInActionSources,
 } from 'lib/types/account-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import {
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import { TextInput } from './modal-components.react.js';
 import {
   fetchNativeCredentials,
   setNativeCredentials,
 } from './native-credentials.js';
 import { PanelButton, Panel } from './panel-components.react.js';
 import PasswordInput from './password-input.react.js';
 import SWMansionIcon from '../components/swmansion-icon.react.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { nativeLogInExtraInfoSelector } from '../selectors/account-selectors.js';
 import type { KeyPressEvent } from '../types/react-native.js';
 import { AppOutOfDateAlertDetails } from '../utils/alert-messages.js';
 import Alert from '../utils/alert.js';
 import { nativeNotificationsSessionCreator } from '../utils/crypto-utils.js';
 import type { StateContainer } from '../utils/state-container.js';
 
 export type LogInState = {
   +usernameInputText: ?string,
   +passwordInputText: ?string,
 };
 type BaseProps = {
   +setActiveAlert: (activeAlert: boolean) => void,
   +opacityValue: Animated.Node,
   +logInState: StateContainer<LogInState>,
 };
 type Props = {
   ...BaseProps,
   +loadingStatus: LoadingStatus,
   +logInExtraInfo: () => Promise<LogInExtraInfo>,
   +dispatchActionPromise: DispatchActionPromise,
   +logIn: (logInInfo: LogInInfo) => Promise<LogInResult>,
   +getInitialNotificationsEncryptedMessage: () => Promise<string>,
 };
 class LogInPanel extends React.PureComponent<Props> {
   usernameInput: ?TextInput;
   passwordInput: ?PasswordInput;
 
   componentDidMount() {
-    this.attemptToFetchCredentials();
+    void this.attemptToFetchCredentials();
   }
 
   get usernameInputText(): string {
     return this.props.logInState.state.usernameInputText || '';
   }
 
   get passwordInputText(): string {
     return this.props.logInState.state.passwordInputText || '';
   }
 
   async attemptToFetchCredentials() {
     if (
       this.props.logInState.state.usernameInputText !== null &&
       this.props.logInState.state.usernameInputText !== undefined
     ) {
       return;
     }
     const credentials = await fetchNativeCredentials();
     if (!credentials) {
       return;
     }
     if (
       this.props.logInState.state.usernameInputText !== null &&
       this.props.logInState.state.usernameInputText !== undefined
     ) {
       return;
     }
     this.props.logInState.setState({
       usernameInputText: credentials.username,
       passwordInputText: credentials.password,
     });
   }
 
   render(): React.Node {
     return (
       <Panel opacityValue={this.props.opacityValue}>
         <View style={styles.row}>
           <SWMansionIcon
             name="user-1"
             size={22}
             color="#555"
             style={styles.icon}
           />
           <TextInput
             style={styles.input}
             value={this.usernameInputText}
             onChangeText={this.onChangeUsernameInputText}
             onKeyPress={this.onUsernameKeyPress}
             placeholder="Username"
             autoFocus={Platform.OS !== 'ios'}
             autoCorrect={false}
             autoCapitalize="none"
             keyboardType="ascii-capable"
             textContentType="username"
             autoComplete="username"
             returnKeyType="next"
             blurOnSubmit={false}
             onSubmitEditing={this.focusPasswordInput}
             editable={this.props.loadingStatus !== 'loading'}
             ref={this.usernameInputRef}
           />
         </View>
         <View style={styles.row}>
           <SWMansionIcon
             name="lock-on"
             size={22}
             color="#555"
             style={styles.icon}
           />
           <PasswordInput
             style={styles.input}
             value={this.passwordInputText}
             onChangeText={this.onChangePasswordInputText}
             placeholder="Password"
             textContentType="password"
             autoComplete="password"
             autoCapitalize="none"
             returnKeyType="go"
             blurOnSubmit={false}
             onSubmitEditing={this.onSubmit}
             editable={this.props.loadingStatus !== 'loading'}
             ref={this.passwordInputRef}
           />
         </View>
         <View style={styles.footer}>
           <PanelButton
             text="LOG IN"
             loadingStatus={this.props.loadingStatus}
             onSubmit={this.onSubmit}
           />
         </View>
       </Panel>
     );
   }
 
   usernameInputRef: (usernameInput: ?TextInput) => void = usernameInput => {
     this.usernameInput = usernameInput;
     if (Platform.OS === 'ios' && usernameInput) {
       setTimeout(() => usernameInput.focus());
     }
   };
 
   focusUsernameInput: () => void = () => {
     invariant(this.usernameInput, 'ref should be set');
     this.usernameInput.focus();
   };
 
   passwordInputRef: (passwordInput: ?PasswordInput) => void = passwordInput => {
     this.passwordInput = passwordInput;
   };
 
   focusPasswordInput: () => void = () => {
     invariant(this.passwordInput, 'ref should be set');
     this.passwordInput.focus();
   };
 
   onChangeUsernameInputText: (text: string) => void = text => {
     this.props.logInState.setState({ usernameInputText: text.trim() });
   };
 
   onUsernameKeyPress: (event: KeyPressEvent) => void = event => {
     const { key } = event.nativeEvent;
     if (
       key.length > 1 &&
       key !== 'Backspace' &&
       key !== 'Enter' &&
       this.passwordInputText.length === 0
     ) {
       this.focusPasswordInput();
     }
   };
 
   onChangePasswordInputText: (text: string) => void = text => {
     this.props.logInState.setState({ passwordInputText: text });
   };
 
   onSubmit: () => Promise<void> = async () => {
     this.props.setActiveAlert(true);
     if (this.usernameInputText.search(validEmailRegex) > -1) {
       Alert.alert(
         'Can’t log in with email',
         'You need to log in with your username now',
         [{ text: 'OK', onPress: this.onUsernameAlertAcknowledged }],
         { cancelable: false },
       );
       return;
     } else if (this.usernameInputText.search(oldValidUsernameRegex) === -1) {
       Alert.alert(
         'Invalid username',
         'Alphanumeric usernames only',
         [{ text: 'OK', onPress: this.onUsernameAlertAcknowledged }],
         { cancelable: false },
       );
       return;
     } else if (this.passwordInputText === '') {
       Alert.alert(
         'Empty password',
         'Password cannot be empty',
         [{ text: 'OK', onPress: this.onPasswordAlertAcknowledged }],
         { cancelable: false },
       );
       return;
     }
 
     Keyboard.dismiss();
     const extraInfo = await this.props.logInExtraInfo();
     const initialNotificationsEncryptedMessage =
       await this.props.getInitialNotificationsEncryptedMessage();
 
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       logInActionTypes,
       this.logInAction({ ...extraInfo, initialNotificationsEncryptedMessage }),
       undefined,
       ({ calendarQuery: extraInfo.calendarQuery }: LogInStartingPayload),
     );
   };
 
   async logInAction(extraInfo: LogInExtraInfo): Promise<LogInResult> {
     try {
       const result = await this.props.logIn({
         ...extraInfo,
         username: this.usernameInputText,
         password: this.passwordInputText,
         logInActionSource: logInActionSources.logInFromNativeForm,
       });
       this.props.setActiveAlert(false);
       await setNativeCredentials({
         username: result.currentUserInfo.username,
         password: this.passwordInputText,
       });
       return result;
     } catch (e) {
       if (e.message === 'invalid_credentials') {
         Alert.alert(
           'Incorrect username or password',
           "Either that user doesn't exist, or the password is incorrect",
           [{ text: 'OK', onPress: this.onUnsuccessfulLoginAlertAckowledged }],
           { cancelable: false },
         );
       } else if (e.message === 'client_version_unsupported') {
         Alert.alert(
           AppOutOfDateAlertDetails.title,
           AppOutOfDateAlertDetails.message,
           [{ text: 'OK', onPress: this.onAppOutOfDateAlertAcknowledged }],
           { cancelable: false },
         );
       } else {
         Alert.alert(
           'Unknown error',
           'Uhh... try again?',
           [{ text: 'OK', onPress: this.onUnknownErrorAlertAcknowledged }],
           { cancelable: false },
         );
       }
       throw e;
     }
   }
 
   onUnsuccessfulLoginAlertAckowledged: () => void = () => {
     this.props.setActiveAlert(false);
     this.props.logInState.setState(
       {
         usernameInputText: '',
         passwordInputText: '',
       },
       this.focusUsernameInput,
     );
   };
 
   onUsernameAlertAcknowledged: () => void = () => {
     this.props.setActiveAlert(false);
     this.props.logInState.setState(
       {
         usernameInputText: '',
       },
       this.focusUsernameInput,
     );
   };
 
   onPasswordAlertAcknowledged: () => void = () => {
     this.props.setActiveAlert(false);
     this.props.logInState.setState(
       {
         passwordInputText: '',
       },
       this.focusPasswordInput,
     );
   };
 
   onUnknownErrorAlertAcknowledged: () => void = () => {
     this.props.setActiveAlert(false);
     this.props.logInState.setState(
       {
         usernameInputText: '',
         passwordInputText: '',
       },
       this.focusUsernameInput,
     );
   };
 
   onAppOutOfDateAlertAcknowledged: () => void = () => {
     this.props.setActiveAlert(false);
   };
 }
 
 export type InnerLogInPanel = LogInPanel;
 
 const styles = StyleSheet.create({
   footer: {
     flexDirection: 'row',
     justifyContent: 'flex-end',
   },
   icon: {
     bottom: 10,
     left: 4,
     position: 'absolute',
   },
   input: {
     paddingLeft: 35,
   },
   row: {
     marginHorizontal: 24,
   },
 });
 
 const logInLoadingStatusSelector =
   createLoadingStatusSelector(logInActionTypes);
 const olmSessionInitializationDataLoadingStatusSelector =
   createLoadingStatusSelector(getOlmSessionInitializationDataActionTypes);
 
 const ConnectedLogInPanel: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedLogInPanel(props: BaseProps) {
     const logInLoadingStatus = useSelector(logInLoadingStatusSelector);
     const olmSessionInitializationDataLoadingStatus = useSelector(
       olmSessionInitializationDataLoadingStatusSelector,
     );
     const loadingStatus = combineLoadingStatuses(
       logInLoadingStatus,
       olmSessionInitializationDataLoadingStatus,
     );
 
     const navContext = React.useContext(NavContext);
     const logInExtraInfo = useSelector(state =>
       nativeLogInExtraInfoSelector({
         redux: state,
         navContext,
       }),
     );
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callLogIn = useLogIn();
     const getInitialNotificationsEncryptedMessage =
       useInitialNotificationsEncryptedMessage(
         nativeNotificationsSessionCreator,
       );
 
     return (
       <LogInPanel
         {...props}
         loadingStatus={loadingStatus}
         logInExtraInfo={logInExtraInfo}
         dispatchActionPromise={dispatchActionPromise}
         logIn={callLogIn}
         getInitialNotificationsEncryptedMessage={
           getInitialNotificationsEncryptedMessage
         }
       />
     );
   });
 
 export default ConnectedLogInPanel;
diff --git a/native/account/logged-out-modal.react.js b/native/account/logged-out-modal.react.js
index eeb9a4419..66e082157 100644
--- a/native/account/logged-out-modal.react.js
+++ b/native/account/logged-out-modal.react.js
@@ -1,846 +1,846 @@
 // @flow
 
 import Icon from '@expo/vector-icons/FontAwesome.js';
 import invariant from 'invariant';
 import _isEqual from 'lodash/fp/isEqual.js';
 import * as React from 'react';
 import {
   View,
   Text,
   TouchableOpacity,
   Image,
   Keyboard,
   Platform,
   BackHandler,
   ActivityIndicator,
 } from 'react-native';
 import Animated, { EasingNode } from 'react-native-reanimated';
 import { SafeAreaView } from 'react-native-safe-area-context';
 
 import { resetUserStateActionType } from 'lib/actions/user-actions.js';
 import {
   cookieSelector,
   urlPrefixSelector,
 } from 'lib/selectors/keyserver-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { useInitialNotificationsEncryptedMessage } from 'lib/shared/crypto-utils.js';
 import { logInActionSources } from 'lib/types/account-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { fetchNewCookieFromNativeCredentials } from 'lib/utils/action-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import { splashBackgroundURI } from './background-info.js';
 import FullscreenSIWEPanel from './fullscreen-siwe-panel.react.js';
 import LogInPanel from './log-in-panel.react.js';
 import type { LogInState } from './log-in-panel.react.js';
 import LoggedOutStaffInfo from './logged-out-staff-info.react.js';
 import RegisterPanel from './register-panel.react.js';
 import type { RegisterState } from './register-panel.react.js';
 import KeyboardAvoidingView from '../components/keyboard-avoiding-view.react.js';
 import ConnectedStatusBar from '../connected-status-bar.react.js';
 import {
   addKeyboardShowListener,
   addKeyboardDismissListener,
   removeKeyboardListener,
 } from '../keyboard/keyboard.js';
 import { createIsForegroundSelector } from '../navigation/nav-selectors.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import type { RootNavigationProp } from '../navigation/root-navigator.react.js';
 import {
   type NavigationRoute,
   LoggedOutModalRouteName,
   RegistrationRouteName,
   QRCodeSignInNavigatorRouteName,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { usePersistedStateLoaded } from '../selectors/app-state-selectors.js';
 import {
   type DerivedDimensionsInfo,
   derivedDimensionsInfoSelector,
 } from '../selectors/dimensions-selectors.js';
 import { splashStyleSelector } from '../splash.js';
 import { useStyles } from '../themes/colors.js';
 import type {
   EventSubscription,
   KeyboardEvent,
 } from '../types/react-native.js';
 import type { ImageStyle } from '../types/styles.js';
 import {
   runTiming,
   ratchetAlongWithKeyboardHeight,
 } from '../utils/animation-utils.js';
 import { nativeNotificationsSessionCreator } from '../utils/crypto-utils.js';
 import {
   type StateContainer,
   type StateChange,
   setStateForContainer,
 } from '../utils/state-container.js';
 import EthereumLogo from '../vectors/ethereum-logo.react.js';
 
 let initialAppLoad = true;
 const safeAreaEdges = ['top', 'bottom'];
 
 /* eslint-disable import/no-named-as-default-member */
 const {
   Value,
   Node,
   Clock,
   block,
   set,
   call,
   cond,
   not,
   and,
   eq,
   neq,
   lessThan,
   greaterOrEq,
   add,
   sub,
   divide,
   max,
   stopClock,
   clockRunning,
 } = Animated;
 /* eslint-enable import/no-named-as-default-member */
 
 export type LoggedOutMode =
   | 'loading'
   | 'prompt'
   | 'log-in'
   | 'register'
   | 'siwe';
 const modeNumbers: { [LoggedOutMode]: number } = {
   'loading': 0,
   'prompt': 1,
   'log-in': 2,
   'register': 3,
   'siwe': 4,
 };
 function isPastPrompt(modeValue: Node) {
   return and(
     neq(modeValue, modeNumbers['loading']),
     neq(modeValue, modeNumbers['prompt']),
   );
 }
 
 const unboundStyles = {
   animationContainer: {
     flex: 1,
   },
   backButton: {
     position: 'absolute',
     top: 13,
   },
   button: {
     borderRadius: 4,
     marginBottom: 4,
     marginTop: 4,
     marginLeft: 4,
     marginRight: 4,
     paddingBottom: 14,
     paddingLeft: 18,
     paddingRight: 18,
     paddingTop: 14,
     flex: 1,
   },
   buttonContainer: {
     bottom: 0,
     left: 0,
     marginLeft: 26,
     marginRight: 26,
     paddingBottom: 20,
     position: 'absolute',
     right: 0,
   },
   buttonText: {
     fontFamily: 'OpenSans-Semibold',
     fontSize: 17,
     textAlign: 'center',
   },
   classicAuthButton: {
     backgroundColor: 'purpleButton',
   },
   classicAuthButtonText: {
     color: 'whiteText',
   },
   registerButtons: {
     flexDirection: 'row',
   },
   signInButtons: {
     flexDirection: 'row',
   },
   container: {
     backgroundColor: 'transparent',
     flex: 1,
   },
   header: {
     color: 'white',
     fontFamily: Platform.OS === 'ios' ? 'IBMPlexSans' : 'IBMPlexSans-Medium',
     fontSize: 56,
     fontWeight: '500',
     lineHeight: 66,
     textAlign: 'center',
   },
   loadingIndicator: {
     paddingTop: 15,
   },
   modalBackground: {
     bottom: 0,
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
   siweButton: {
     backgroundColor: 'siweButton',
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'center',
   },
   siweButtonText: {
     color: 'siweButtonText',
   },
   siweOr: {
     flex: 1,
     flexDirection: 'row',
     marginBottom: 18,
     marginTop: 14,
   },
   siweOrLeftHR: {
     borderColor: 'logInSpacer',
     borderTopWidth: 1,
     flex: 1,
     marginRight: 18,
     marginTop: 10,
   },
   siweOrRightHR: {
     borderColor: 'logInSpacer',
     borderTopWidth: 1,
     flex: 1,
     marginLeft: 18,
     marginTop: 10,
   },
   siweOrText: {
     color: 'whiteText',
     fontSize: 17,
     textAlign: 'center',
   },
   siweIcon: {
     paddingRight: 10,
   },
 };
 
 type BaseProps = {
   +navigation: RootNavigationProp<'LoggedOutModal'>,
   +route: NavigationRoute<'LoggedOutModal'>,
 };
 
 type Props = {
   ...BaseProps,
   // Navigation state
   +isForeground: boolean,
   // Redux state
   +persistedStateLoaded: boolean,
   +rehydrateConcluded: boolean,
   +cookie: ?string,
   +urlPrefix: string,
   +loggedIn: boolean,
   +dimensions: DerivedDimensionsInfo,
   +splashStyle: ImageStyle,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatch: Dispatch,
   // Keyserver olm sessions functions
   +getInitialNotificationsEncryptedMessage: () => Promise<string>,
 };
 type State = {
   +mode: LoggedOutMode,
   +nextMode: LoggedOutMode,
   +logInState: StateContainer<LogInState>,
   +registerState: StateContainer<RegisterState>,
 };
 class LoggedOutModal extends React.PureComponent<Props, State> {
   keyboardShowListener: ?EventSubscription;
   keyboardHideListener: ?EventSubscription;
 
   mounted = false;
   nextMode: LoggedOutMode = 'loading';
   activeAlert = false;
 
   contentHeight: Value;
   keyboardHeightValue: Value = new Value(0);
   modeValue: Value;
 
   buttonOpacity: Value;
   panelPaddingTopValue: Node;
   panelOpacityValue: Node;
 
   constructor(props: Props) {
     super(props);
 
     // Man, this is a lot of boilerplate just to containerize some state.
     // Mostly due to Flow typing requirements...
     const setLogInState = setStateForContainer(
       this.guardedSetState,
       (change: Partial<LogInState>) => (fullState: State) => ({
         logInState: {
           ...fullState.logInState,
           state: { ...fullState.logInState.state, ...change },
         },
       }),
     );
     const setRegisterState = setStateForContainer<State, RegisterState>(
       this.guardedSetState,
       (change: Partial<RegisterState>) => (fullState: State) => ({
         registerState: {
           ...fullState.registerState,
           state: { ...fullState.registerState.state, ...change },
         },
       }),
     );
 
     const initialMode = props.persistedStateLoaded ? 'prompt' : 'loading';
     this.state = {
       mode: initialMode,
       nextMode: initialMode,
       logInState: {
         state: {
           usernameInputText: null,
           passwordInputText: null,
         },
         setState: setLogInState,
       },
       registerState: {
         state: {
           usernameInputText: '',
           passwordInputText: '',
           confirmPasswordInputText: '',
         },
         setState: setRegisterState,
       },
     };
     this.nextMode = initialMode;
 
     this.contentHeight = new Value(props.dimensions.safeAreaHeight);
     this.modeValue = new Value(modeNumbers[this.nextMode]);
 
     this.buttonOpacity = new Value(props.persistedStateLoaded ? 1 : 0);
     this.panelPaddingTopValue = this.panelPaddingTop();
     this.panelOpacityValue = this.panelOpacity();
   }
 
   guardedSetState = (change: StateChange<State>, callback?: () => mixed) => {
     if (this.mounted) {
       this.setState(change, callback);
     }
   };
 
   setMode(newMode: LoggedOutMode) {
     this.nextMode = newMode;
     this.guardedSetState({ mode: newMode, nextMode: newMode });
     this.modeValue.setValue(modeNumbers[newMode]);
   }
 
   proceedToNextMode = () => {
     this.guardedSetState({ mode: this.nextMode });
   };
 
   componentDidMount() {
     this.mounted = true;
     if (this.props.rehydrateConcluded) {
-      this.onInitialAppLoad();
+      void this.onInitialAppLoad();
     }
     if (this.props.isForeground) {
       this.onForeground();
     }
   }
 
   componentWillUnmount() {
     this.mounted = false;
     if (this.props.isForeground) {
       this.onBackground();
     }
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (!prevProps.persistedStateLoaded && this.props.persistedStateLoaded) {
       this.setMode('prompt');
     }
     if (!prevProps.rehydrateConcluded && this.props.rehydrateConcluded) {
-      this.onInitialAppLoad();
+      void this.onInitialAppLoad();
     }
     if (!prevProps.isForeground && this.props.isForeground) {
       this.onForeground();
     } else if (prevProps.isForeground && !this.props.isForeground) {
       this.onBackground();
     }
 
     if (this.state.mode === 'prompt' && prevState.mode !== 'prompt') {
       this.buttonOpacity.setValue(0);
       Animated.timing(this.buttonOpacity, {
         easing: EasingNode.out(EasingNode.ease),
         duration: 250,
         toValue: 1.0,
       }).start();
     }
 
     const newContentHeight = this.props.dimensions.safeAreaHeight;
     const oldContentHeight = prevProps.dimensions.safeAreaHeight;
     if (newContentHeight !== oldContentHeight) {
       this.contentHeight.setValue(newContentHeight);
     }
   }
 
   onForeground() {
     this.keyboardShowListener = addKeyboardShowListener(this.keyboardShow);
     this.keyboardHideListener = addKeyboardDismissListener(this.keyboardHide);
     BackHandler.addEventListener('hardwareBackPress', this.hardwareBack);
   }
 
   onBackground() {
     if (this.keyboardShowListener) {
       removeKeyboardListener(this.keyboardShowListener);
       this.keyboardShowListener = null;
     }
     if (this.keyboardHideListener) {
       removeKeyboardListener(this.keyboardHideListener);
       this.keyboardHideListener = null;
     }
     BackHandler.removeEventListener('hardwareBackPress', this.hardwareBack);
   }
 
   // This gets triggered when an app is killed and restarted
   // Not when it is returned from being backgrounded
   async onInitialAppLoad() {
     if (!initialAppLoad) {
       return;
     }
     initialAppLoad = false;
 
     const { loggedIn, cookie, urlPrefix, dispatch } = this.props;
     const hasUserCookie = cookie && cookie.startsWith('user=');
     if (loggedIn === !!hasUserCookie) {
       return;
     }
     if (!__DEV__) {
       const actionSource = loggedIn
         ? logInActionSources.appStartReduxLoggedInButInvalidCookie
         : logInActionSources.appStartCookieLoggedInButInvalidRedux;
       const sessionChange = await fetchNewCookieFromNativeCredentials(
         dispatch,
         cookie,
         urlPrefix,
         actionSource,
         ashoatKeyserverID,
         this.props.getInitialNotificationsEncryptedMessage,
       );
       if (
         sessionChange &&
         sessionChange.cookie &&
         sessionChange.cookie.startsWith('user=')
       ) {
         // success! we can expect subsequent actions to fix up the state
         return;
       }
     }
     this.props.dispatch({ type: resetUserStateActionType });
   }
 
   hardwareBack: () => boolean = () => {
     if (this.nextMode !== 'prompt') {
       this.goBackToPrompt();
       return true;
     }
     return false;
   };
 
   panelPaddingTop(): Node {
     const headerHeight = Platform.OS === 'ios' ? 62.33 : 58.54;
     const promptButtonsSize = Platform.OS === 'ios' ? 40 : 61;
     const logInContainerSize = 140;
     const registerPanelSize = Platform.OS === 'ios' ? 181 : 180;
     const siwePanelSize = 250;
 
     const containerSize = add(
       headerHeight,
       cond(not(isPastPrompt(this.modeValue)), promptButtonsSize, 0),
       cond(eq(this.modeValue, modeNumbers['log-in']), logInContainerSize, 0),
       cond(eq(this.modeValue, modeNumbers['register']), registerPanelSize, 0),
       cond(eq(this.modeValue, modeNumbers['siwe']), siwePanelSize, 0),
     );
     const potentialPanelPaddingTop = divide(
       max(sub(this.contentHeight, this.keyboardHeightValue, containerSize), 0),
       2,
     );
 
     const panelPaddingTop = new Value(-1);
     const targetPanelPaddingTop = new Value(-1);
     const prevModeValue = new Value(modeNumbers[this.nextMode]);
     const clock = new Clock();
     const keyboardTimeoutClock = new Clock();
     return block([
       cond(lessThan(panelPaddingTop, 0), [
         set(panelPaddingTop, potentialPanelPaddingTop),
         set(targetPanelPaddingTop, potentialPanelPaddingTop),
       ]),
       cond(
         lessThan(this.keyboardHeightValue, 0),
         [
           runTiming(keyboardTimeoutClock, 0, 1, true, { duration: 500 }),
           cond(
             not(clockRunning(keyboardTimeoutClock)),
             set(this.keyboardHeightValue, 0),
           ),
         ],
         stopClock(keyboardTimeoutClock),
       ),
       cond(
         and(
           greaterOrEq(this.keyboardHeightValue, 0),
           neq(prevModeValue, this.modeValue),
         ),
         [
           stopClock(clock),
           cond(
             neq(isPastPrompt(prevModeValue), isPastPrompt(this.modeValue)),
             set(targetPanelPaddingTop, potentialPanelPaddingTop),
           ),
           set(prevModeValue, this.modeValue),
         ],
       ),
       ratchetAlongWithKeyboardHeight(this.keyboardHeightValue, [
         stopClock(clock),
         set(targetPanelPaddingTop, potentialPanelPaddingTop),
       ]),
       cond(
         neq(panelPaddingTop, targetPanelPaddingTop),
         set(
           panelPaddingTop,
           runTiming(clock, panelPaddingTop, targetPanelPaddingTop),
         ),
       ),
       panelPaddingTop,
     ]);
   }
 
   panelOpacity(): Node {
     const targetPanelOpacity = isPastPrompt(this.modeValue);
 
     const panelOpacity = new Value(-1);
     const prevPanelOpacity = new Value(-1);
     const prevTargetPanelOpacity = new Value(-1);
     const clock = new Clock();
     return block([
       cond(lessThan(panelOpacity, 0), [
         set(panelOpacity, targetPanelOpacity),
         set(prevPanelOpacity, targetPanelOpacity),
         set(prevTargetPanelOpacity, targetPanelOpacity),
       ]),
       cond(greaterOrEq(this.keyboardHeightValue, 0), [
         cond(neq(targetPanelOpacity, prevTargetPanelOpacity), [
           stopClock(clock),
           set(prevTargetPanelOpacity, targetPanelOpacity),
         ]),
         cond(
           neq(panelOpacity, targetPanelOpacity),
           set(panelOpacity, runTiming(clock, panelOpacity, targetPanelOpacity)),
         ),
       ]),
       cond(
         and(eq(panelOpacity, 0), neq(prevPanelOpacity, 0)),
         call([], this.proceedToNextMode),
       ),
       set(prevPanelOpacity, panelOpacity),
       panelOpacity,
     ]);
   }
 
   keyboardShow = (event: KeyboardEvent) => {
     if (
       event.startCoordinates &&
       _isEqual(event.startCoordinates)(event.endCoordinates)
     ) {
       return;
     }
     const keyboardHeight: number = Platform.select({
       // Android doesn't include the bottomInset in this height measurement
       android: event.endCoordinates.height,
       default: Math.max(
         event.endCoordinates.height - this.props.dimensions.bottomInset,
         0,
       ),
     });
     this.keyboardHeightValue.setValue(keyboardHeight);
   };
 
   keyboardHide = () => {
     if (!this.activeAlert) {
       this.keyboardHeightValue.setValue(0);
     }
   };
 
   setActiveAlert = (activeAlert: boolean) => {
     this.activeAlert = activeAlert;
   };
 
   goBackToPrompt = () => {
     this.nextMode = 'prompt';
     this.guardedSetState({ nextMode: 'prompt' });
     this.keyboardHeightValue.setValue(0);
     this.modeValue.setValue(modeNumbers['prompt']);
     Keyboard.dismiss();
   };
 
   render(): React.Node {
     const { styles } = this.props;
 
     const siweButton = (
       <>
         <TouchableOpacity
           onPress={this.onPressSIWE}
           style={[styles.button, styles.siweButton]}
           activeOpacity={0.6}
         >
           <View style={styles.siweIcon}>
             <EthereumLogo />
           </View>
           <Text style={[styles.buttonText, styles.siweButtonText]}>
             Sign in with Ethereum
           </Text>
         </TouchableOpacity>
         <View style={styles.siweOr}>
           <View style={styles.siweOrLeftHR} />
           <Text style={styles.siweOrText}>or</Text>
           <View style={styles.siweOrRightHR} />
         </View>
       </>
     );
 
     let panel = null;
     let buttons = null;
     if (this.state.mode === 'log-in') {
       panel = (
         <LogInPanel
           setActiveAlert={this.setActiveAlert}
           opacityValue={this.panelOpacityValue}
           logInState={this.state.logInState}
         />
       );
     } else if (this.state.mode === 'register') {
       panel = (
         <RegisterPanel
           setActiveAlert={this.setActiveAlert}
           opacityValue={this.panelOpacityValue}
           registerState={this.state.registerState}
         />
       );
     } else if (this.state.mode === 'prompt') {
       const opacityStyle = { opacity: this.buttonOpacity };
 
       const registerButtons = [];
       registerButtons.push(
         <TouchableOpacity
           onPress={this.onPressRegister}
           style={[styles.button, styles.classicAuthButton]}
           activeOpacity={0.6}
           key="old"
         >
           <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
             Register
           </Text>
         </TouchableOpacity>,
       );
       if (__DEV__) {
         registerButtons.push(
           <TouchableOpacity
             onPress={this.onPressNewRegister}
             style={[styles.button, styles.classicAuthButton]}
             activeOpacity={0.6}
             key="new"
           >
             <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
               Register (new)
             </Text>
           </TouchableOpacity>,
         );
       }
 
       const signInButtons = [];
       signInButtons.push(
         <TouchableOpacity
           onPress={this.onPressLogIn}
           style={[styles.button, styles.classicAuthButton]}
           activeOpacity={0.6}
           key="login-form"
         >
           <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
             Sign in
           </Text>
         </TouchableOpacity>,
       );
       if (__DEV__) {
         signInButtons.push(
           <TouchableOpacity
             onPress={this.onPressQRCodeSignIn}
             style={[styles.button, styles.classicAuthButton]}
             activeOpacity={0.6}
             key="qr-code-login"
           >
             <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
               Sign in (QR)
             </Text>
           </TouchableOpacity>,
         );
       }
 
       buttons = (
         <Animated.View style={[styles.buttonContainer, opacityStyle]}>
           <LoggedOutStaffInfo />
           {siweButton}
           <View style={styles.signInButtons}>{signInButtons}</View>
           <View style={styles.registerButtons}>{registerButtons}</View>
         </Animated.View>
       );
     } else if (this.state.mode === 'loading') {
       panel = (
         <ActivityIndicator
           color="white"
           size="large"
           style={styles.loadingIndicator}
         />
       );
     }
 
     const windowWidth = this.props.dimensions.width;
     const buttonStyle = {
       opacity: this.panelOpacityValue,
       left: windowWidth < 360 ? 28 : 40,
     };
     const padding = { paddingTop: this.panelPaddingTopValue };
 
     const animatedContent = (
       <Animated.View style={[styles.animationContainer, padding]}>
         <View>
           <Text style={styles.header}>Comm</Text>
           <Animated.View style={[styles.backButton, buttonStyle]}>
             <TouchableOpacity activeOpacity={0.6} onPress={this.hardwareBack}>
               <Icon name="arrow-circle-o-left" size={36} color="#FFFFFFAA" />
             </TouchableOpacity>
           </Animated.View>
         </View>
         {panel}
       </Animated.View>
     );
 
     let siwePanel;
     if (this.state.mode === 'siwe') {
       siwePanel = (
         <FullscreenSIWEPanel
           goBackToPrompt={this.goBackToPrompt}
           closing={this.state.nextMode === 'prompt'}
         />
       );
     }
 
     const backgroundSource = { uri: splashBackgroundURI };
     return (
       <React.Fragment>
         <ConnectedStatusBar barStyle="light-content" />
         <Image
           source={backgroundSource}
           style={[styles.modalBackground, this.props.splashStyle]}
         />
         <SafeAreaView style={styles.container} edges={safeAreaEdges}>
           <KeyboardAvoidingView behavior="padding" style={styles.container}>
             {animatedContent}
             {buttons}
           </KeyboardAvoidingView>
         </SafeAreaView>
         {siwePanel}
       </React.Fragment>
     );
   }
 
   onPressSIWE = () => {
     this.setMode('siwe');
   };
 
   onPressLogIn = () => {
     if (Platform.OS !== 'ios') {
       // For some strange reason, iOS's password management logic doesn't
       // realize that the username and password fields in LogInPanel are related
       // if the username field gets focused on mount. To avoid this issue we
       // need the username and password fields to both appear on-screen before
       // we focus the username field. However, when we set keyboardHeightValue
       // to -1 here, we are telling our Reanimated logic to wait until the
       // keyboard appears before showing LogInPanel. Since we need LogInPanel
       // to appear before the username field is focused, we need to avoid this
       // behavior on iOS.
       this.keyboardHeightValue.setValue(-1);
     }
     this.setMode('log-in');
   };
 
   onPressQRCodeSignIn = () => {
     this.props.navigation.navigate(QRCodeSignInNavigatorRouteName);
   };
 
   onPressRegister = () => {
     this.keyboardHeightValue.setValue(-1);
     this.setMode('register');
   };
 
   onPressNewRegister = () => {
     this.props.navigation.navigate(RegistrationRouteName);
   };
 }
 
 const isForegroundSelector = createIsForegroundSelector(
   LoggedOutModalRouteName,
 );
 
 const ConnectedLoggedOutModal: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedLoggedOutModal(props: BaseProps) {
     const navContext = React.useContext(NavContext);
     const isForeground = isForegroundSelector(navContext);
 
     const rehydrateConcluded = useSelector(
       state => !!(state._persist && state._persist.rehydrated && navContext),
     );
     const persistedStateLoaded = usePersistedStateLoaded();
     const cookie = useSelector(cookieSelector(ashoatKeyserverID));
     const urlPrefix = useSelector(urlPrefixSelector(ashoatKeyserverID));
     invariant(urlPrefix, "missing urlPrefix for ashoat's keyserver");
     const loggedIn = useSelector(isLoggedIn);
     const dimensions = useSelector(derivedDimensionsInfoSelector);
     const splashStyle = useSelector(splashStyleSelector);
     const styles = useStyles(unboundStyles);
 
     const dispatch = useDispatch();
     const getInitialNotificationsEncryptedMessage =
       useInitialNotificationsEncryptedMessage(
         nativeNotificationsSessionCreator,
       );
     return (
       <LoggedOutModal
         {...props}
         isForeground={isForeground}
         persistedStateLoaded={persistedStateLoaded}
         rehydrateConcluded={rehydrateConcluded}
         cookie={cookie}
         urlPrefix={urlPrefix}
         loggedIn={loggedIn}
         dimensions={dimensions}
         splashStyle={splashStyle}
         styles={styles}
         dispatch={dispatch}
         getInitialNotificationsEncryptedMessage={
           getInitialNotificationsEncryptedMessage
         }
       />
     );
   });
 
 export default ConnectedLoggedOutModal;
diff --git a/native/account/register-panel.react.js b/native/account/register-panel.react.js
index 9572c5905..eef3d1339 100644
--- a/native/account/register-panel.react.js
+++ b/native/account/register-panel.react.js
@@ -1,513 +1,513 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   Text,
   View,
   StyleSheet,
   Platform,
   Keyboard,
   Linking,
 } from 'react-native';
 import Animated from 'react-native-reanimated';
 
 import { setDataLoadedActionType } from 'lib/actions/client-db-store-actions.js';
 import {
   registerActionTypes,
   register,
   getOlmSessionInitializationDataActionTypes,
 } from 'lib/actions/user-actions.js';
 import {
   createLoadingStatusSelector,
   combineLoadingStatuses,
 } from 'lib/selectors/loading-selectors.js';
 import { validUsernameRegex } from 'lib/shared/account-utils.js';
 import { useInitialNotificationsEncryptedMessage } from 'lib/shared/crypto-utils.js';
 import type {
   RegisterInfo,
   LogInExtraInfo,
   RegisterResult,
   LogInStartingPayload,
 } from 'lib/types/account-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import { TextInput } from './modal-components.react.js';
 import { setNativeCredentials } from './native-credentials.js';
 import { PanelButton, Panel } from './panel-components.react.js';
 import SWMansionIcon from '../components/swmansion-icon.react.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { nativeLogInExtraInfoSelector } from '../selectors/account-selectors.js';
 import type { KeyPressEvent } from '../types/react-native.js';
 import { AppOutOfDateAlertDetails } from '../utils/alert-messages.js';
 import Alert from '../utils/alert.js';
 import { nativeNotificationsSessionCreator } from '../utils/crypto-utils.js';
 import { type StateContainer } from '../utils/state-container.js';
 
 type WritableRegisterState = {
   usernameInputText: string,
   passwordInputText: string,
   confirmPasswordInputText: string,
 };
 export type RegisterState = $ReadOnly<WritableRegisterState>;
 type BaseProps = {
   +setActiveAlert: (activeAlert: boolean) => void,
   +opacityValue: Animated.Node,
   +registerState: StateContainer<RegisterState>,
 };
 type Props = {
   ...BaseProps,
   +loadingStatus: LoadingStatus,
   +logInExtraInfo: () => Promise<LogInExtraInfo>,
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   +register: (registerInfo: RegisterInfo) => Promise<RegisterResult>,
   +getInitialNotificationsEncryptedMessage: () => Promise<string>,
 };
 type State = {
   +confirmPasswordFocused: boolean,
 };
 class RegisterPanel extends React.PureComponent<Props, State> {
   state: State = {
     confirmPasswordFocused: false,
   };
   usernameInput: ?TextInput;
   passwordInput: ?TextInput;
   confirmPasswordInput: ?TextInput;
   passwordBeingAutoFilled = false;
 
   render(): React.Node {
     let confirmPasswordTextInputExtraProps;
     if (
       Platform.OS !== 'ios' ||
       this.state.confirmPasswordFocused ||
       this.props.registerState.state.confirmPasswordInputText.length > 0
     ) {
       confirmPasswordTextInputExtraProps = {
         secureTextEntry: true,
         textContentType: 'password',
       };
     }
 
     let onPasswordKeyPress;
     if (Platform.OS === 'ios') {
       onPasswordKeyPress = this.onPasswordKeyPress;
     }
 
     /* eslint-disable react-native/no-raw-text */
     const privatePolicyNotice = (
       <View style={styles.notice}>
         <Text style={styles.noticeText}>
           By signing up, you agree to our{' '}
           <Text style={styles.hyperlinkText} onPress={this.onTermsOfUsePressed}>
             Terms
           </Text>
           {' & '}
           <Text
             style={styles.hyperlinkText}
             onPress={this.onPrivacyPolicyPressed}
           >
             Privacy Policy
           </Text>
           .
         </Text>
       </View>
     );
     /* eslint-enable react-native/no-raw-text */
 
     return (
       <Panel opacityValue={this.props.opacityValue} style={styles.container}>
         <View style={styles.row}>
           <SWMansionIcon
             name="user-1"
             size={22}
             color="#555"
             style={styles.icon}
           />
           <TextInput
             style={styles.input}
             value={this.props.registerState.state.usernameInputText}
             onChangeText={this.onChangeUsernameInputText}
             placeholder="Username"
             autoFocus={true}
             autoCorrect={false}
             autoCapitalize="none"
             keyboardType="ascii-capable"
             textContentType="username"
             autoComplete="username-new"
             returnKeyType="next"
             blurOnSubmit={false}
             onSubmitEditing={this.focusPasswordInput}
             editable={this.props.loadingStatus !== 'loading'}
             ref={this.usernameInputRef}
           />
         </View>
         <View style={styles.row}>
           <SWMansionIcon
             name="lock-on"
             size={22}
             color="#555"
             style={styles.icon}
           />
           <TextInput
             style={styles.input}
             value={this.props.registerState.state.passwordInputText}
             onChangeText={this.onChangePasswordInputText}
             onKeyPress={onPasswordKeyPress}
             placeholder="Password"
             secureTextEntry={true}
             textContentType="password"
             autoComplete="password-new"
             returnKeyType="next"
             blurOnSubmit={false}
             onSubmitEditing={this.focusConfirmPasswordInput}
             editable={this.props.loadingStatus !== 'loading'}
             ref={this.passwordInputRef}
           />
         </View>
         <View style={styles.row}>
           <TextInput
             style={styles.input}
             value={this.props.registerState.state.confirmPasswordInputText}
             onChangeText={this.onChangeConfirmPasswordInputText}
             placeholder="Confirm password"
             autoComplete="password-new"
             returnKeyType="go"
             blurOnSubmit={false}
             onSubmitEditing={this.onSubmit}
             onFocus={this.onConfirmPasswordFocus}
             editable={this.props.loadingStatus !== 'loading'}
             ref={this.confirmPasswordInputRef}
             {...confirmPasswordTextInputExtraProps}
           />
         </View>
         <View style={styles.footer}>
           {privatePolicyNotice}
           <PanelButton
             text="SIGN UP"
             loadingStatus={this.props.loadingStatus}
             onSubmit={this.onSubmit}
           />
         </View>
       </Panel>
     );
   }
 
   usernameInputRef = (usernameInput: ?TextInput) => {
     this.usernameInput = usernameInput;
   };
 
   passwordInputRef = (passwordInput: ?TextInput) => {
     this.passwordInput = passwordInput;
   };
 
   confirmPasswordInputRef = (confirmPasswordInput: ?TextInput) => {
     this.confirmPasswordInput = confirmPasswordInput;
   };
 
   focusUsernameInput = () => {
     invariant(this.usernameInput, 'ref should be set');
     this.usernameInput.focus();
   };
 
   focusPasswordInput = () => {
     invariant(this.passwordInput, 'ref should be set');
     this.passwordInput.focus();
   };
 
   focusConfirmPasswordInput = () => {
     invariant(this.confirmPasswordInput, 'ref should be set');
     this.confirmPasswordInput.focus();
   };
 
   onTermsOfUsePressed = () => {
-    Linking.openURL('https://comm.app/terms');
+    void Linking.openURL('https://comm.app/terms');
   };
 
   onPrivacyPolicyPressed = () => {
-    Linking.openURL('https://comm.app/privacy');
+    void Linking.openURL('https://comm.app/privacy');
   };
 
   onChangeUsernameInputText = (text: string) => {
     this.props.registerState.setState({ usernameInputText: text });
   };
 
   onChangePasswordInputText = (text: string) => {
     const stateUpdate: Partial<WritableRegisterState> = {};
     stateUpdate.passwordInputText = text;
     if (this.passwordBeingAutoFilled) {
       this.passwordBeingAutoFilled = false;
       stateUpdate.confirmPasswordInputText = text;
     }
     this.props.registerState.setState(stateUpdate);
   };
 
   onPasswordKeyPress = (event: KeyPressEvent) => {
     const { key } = event.nativeEvent;
     if (
       key.length > 1 &&
       key !== 'Backspace' &&
       key !== 'Enter' &&
       this.props.registerState.state.confirmPasswordInputText.length === 0
     ) {
       this.passwordBeingAutoFilled = true;
     }
   };
 
   onChangeConfirmPasswordInputText = (text: string) => {
     this.props.registerState.setState({ confirmPasswordInputText: text });
   };
 
   onConfirmPasswordFocus = () => {
     this.setState({ confirmPasswordFocused: true });
   };
 
   onSubmit = async () => {
     this.props.setActiveAlert(true);
     if (this.props.registerState.state.passwordInputText === '') {
       Alert.alert(
         'Empty password',
         'Password cannot be empty',
         [{ text: 'OK', onPress: this.onPasswordAlertAcknowledged }],
         { cancelable: false },
       );
     } else if (
       this.props.registerState.state.passwordInputText !==
       this.props.registerState.state.confirmPasswordInputText
     ) {
       Alert.alert(
         'Passwords don’t match',
         'Password fields must contain the same password',
         [{ text: 'OK', onPress: this.onPasswordAlertAcknowledged }],
         { cancelable: false },
       );
     } else if (
       this.props.registerState.state.usernameInputText.search(
         validUsernameRegex,
       ) === -1
     ) {
       Alert.alert(
         'Invalid username',
         'Usernames must be at least six characters long, start with either a ' +
           'letter or a number, and may contain only letters, numbers, or the ' +
           'characters “-” and “_”',
         [{ text: 'OK', onPress: this.onUsernameAlertAcknowledged }],
         { cancelable: false },
       );
     } else {
       Keyboard.dismiss();
       const extraInfo = await this.props.logInExtraInfo();
       const initialNotificationsEncryptedMessage =
         await this.props.getInitialNotificationsEncryptedMessage();
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         registerActionTypes,
         this.registerAction({
           ...extraInfo,
           initialNotificationsEncryptedMessage,
         }),
         undefined,
         ({ calendarQuery: extraInfo.calendarQuery }: LogInStartingPayload),
       );
     }
   };
 
   onPasswordAlertAcknowledged = () => {
     this.props.setActiveAlert(false);
     this.props.registerState.setState(
       {
         passwordInputText: '',
         confirmPasswordInputText: '',
       },
       () => {
         invariant(this.passwordInput, 'ref should exist');
         this.passwordInput.focus();
       },
     );
   };
 
   onUsernameAlertAcknowledged = () => {
     this.props.setActiveAlert(false);
     this.props.registerState.setState(
       {
         usernameInputText: '',
       },
       () => {
         invariant(this.usernameInput, 'ref should exist');
         this.usernameInput.focus();
       },
     );
   };
 
   async registerAction(extraInfo: LogInExtraInfo): Promise<RegisterResult> {
     try {
       const result = await this.props.register({
         ...extraInfo,
         username: this.props.registerState.state.usernameInputText,
         password: this.props.registerState.state.passwordInputText,
       });
       this.props.setActiveAlert(false);
       this.props.dispatch({
         type: setDataLoadedActionType,
         payload: {
           dataLoaded: true,
         },
       });
       await setNativeCredentials({
         username: result.currentUserInfo.username,
         password: this.props.registerState.state.passwordInputText,
       });
       return result;
     } catch (e) {
       if (e.message === 'username_reserved') {
         Alert.alert(
           'Username reserved',
           'This username is currently reserved. Please contact support@' +
             'comm.app if you would like to claim this account.',
           [{ text: 'OK', onPress: this.onUsernameAlertAcknowledged }],
           { cancelable: false },
         );
       } else if (e.message === 'username_taken') {
         Alert.alert(
           'Username taken',
           'An account with that username already exists',
           [{ text: 'OK', onPress: this.onUsernameAlertAcknowledged }],
           { cancelable: false },
         );
       } else if (e.message === 'client_version_unsupported') {
         Alert.alert(
           AppOutOfDateAlertDetails.title,
           AppOutOfDateAlertDetails.message,
           [{ text: 'OK', onPress: this.onAppOutOfDateAlertAcknowledged }],
           { cancelable: false },
         );
       } else {
         Alert.alert(
           'Unknown error',
           'Uhh... try again?',
           [{ text: 'OK', onPress: this.onUnknownErrorAlertAcknowledged }],
           { cancelable: false },
         );
       }
       throw e;
     }
   }
 
   onUnknownErrorAlertAcknowledged = () => {
     this.props.setActiveAlert(false);
     this.props.registerState.setState(
       {
         usernameInputText: '',
         passwordInputText: '',
         confirmPasswordInputText: '',
       },
       () => {
         invariant(this.usernameInput, 'ref should exist');
         this.usernameInput.focus();
       },
     );
   };
 
   onAppOutOfDateAlertAcknowledged = () => {
     this.props.setActiveAlert(false);
   };
 }
 
 const styles = StyleSheet.create({
   container: {
     zIndex: 2,
   },
   footer: {
     alignItems: 'stretch',
     flexDirection: 'row',
     flexShrink: 1,
     justifyContent: 'space-between',
     paddingLeft: 24,
   },
   hyperlinkText: {
     color: '#036AFF',
     fontWeight: 'bold',
   },
   icon: {
     bottom: 10,
     left: 4,
     position: 'absolute',
   },
   input: {
     paddingLeft: 35,
   },
   notice: {
     alignSelf: 'center',
     display: 'flex',
     flexShrink: 1,
     maxWidth: 190,
     paddingBottom: 18,
     paddingRight: 8,
     paddingTop: 12,
   },
   noticeText: {
     color: '#444',
     fontSize: 13,
     lineHeight: 20,
     textAlign: 'center',
   },
   row: {
     marginHorizontal: 24,
   },
 });
 
 const registerLoadingStatusSelector =
   createLoadingStatusSelector(registerActionTypes);
 const olmSessionInitializationDataLoadingStatusSelector =
   createLoadingStatusSelector(getOlmSessionInitializationDataActionTypes);
 
 const ConnectedRegisterPanel: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedRegisterPanel(props: BaseProps) {
     const registerLoadingStatus = useSelector(registerLoadingStatusSelector);
     const olmSessionInitializationDataLoadingStatus = useSelector(
       olmSessionInitializationDataLoadingStatusSelector,
     );
     const loadingStatus = combineLoadingStatuses(
       registerLoadingStatus,
       olmSessionInitializationDataLoadingStatus,
     );
 
     const navContext = React.useContext(NavContext);
     const logInExtraInfo = useSelector(state =>
       nativeLogInExtraInfoSelector({
         redux: state,
         navContext,
       }),
     );
 
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const callRegister = useServerCall(register);
     const getInitialNotificationsEncryptedMessage =
       useInitialNotificationsEncryptedMessage(
         nativeNotificationsSessionCreator,
       );
 
     return (
       <RegisterPanel
         {...props}
         loadingStatus={loadingStatus}
         logInExtraInfo={logInExtraInfo}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         register={callRegister}
         getInitialNotificationsEncryptedMessage={
           getInitialNotificationsEncryptedMessage
         }
       />
     );
   });
 
 export default ConnectedRegisterPanel;
diff --git a/native/account/registration/connect-ethereum.react.js b/native/account/registration/connect-ethereum.react.js
index 8c28e48af..69695571f 100644
--- a/native/account/registration/connect-ethereum.react.js
+++ b/native/account/registration/connect-ethereum.react.js
@@ -1,315 +1,315 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import {
   exactSearchUser,
   exactSearchUserActionTypes,
 } from 'lib/actions/user-actions.js';
 import { ENSCacheContext } from 'lib/components/ens-cache-provider.react.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { SIWEResult } from 'lib/types/siwe-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import RegistrationButtonContainer from './registration-button-container.react.js';
 import RegistrationButton from './registration-button.react.js';
 import RegistrationContainer from './registration-container.react.js';
 import RegistrationContentContainer from './registration-content-container.react.js';
 import { RegistrationContext } from './registration-context.js';
 import type { RegistrationNavigationProp } from './registration-navigator.react.js';
 import {
   type CoolOrNerdMode,
   ensAvatarSelection,
 } from './registration-types.js';
 import {
   type NavigationRoute,
   ExistingEthereumAccountRouteName,
   UsernameSelectionRouteName,
   AvatarSelectionRouteName,
 } from '../../navigation/route-names.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { useStyles } from '../../themes/colors.js';
 import EthereumLogoDark from '../../vectors/ethereum-logo-dark.react.js';
 import SIWEPanel from '../siwe-panel.react.js';
 
 const exactSearchUserLoadingStatusSelector = createLoadingStatusSelector(
   exactSearchUserActionTypes,
 );
 
 export type ConnectEthereumParams = {
   +userSelections: {
     +coolOrNerdMode: CoolOrNerdMode,
     +keyserverURL: string,
   },
 };
 
 type PanelState = 'closed' | 'opening' | 'open' | 'closing';
 
 type Props = {
   +navigation: RegistrationNavigationProp<'ConnectEthereum'>,
   +route: NavigationRoute<'ConnectEthereum'>,
 };
 function ConnectEthereum(props: Props): React.Node {
   const { params } = props.route;
   const { userSelections } = props.route.params;
 
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const { setCachedSelections } = registrationContext;
 
   const isNerdMode = userSelections.coolOrNerdMode === 'nerd';
   const styles = useStyles(unboundStyles);
 
   let body;
   if (!isNerdMode) {
     body = (
       <Text style={styles.body}>
         Connecting your Ethereum wallet allows you to use your ENS name and
         avatar in the app. You&rsquo;ll also be able to log in with your wallet
         instead of a password.
       </Text>
     );
   } else {
     body = (
       <>
         <Text style={styles.body}>
           Connecting your Ethereum wallet has three benefits:
         </Text>
         <View style={styles.list}>
           <View style={styles.listItem}>
             <Text style={styles.listItemNumber}>{'1. '}</Text>
             <Text style={styles.listItemContent}>
               Your peers will be able to cryptographically verify that your Comm
               account is associated with your Ethereum wallet.
             </Text>
           </View>
           <View style={styles.listItem}>
             <Text style={styles.listItemNumber}>{'2. '}</Text>
             <Text style={styles.listItemContent}>
               You&rsquo;ll be able to use your ENS name and avatar in the app.
             </Text>
           </View>
           <View style={styles.listItem}>
             <Text style={styles.listItemNumber}>{'3. '}</Text>
             <Text style={styles.listItemContent}>
               You can choose to skip setting a password, and to log in with your
               Ethereum wallet instead.
             </Text>
           </View>
         </View>
       </>
     );
   }
 
   const [panelState, setPanelState] = React.useState<PanelState>('closed');
   const openPanel = React.useCallback(() => {
     setPanelState('opening');
   }, []);
   const onPanelClosed = React.useCallback(() => {
     setPanelState('closed');
   }, []);
   const onPanelClosing = React.useCallback(() => {
     setPanelState('closing');
   }, []);
 
   const siwePanelSetLoading = React.useCallback(
     (loading: boolean) => {
       if (panelState === 'closing' || panelState === 'closed') {
         return;
       }
       setPanelState(loading ? 'opening' : 'open');
     },
     [panelState],
   );
 
   const { navigate } = props.navigation;
   const onSkip = React.useCallback(() => {
     navigate<'UsernameSelection'>({
       name: UsernameSelectionRouteName,
       params,
     });
   }, [navigate, params]);
 
   const { keyserverURL } = userSelections;
   const serverCallParamOverride = React.useMemo(
     () => ({
       urlPrefix: keyserverURL,
     }),
     [keyserverURL],
   );
 
   const exactSearchUserCall = useServerCall(
     exactSearchUser,
     serverCallParamOverride,
   );
   const dispatchActionPromise = useDispatchActionPromise();
 
   const cacheContext = React.useContext(ENSCacheContext);
   const { ensCache } = cacheContext;
 
   const onSuccessfulWalletSignature = React.useCallback(
     async (result: SIWEResult) => {
       const searchPromise = exactSearchUserCall(result.address);
-      dispatchActionPromise(exactSearchUserActionTypes, searchPromise);
+      void dispatchActionPromise(exactSearchUserActionTypes, searchPromise);
 
       // We want to figure out if the user has an ENS avatar now
       // so that we can default to the ENS avatar in AvatarSelection
       const avatarURIPromise = (async () => {
         if (!ensCache) {
           return null;
         }
         return await ensCache.getAvatarURIForAddress(result.address);
       })();
 
       const { userInfo } = await searchPromise;
 
       if (userInfo) {
         navigate<'ExistingEthereumAccount'>({
           name: ExistingEthereumAccountRouteName,
           params: result,
         });
         return;
       }
 
       const avatarURI = await avatarURIPromise;
 
       const ethereumAccount = {
         accountType: 'ethereum',
         ...result,
         avatarURI,
       };
 
       setCachedSelections(oldUserSelections => {
         const base = {
           ...oldUserSelections,
           ethereumAccount,
         };
         if (base.avatarData || !avatarURI) {
           return base;
         }
         return {
           ...base,
           avatarData: ensAvatarSelection,
         };
       });
 
       const newUserSelections = {
         ...userSelections,
         accountSelection: ethereumAccount,
       };
       navigate<'AvatarSelection'>({
         name: AvatarSelectionRouteName,
         params: { userSelections: newUserSelections },
       });
     },
     [
       userSelections,
       exactSearchUserCall,
       dispatchActionPromise,
       setCachedSelections,
       navigate,
       ensCache,
     ],
   );
 
   let siwePanel;
   if (panelState !== 'closed') {
     siwePanel = (
       <SIWEPanel
         onClosing={onPanelClosing}
         onClosed={onPanelClosed}
         closing={panelState === 'closing'}
         onSuccessfulWalletSignature={onSuccessfulWalletSignature}
         setLoading={siwePanelSetLoading}
         keyserverCallParamOverride={serverCallParamOverride}
       />
     );
   }
 
   const exactSearchUserCallLoading = useSelector(
     state => exactSearchUserLoadingStatusSelector(state) === 'loading',
   );
   const connectButtonVariant =
     exactSearchUserCallLoading || panelState === 'opening'
       ? 'loading'
       : 'enabled';
 
   return (
     <>
       <RegistrationContainer>
         <RegistrationContentContainer style={styles.scrollViewContentContainer}>
           <Text style={styles.header}>
             Do you want to connect an Ethereum wallet?
           </Text>
           {body}
           <View style={styles.ethereumLogoContainer}>
             <EthereumLogoDark />
           </View>
         </RegistrationContentContainer>
         <RegistrationButtonContainer>
           <RegistrationButton
             onPress={openPanel}
             label="Connect Ethereum wallet"
             variant={connectButtonVariant}
           />
           <RegistrationButton
             onPress={onSkip}
             label="Do not connect"
             variant="outline"
           />
         </RegistrationButtonContainer>
       </RegistrationContainer>
       {siwePanel}
     </>
   );
 }
 
 const unboundStyles = {
   scrollViewContentContainer: {
     flexGrow: 1,
   },
   header: {
     fontSize: 24,
     color: 'panelForegroundLabel',
     paddingBottom: 16,
   },
   body: {
     fontFamily: 'Arial',
     fontSize: 15,
     lineHeight: 20,
     color: 'panelForegroundSecondaryLabel',
     paddingBottom: 16,
   },
   ethereumLogoContainer: {
     flexGrow: 1,
     alignItems: 'center',
     justifyContent: 'center',
   },
   list: {
     paddingBottom: 16,
   },
   listItem: {
     flexDirection: 'row',
   },
   listItemNumber: {
     fontFamily: 'Arial',
     fontWeight: 'bold',
     fontSize: 15,
     lineHeight: 20,
     color: 'panelForegroundSecondaryLabel',
   },
   listItemContent: {
     fontFamily: 'Arial',
     flexShrink: 1,
     fontSize: 15,
     lineHeight: 20,
     color: 'panelForegroundSecondaryLabel',
   },
 };
 
 export default ConnectEthereum;
diff --git a/native/account/registration/password-selection.react.js b/native/account/registration/password-selection.react.js
index 72472eaef..9fb37be54 100644
--- a/native/account/registration/password-selection.react.js
+++ b/native/account/registration/password-selection.react.js
@@ -1,249 +1,249 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text, Platform, TextInput } from 'react-native';
 
 import sleep from 'lib/utils/sleep.js';
 
 import RegistrationButtonContainer from './registration-button-container.react.js';
 import RegistrationButton from './registration-button.react.js';
 import RegistrationContainer from './registration-container.react.js';
 import RegistrationContentContainer from './registration-content-container.react.js';
 import { RegistrationContext } from './registration-context.js';
 import type { RegistrationNavigationProp } from './registration-navigator.react.js';
 import RegistrationTextInput from './registration-text-input.react.js';
 import type { CoolOrNerdMode } from './registration-types.js';
 import {
   type NavigationRoute,
   AvatarSelectionRouteName,
 } from '../../navigation/route-names.js';
 import { useStyles } from '../../themes/colors.js';
 import type { KeyPressEvent } from '../../types/react-native.js';
 
 export type PasswordSelectionParams = {
   +userSelections: {
     +coolOrNerdMode: CoolOrNerdMode,
     +keyserverURL: string,
     +username: string,
   },
 };
 
 type PasswordError = 'passwords_dont_match' | 'empty_password';
 
 type Props = {
   +navigation: RegistrationNavigationProp<'PasswordSelection'>,
   +route: NavigationRoute<'PasswordSelection'>,
 };
 function PasswordSelection(props: Props): React.Node {
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const { cachedSelections, setCachedSelections } = registrationContext;
 
   const [password, setPassword] = React.useState(
     cachedSelections.password ?? '',
   );
   const [confirmPassword, setConfirmPassword] = React.useState(
     cachedSelections.password ?? '',
   );
   const passwordsMatch = password === confirmPassword;
   const passwordIsEmpty = password === '';
 
   const [passwordError, setPasswordError] = React.useState<?PasswordError>();
   const potentiallyClearErrors = React.useCallback(() => {
     if (!passwordsMatch || passwordIsEmpty) {
       return false;
     }
     setPasswordError(null);
     return true;
   }, [passwordsMatch, passwordIsEmpty]);
 
   const checkPasswordValidity = React.useCallback(() => {
     if (!passwordsMatch) {
       setPasswordError('passwords_dont_match');
       return false;
     } else if (passwordIsEmpty) {
       setPasswordError('empty_password');
       return false;
     }
     return potentiallyClearErrors();
   }, [passwordsMatch, passwordIsEmpty, potentiallyClearErrors]);
 
   const { userSelections } = props.route.params;
   const { navigate } = props.navigation;
   const onProceed = React.useCallback(() => {
     if (!checkPasswordValidity()) {
       return;
     }
 
     const { coolOrNerdMode, keyserverURL, username } = userSelections;
     const newUserSelections = {
       coolOrNerdMode,
       keyserverURL,
       accountSelection: {
         accountType: 'username',
         username,
         password,
       },
     };
     setCachedSelections(oldUserSelections => ({
       ...oldUserSelections,
       password,
     }));
     navigate<'AvatarSelection'>({
       name: AvatarSelectionRouteName,
       params: { userSelections: newUserSelections },
     });
   }, [
     checkPasswordValidity,
     userSelections,
     password,
     setCachedSelections,
     navigate,
   ]);
 
   const styles = useStyles(unboundStyles);
   let errorText;
   if (passwordError === 'passwords_dont_match') {
     errorText = (
       <Text style={styles.errorText}>Passwords don&rsquo;t match</Text>
     );
   } else if (passwordError === 'empty_password') {
     errorText = <Text style={styles.errorText}>Password cannot be empty</Text>;
   }
 
   const confirmPasswordInputRef =
     React.useRef<?React.ElementRef<typeof TextInput>>();
   const focusConfirmPasswordInput = React.useCallback(() => {
     confirmPasswordInputRef.current?.focus();
   }, []);
 
   const iosPasswordBeingAutoFilled = React.useRef(false);
   const confirmPasswordEmpty = confirmPassword.length === 0;
   const onPasswordKeyPress = React.useCallback(
     (event: KeyPressEvent) => {
       const { key } = event.nativeEvent;
       // On iOS, paste doesn't trigger onKeyPress, but password autofill does
       // Password autofill calls onKeyPress with `key` set to the whole password
       if (
         key.length > 1 &&
         key !== 'Backspace' &&
         key !== 'Enter' &&
         confirmPasswordEmpty
       ) {
         iosPasswordBeingAutoFilled.current = true;
       }
     },
     [confirmPasswordEmpty],
   );
 
   const passwordInputRef = React.useRef<?React.ElementRef<typeof TextInput>>();
   const passwordLength = password.length;
   const onChangePasswordInput = React.useCallback(
     (input: string) => {
       setPassword(input);
       if (iosPasswordBeingAutoFilled.current) {
         // On iOS, paste doesn't trigger onKeyPress, but password autofill does
         iosPasswordBeingAutoFilled.current = false;
         setConfirmPassword(input);
         passwordInputRef.current?.blur();
       } else if (
         Platform.OS === 'android' &&
         input.length - passwordLength > 1 &&
         confirmPasswordEmpty
       ) {
         // On Android, password autofill doesn't trigger onKeyPress. Instead we
         // rely on observing when the password field changes by more than one
         // character at a time. This means we treat paste the same way as
         // password autofill
         setConfirmPassword(input);
         passwordInputRef.current?.blur();
       }
     },
     [passwordLength, confirmPasswordEmpty],
   );
 
   const shouldAutoFocus = React.useRef(!cachedSelections.password);
 
   /* eslint-disable react-hooks/rules-of-hooks */
   if (Platform.OS === 'android') {
     // It's okay to call this hook conditionally because
     // the condition is guaranteed to never change
     React.useEffect(() => {
-      (async () => {
+      void (async () => {
         await sleep(250);
         if (shouldAutoFocus.current) {
           passwordInputRef.current?.focus();
         }
       })();
     }, []);
   }
   /* eslint-enable react-hooks/rules-of-hooks */
 
   const autoFocus = Platform.OS !== 'android' && shouldAutoFocus.current;
 
   return (
     <RegistrationContainer>
       <RegistrationContentContainer>
         <Text style={styles.header}>Pick a password</Text>
         <RegistrationTextInput
           value={password}
           onChangeText={onChangePasswordInput}
           placeholder="Password"
           autoFocus={autoFocus}
           secureTextEntry={true}
           textContentType="newPassword"
           autoComplete="password-new"
           returnKeyType="next"
           onSubmitEditing={focusConfirmPasswordInput}
           onKeyPress={onPasswordKeyPress}
           onBlur={potentiallyClearErrors}
           ref={passwordInputRef}
         />
         <RegistrationTextInput
           value={confirmPassword}
           onChangeText={setConfirmPassword}
           placeholder="Confirm password"
           secureTextEntry={true}
           textContentType="newPassword"
           autoComplete="password-new"
           returnKeyType="go"
           onSubmitEditing={onProceed}
           onBlur={checkPasswordValidity}
           style={styles.confirmPassword}
           ref={confirmPasswordInputRef}
         />
         <View style={styles.error}>{errorText}</View>
       </RegistrationContentContainer>
       <RegistrationButtonContainer>
         <RegistrationButton
           onPress={onProceed}
           label="Next"
           variant={passwordsMatch && !passwordIsEmpty ? 'enabled' : 'disabled'}
         />
       </RegistrationButtonContainer>
     </RegistrationContainer>
   );
 }
 
 const unboundStyles = {
   header: {
     fontSize: 24,
     color: 'panelForegroundLabel',
     paddingBottom: 16,
   },
   error: {
     marginTop: 16,
   },
   errorText: {
     fontFamily: 'Arial',
     fontSize: 15,
     lineHeight: 20,
     color: 'redText',
   },
   confirmPassword: {
     marginTop: 16,
   },
 };
 
 export default PasswordSelection;
diff --git a/native/account/registration/registration-server-call.js b/native/account/registration/registration-server-call.js
index 35cd43cd3..ecf3952df 100644
--- a/native/account/registration/registration-server-call.js
+++ b/native/account/registration/registration-server-call.js
@@ -1,230 +1,230 @@
 // @flow
 
 import * as React from 'react';
 
 import { setDataLoadedActionType } from 'lib/actions/client-db-store-actions.js';
 import { registerActionTypes, register } from 'lib/actions/user-actions.js';
 import type { LogInStartingPayload } from 'lib/types/account-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { setURLPrefix } from 'lib/utils/url-utils.js';
 
 import type {
   RegistrationServerCallInput,
   UsernameAccountSelection,
   AvatarData,
 } from './registration-types.js';
 import {
   useNativeSetUserAvatar,
   useUploadSelectedMedia,
 } from '../../avatars/avatar-hooks.js';
 import { NavContext } from '../../navigation/navigation-context.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { nativeLogInExtraInfoSelector } from '../../selectors/account-selectors.js';
 import { AppOutOfDateAlertDetails } from '../../utils/alert-messages.js';
 import Alert from '../../utils/alert.js';
 import { setNativeCredentials } from '../native-credentials.js';
 import { useSIWEServerCall } from '../siwe-hooks.js';
 
 // We can't just do everything in one async callback, since the server calls
 // would get bound to Redux state from before the registration. The registration
 // flow has multiple steps where critical Redux state is changed, where
 // subsequent steps depend on accessing the updated Redux state.
 
 // To address this, we break the registration process up into multiple steps.
 // When each step completes we update the currentStep state, and we have Redux
 // selectors that trigger useEffects for subsequent steps when relevant data
 // starts to appear in Redux.
 
 type CurrentStep =
   | { +step: 'inactive' }
   | {
       +step: 'waiting_for_registration_call',
       +avatarData: ?AvatarData,
       +resolve: () => void,
       +reject: Error => void,
     };
 
 const inactiveStep = { step: 'inactive' };
 
 function useRegistrationServerCall(): RegistrationServerCallInput => Promise<void> {
   const [currentStep, setCurrentStep] =
     React.useState<CurrentStep>(inactiveStep);
 
   // STEP 1: ACCOUNT REGISTRATION
 
   const navContext = React.useContext(NavContext);
   const logInExtraInfo = useSelector(state =>
     nativeLogInExtraInfoSelector({
       redux: state,
       navContext,
     }),
   );
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callRegister = useServerCall(register);
 
   const registerUsernameAccount = React.useCallback(
     async (
       accountSelection: UsernameAccountSelection,
       keyserverURL: string,
     ) => {
       const extraInfo = await logInExtraInfo();
       const registerPromise = (async () => {
         try {
           const result = await callRegister(
             {
               ...extraInfo,
               username: accountSelection.username,
               password: accountSelection.password,
             },
             {
               urlPrefixOverride: keyserverURL,
             },
           );
           await setNativeCredentials({
             username: result.currentUserInfo.username,
             password: accountSelection.password,
           });
           return result;
         } catch (e) {
           if (e.message === 'username_reserved') {
             Alert.alert(
               'Username reserved',
               'This username is currently reserved. Please contact support@' +
                 'comm.app if you would like to claim this account.',
             );
           } else if (e.message === 'username_taken') {
             Alert.alert(
               'Username taken',
               'An account with that username already exists',
             );
           } else if (e.message === 'client_version_unsupported') {
             Alert.alert(
               AppOutOfDateAlertDetails.title,
               AppOutOfDateAlertDetails.message,
             );
           } else {
             Alert.alert('Unknown error', 'Uhh... try again?');
           }
           throw e;
         }
       })();
-      dispatchActionPromise(
+      void dispatchActionPromise(
         registerActionTypes,
         registerPromise,
         undefined,
         ({ calendarQuery: extraInfo.calendarQuery }: LogInStartingPayload),
       );
       await registerPromise;
     },
     [logInExtraInfo, callRegister, dispatchActionPromise],
   );
 
   const siweServerCallParams = React.useMemo(() => {
     const onServerCallFailure = () => {
       Alert.alert('Unknown error', 'Uhh... try again?');
     };
     return { onFailure: onServerCallFailure };
   }, []);
   const siweServerCall = useSIWEServerCall(siweServerCallParams);
 
   const dispatch = useDispatch();
   const returnedFunc = React.useCallback(
     (input: RegistrationServerCallInput) =>
       new Promise<void>(
         // eslint-disable-next-line no-async-promise-executor
         async (resolve, reject) => {
           try {
             if (currentStep.step !== 'inactive') {
               return;
             }
             const { accountSelection, avatarData, keyserverURL } = input;
             if (accountSelection.accountType === 'username') {
               await registerUsernameAccount(accountSelection, keyserverURL);
             } else {
               await siweServerCall(accountSelection, {
                 urlPrefixOverride: keyserverURL,
               });
             }
             dispatch({
               type: setURLPrefix,
               payload: keyserverURL,
             });
             setCurrentStep({
               step: 'waiting_for_registration_call',
               avatarData,
               resolve,
               reject,
             });
           } catch (e) {
             reject(e);
           }
         },
       ),
     [currentStep, registerUsernameAccount, siweServerCall, dispatch],
   );
 
   // STEP 2: SETTING AVATAR
 
   const uploadSelectedMedia = useUploadSelectedMedia();
   const nativeSetUserAvatar = useNativeSetUserAvatar();
 
   const hasCurrentUserInfo = useSelector(
     state => !!state.currentUserInfo && !state.currentUserInfo.anonymous,
   );
 
   const avatarBeingSetRef = React.useRef(false);
   React.useEffect(() => {
     if (
       !hasCurrentUserInfo ||
       currentStep.step !== 'waiting_for_registration_call' ||
       avatarBeingSetRef.current
     ) {
       return;
     }
     avatarBeingSetRef.current = true;
     const { avatarData, resolve } = currentStep;
-    (async () => {
+    void (async () => {
       try {
         if (!avatarData) {
           return;
         }
         let updateUserAvatarRequest;
         if (!avatarData.needsUpload) {
           ({ updateUserAvatarRequest } = avatarData);
         } else {
           const { mediaSelection } = avatarData;
           updateUserAvatarRequest = await uploadSelectedMedia(mediaSelection);
           if (!updateUserAvatarRequest) {
             return;
           }
         }
         await nativeSetUserAvatar(updateUserAvatarRequest);
       } finally {
         dispatch({
           type: setDataLoadedActionType,
           payload: {
             dataLoaded: true,
           },
         });
         setCurrentStep(inactiveStep);
         avatarBeingSetRef.current = false;
         resolve();
       }
     })();
   }, [
     currentStep,
     hasCurrentUserInfo,
     uploadSelectedMedia,
     nativeSetUserAvatar,
     dispatch,
   ]);
 
   return returnedFunc;
 }
 
 export { useRegistrationServerCall };
diff --git a/native/account/registration/registration-terms.react.js b/native/account/registration/registration-terms.react.js
index c2def8e41..0828d7641 100644
--- a/native/account/registration/registration-terms.react.js
+++ b/native/account/registration/registration-terms.react.js
@@ -1,131 +1,131 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, View, Image, Linking } from 'react-native';
 
 import RegistrationButtonContainer from './registration-button-container.react.js';
 import RegistrationButton from './registration-button.react.js';
 import RegistrationContainer from './registration-container.react.js';
 import RegistrationContentContainer from './registration-content-container.react.js';
 import { RegistrationContext } from './registration-context.js';
 import type { RegistrationNavigationProp } from './registration-navigator.react.js';
 import type {
   CoolOrNerdMode,
   AccountSelection,
   AvatarData,
 } from './registration-types.js';
 import commSwooshSource from '../../img/comm-swoosh.png';
 import type { NavigationRoute } from '../../navigation/route-names.js';
 import { useStyles } from '../../themes/colors.js';
 
 export type RegistrationTermsParams = {
   +userSelections: {
     +coolOrNerdMode: CoolOrNerdMode,
     +keyserverURL: string,
     +accountSelection: AccountSelection,
     +avatarData: ?AvatarData,
   },
 };
 
 const onTermsOfUsePressed = () => {
-  Linking.openURL('https://comm.app/terms');
+  void Linking.openURL('https://comm.app/terms');
 };
 
 const onPrivacyPolicyPressed = () => {
-  Linking.openURL('https://comm.app/privacy');
+  void Linking.openURL('https://comm.app/privacy');
 };
 
 type Props = {
   +navigation: RegistrationNavigationProp<'RegistrationTerms'>,
   +route: NavigationRoute<'RegistrationTerms'>,
 };
 function RegistrationTerms(props: Props): React.Node {
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const { register } = registrationContext;
 
   const [registrationInProgress, setRegistrationInProgress] =
     React.useState(false);
 
   const { userSelections } = props.route.params;
   const onProceed = React.useCallback(async () => {
     setRegistrationInProgress(true);
     try {
       await register(userSelections);
     } finally {
       setRegistrationInProgress(false);
     }
   }, [register, userSelections]);
 
   const styles = useStyles(unboundStyles);
 
   /* eslint-disable react-native/no-raw-text */
   const termsNotice = (
     <Text style={styles.body}>
       By registering, you are agreeing to our{' '}
       <Text style={styles.hyperlinkText} onPress={onTermsOfUsePressed}>
         Terms of Use
       </Text>
       {' and '}
       <Text style={styles.hyperlinkText} onPress={onPrivacyPolicyPressed}>
         Privacy Policy
       </Text>
       .
     </Text>
   );
   /* eslint-enable react-native/no-raw-text */
 
   return (
     <RegistrationContainer>
       <RegistrationContentContainer style={styles.scrollViewContentContainer}>
         <Text style={styles.header}>Finish registration</Text>
         {termsNotice}
         <View style={styles.commSwooshContainer}>
           <Image source={commSwooshSource} style={styles.commSwoosh} />
         </View>
       </RegistrationContentContainer>
       <RegistrationButtonContainer>
         <RegistrationButton
           onPress={onProceed}
           label="Register"
           variant={registrationInProgress ? 'loading' : 'enabled'}
         />
       </RegistrationButtonContainer>
     </RegistrationContainer>
   );
 }
 
 const unboundStyles = {
   scrollViewContentContainer: {
     flexGrow: 1,
   },
   header: {
     fontSize: 24,
     color: 'panelForegroundLabel',
     paddingBottom: 16,
   },
   body: {
     fontFamily: 'Arial',
     fontSize: 15,
     lineHeight: 20,
     color: 'panelForegroundSecondaryLabel',
     paddingBottom: 16,
   },
   commSwooshContainer: {
     flexGrow: 1,
     flexShrink: 1,
     alignItems: 'center',
     justifyContent: 'center',
   },
   commSwoosh: {
     resizeMode: 'center',
     width: '100%',
     height: '100%',
   },
   hyperlinkText: {
     color: 'purpleLink',
   },
 };
 
 export default RegistrationTerms;
diff --git a/native/account/registration/username-selection.react.js b/native/account/registration/username-selection.react.js
index 2856e6ea2..455d359bc 100644
--- a/native/account/registration/username-selection.react.js
+++ b/native/account/registration/username-selection.react.js
@@ -1,226 +1,226 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text } from 'react-native';
 
 import {
   exactSearchUser,
   exactSearchUserActionTypes,
 } from 'lib/actions/user-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { validUsernameRegex } from 'lib/shared/account-utils.js';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import RegistrationButtonContainer from './registration-button-container.react.js';
 import RegistrationButton from './registration-button.react.js';
 import RegistrationContainer from './registration-container.react.js';
 import RegistrationContentContainer from './registration-content-container.react.js';
 import { RegistrationContext } from './registration-context.js';
 import type { RegistrationNavigationProp } from './registration-navigator.react.js';
 import RegistrationTextInput from './registration-text-input.react.js';
 import type { CoolOrNerdMode } from './registration-types.js';
 import {
   type NavigationRoute,
   PasswordSelectionRouteName,
 } from '../../navigation/route-names.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { useStyles } from '../../themes/colors.js';
 
 const exactSearchUserLoadingStatusSelector = createLoadingStatusSelector(
   exactSearchUserActionTypes,
 );
 
 export type UsernameSelectionParams = {
   +userSelections: {
     +coolOrNerdMode: CoolOrNerdMode,
     +keyserverURL: string,
   },
 };
 
 type UsernameError = 'username_invalid' | 'username_taken';
 
 type Props = {
   +navigation: RegistrationNavigationProp<'UsernameSelection'>,
   +route: NavigationRoute<'UsernameSelection'>,
 };
 function UsernameSelection(props: Props): React.Node {
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const { cachedSelections, setCachedSelections } = registrationContext;
 
   const [username, setUsername] = React.useState(
     cachedSelections.username ?? '',
   );
   const validUsername = username.search(validUsernameRegex) > -1;
 
   const [usernameError, setUsernameError] = React.useState<?UsernameError>();
   const checkUsernameValidity = React.useCallback(() => {
     if (!validUsername) {
       setUsernameError('username_invalid');
       return false;
     }
     setUsernameError(null);
     return true;
   }, [validUsername]);
 
   const { userSelections } = props.route.params;
   const { keyserverURL } = userSelections;
   const serverCallParamOverride = React.useMemo(
     () => ({
       urlPrefix: keyserverURL,
     }),
     [keyserverURL],
   );
 
   const exactSearchUserCall = useServerCall(
     exactSearchUser,
     serverCallParamOverride,
   );
   const dispatchActionPromise = useDispatchActionPromise();
   const { navigate } = props.navigation;
   const onProceed = React.useCallback(async () => {
     if (!checkUsernameValidity()) {
       return;
     }
 
     const searchPromise = exactSearchUserCall(username);
-    dispatchActionPromise(exactSearchUserActionTypes, searchPromise);
+    void dispatchActionPromise(exactSearchUserActionTypes, searchPromise);
     const { userInfo } = await searchPromise;
 
     if (userInfo) {
       setUsernameError('username_taken');
       return;
     }
 
     setUsernameError(undefined);
     setCachedSelections(oldUserSelections => ({
       ...oldUserSelections,
       username,
     }));
     navigate<'PasswordSelection'>({
       name: PasswordSelectionRouteName,
       params: {
         userSelections: {
           ...userSelections,
           username,
         },
       },
     });
   }, [
     checkUsernameValidity,
     username,
     exactSearchUserCall,
     dispatchActionPromise,
     setCachedSelections,
     navigate,
     userSelections,
   ]);
 
   const exactSearchUserCallLoading = useSelector(
     state => exactSearchUserLoadingStatusSelector(state) === 'loading',
   );
   let buttonVariant = 'disabled';
   if (exactSearchUserCallLoading) {
     buttonVariant = 'loading';
   } else if (validUsername) {
     buttonVariant = 'enabled';
   }
 
   const styles = useStyles(unboundStyles);
   let errorText;
   if (usernameError === 'username_invalid') {
     errorText = (
       <>
         <Text style={styles.errorText}>Usernames must:</Text>
         <View style={styles.listItem}>
           <Text style={[styles.errorText, styles.listItemNumber]}>{'1. '}</Text>
           <Text style={[styles.errorText, styles.listItemContent]}>
             Be at least one character long.
           </Text>
         </View>
         <View style={styles.listItem}>
           <Text style={[styles.errorText, styles.listItemNumber]}>{'2. '}</Text>
           <Text style={[styles.errorText, styles.listItemContent]}>
             Start with either a letter or a number.
           </Text>
         </View>
         <View style={styles.listItem}>
           <Text style={[styles.errorText, styles.listItemNumber]}>{'3. '}</Text>
           <Text style={[styles.errorText, styles.listItemContent]}>
             Contain only letters, numbers, or the characters “-” and “_”.
           </Text>
         </View>
       </>
     );
   } else if (usernameError === 'username_taken') {
     errorText = (
       <Text style={styles.errorText}>
         Username taken. Please try another one
       </Text>
     );
   }
 
   const shouldAutoFocus = React.useRef(!cachedSelections.username);
   return (
     <RegistrationContainer>
       <RegistrationContentContainer>
         <Text style={styles.header}>Pick a username</Text>
         <RegistrationTextInput
           value={username}
           onChangeText={setUsername}
           placeholder="Username"
           autoFocus={shouldAutoFocus.current}
           autoCorrect={false}
           autoCapitalize="none"
           keyboardType="ascii-capable"
           textContentType="username"
           autoComplete="username-new"
           returnKeyType="go"
           onSubmitEditing={onProceed}
           editable={!exactSearchUserCallLoading}
           onBlur={checkUsernameValidity}
         />
         <View style={styles.error}>{errorText}</View>
       </RegistrationContentContainer>
       <RegistrationButtonContainer>
         <RegistrationButton
           onPress={onProceed}
           label="Next"
           variant={buttonVariant}
         />
       </RegistrationButtonContainer>
     </RegistrationContainer>
   );
 }
 
 const unboundStyles = {
   header: {
     fontSize: 24,
     color: 'panelForegroundLabel',
     paddingBottom: 16,
   },
   error: {
     marginTop: 16,
   },
   errorText: {
     fontFamily: 'Arial',
     fontSize: 15,
     lineHeight: 20,
     color: 'redText',
   },
   listItem: {
     flexDirection: 'row',
   },
   listItemNumber: {
     fontWeight: 'bold',
   },
   listItemContent: {
     flexShrink: 1,
   },
 };
 
 export default UsernameSelection;
diff --git a/native/account/siwe-hooks.js b/native/account/siwe-hooks.js
index 487bbd223..54f7de476 100644
--- a/native/account/siwe-hooks.js
+++ b/native/account/siwe-hooks.js
@@ -1,109 +1,109 @@
 // @flow
 
 import * as React from 'react';
 
 import { siweAuth, siweAuthActionTypes } from 'lib/actions/siwe-actions.js';
 import { useInitialNotificationsEncryptedMessage } from 'lib/shared/crypto-utils.js';
 import type {
   LogInStartingPayload,
   LogInExtraInfo,
 } from 'lib/types/account-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import type { CallServerEndpointOptions } from 'lib/utils/call-server-endpoint.js';
 
 import { NavContext } from '../navigation/navigation-context.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { nativeLogInExtraInfoSelector } from '../selectors/account-selectors.js';
 import { nativeNotificationsSessionCreator } from '../utils/crypto-utils.js';
 
 type SIWEServerCallParams = {
   +message: string,
   +signature: string,
   ...
 };
 type UseSIWEServerCallParams = {
   +onFailure: () => mixed,
 };
 function useSIWEServerCall(
   params: UseSIWEServerCallParams,
 ): (SIWEServerCallParams, ?CallServerEndpointOptions) => Promise<void> {
   const { onFailure } = params;
 
   const siweAuthCall = useServerCall(siweAuth);
 
   const callSIWE = React.useCallback(
     async (
       message: string,
       signature: string,
       extraInfo: LogInExtraInfo,
       callServerEndpointOptions: ?CallServerEndpointOptions,
     ) => {
       try {
         return await siweAuthCall(
           {
             message,
             signature,
             ...extraInfo,
           },
           callServerEndpointOptions,
         );
       } catch (e) {
         onFailure();
         throw e;
       }
     },
     [onFailure, siweAuthCall],
   );
 
   const navContext = React.useContext(NavContext);
   const logInExtraInfo = useSelector(state =>
     nativeLogInExtraInfoSelector({
       redux: state,
       navContext,
     }),
   );
 
   const getInitialNotificationsEncryptedMessage =
     useInitialNotificationsEncryptedMessage(nativeNotificationsSessionCreator);
 
   const dispatchActionPromise = useDispatchActionPromise();
   return React.useCallback(
     async ({ message, signature }, callServerEndpointOptions) => {
       const extraInfo = await logInExtraInfo();
       const initialNotificationsEncryptedMessage =
         await getInitialNotificationsEncryptedMessage({
           callServerEndpointOptions,
         });
 
       const siwePromise = callSIWE(
         message,
         signature,
         {
           ...extraInfo,
           initialNotificationsEncryptedMessage,
         },
         callServerEndpointOptions,
       );
 
-      dispatchActionPromise(
+      void dispatchActionPromise(
         siweAuthActionTypes,
         siwePromise,
         undefined,
         ({ calendarQuery: extraInfo.calendarQuery }: LogInStartingPayload),
       );
 
       await siwePromise;
     },
     [
       logInExtraInfo,
       dispatchActionPromise,
       callSIWE,
       getInitialNotificationsEncryptedMessage,
     ],
   );
 }
 
 export { useSIWEServerCall };
diff --git a/native/account/siwe-panel.react.js b/native/account/siwe-panel.react.js
index a80b6af67..bbd4cc173 100644
--- a/native/account/siwe-panel.react.js
+++ b/native/account/siwe-panel.react.js
@@ -1,228 +1,228 @@
 // @flow
 
 import BottomSheet from '@gorhom/bottom-sheet';
 import * as React from 'react';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import WebView from 'react-native-webview';
 
 import {
   getSIWENonce,
   getSIWENonceActionTypes,
   siweAuthActionTypes,
 } from 'lib/actions/siwe-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { SIWEWebViewMessage, SIWEResult } from 'lib/types/siwe-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
   type BindServerCallsParams,
 } from 'lib/utils/action-utils.js';
 
 import { useKeyboardHeight } from '../keyboard/keyboard-hooks.js';
 import { useSelector } from '../redux/redux-utils.js';
 import type { BottomSheetRef } from '../types/bottom-sheet.js';
 import Alert from '../utils/alert.js';
 import { getContentSigningKey } from '../utils/crypto-utils.js';
 import { defaultLandingURLPrefix } from '../utils/url-utils.js';
 
 const commSIWE = `${defaultLandingURLPrefix}/siwe`;
 
 const getSIWENonceLoadingStatusSelector = createLoadingStatusSelector(
   getSIWENonceActionTypes,
 );
 const siweAuthLoadingStatusSelector =
   createLoadingStatusSelector(siweAuthActionTypes);
 
 type WebViewMessageEvent = {
   +nativeEvent: {
     +data: string,
     ...
   },
   ...
 };
 
 type Props = {
   +onClosed: () => mixed,
   +onClosing: () => mixed,
   +onSuccessfulWalletSignature: SIWEResult => mixed,
   +closing: boolean,
   +setLoading: boolean => mixed,
   +keyserverCallParamOverride?: Partial<BindServerCallsParams>,
 };
 function SIWEPanel(props: Props): React.Node {
   const dispatchActionPromise = useDispatchActionPromise();
   const getSIWENonceCall = useServerCall(
     getSIWENonce,
     props.keyserverCallParamOverride,
   );
 
   const getSIWENonceCallFailed = useSelector(
     state => getSIWENonceLoadingStatusSelector(state) === 'error',
   );
 
   const { onClosing } = props;
   React.useEffect(() => {
     if (getSIWENonceCallFailed) {
       Alert.alert(
         'Unknown error',
         'Uhh... try again?',
         [{ text: 'OK', onPress: onClosing }],
         { cancelable: false },
       );
     }
   }, [getSIWENonceCallFailed, onClosing]);
 
   const siweAuthCallLoading = useSelector(
     state => siweAuthLoadingStatusSelector(state) === 'loading',
   );
 
   const [nonce, setNonce] = React.useState<?string>(null);
   const [primaryIdentityPublicKey, setPrimaryIdentityPublicKey] =
     React.useState<?string>(null);
 
   React.useEffect(() => {
-    (async () => {
-      dispatchActionPromise(
+    void (async () => {
+      void dispatchActionPromise(
         getSIWENonceActionTypes,
         (async () => {
           const response = await getSIWENonceCall();
           setNonce(response);
         })(),
       );
       const ed25519 = await getContentSigningKey();
       setPrimaryIdentityPublicKey(ed25519);
     })();
   }, [dispatchActionPromise, getSIWENonceCall]);
 
   const [isLoading, setLoading] = React.useState(true);
   const [walletConnectModalHeight, setWalletConnectModalHeight] =
     React.useState(0);
   const insets = useSafeAreaInsets();
   const keyboardHeight = useKeyboardHeight();
   const bottomInset = insets.bottom;
   const snapPoints = React.useMemo(() => {
     if (isLoading) {
       return [1];
     } else if (walletConnectModalHeight) {
       const baseHeight =
         bottomInset + walletConnectModalHeight + keyboardHeight;
       if (baseHeight < 400) {
         return [baseHeight - 10];
       } else {
         return [baseHeight + 5];
       }
     } else {
       const baseHeight = bottomInset + keyboardHeight;
       return [baseHeight + 435, baseHeight + 600];
     }
   }, [isLoading, walletConnectModalHeight, bottomInset, keyboardHeight]);
 
   const bottomSheetRef = React.useRef<?BottomSheetRef>();
   const snapToIndex = bottomSheetRef.current?.snapToIndex;
   React.useEffect(() => {
     // When the snapPoints change, always reset to the first one
     // Without this, when we close the WalletConnect modal we don't resize
     snapToIndex?.(0);
   }, [snapToIndex, snapPoints]);
 
   const closeBottomSheet = bottomSheetRef.current?.close;
   const { closing, onSuccessfulWalletSignature } = props;
   const handleMessage = React.useCallback(
     async (event: WebViewMessageEvent) => {
       const data: SIWEWebViewMessage = JSON.parse(event.nativeEvent.data);
       if (data.type === 'siwe_success') {
         const { address, message, signature } = data;
         if (address && signature) {
           closeBottomSheet?.();
           await onSuccessfulWalletSignature({ address, message, signature });
         }
       } else if (data.type === 'siwe_closed') {
         onClosing();
         closeBottomSheet?.();
       } else if (data.type === 'walletconnect_modal_update') {
         const height = data.state === 'open' ? data.height : 0;
         setWalletConnectModalHeight(height);
       }
     },
     [onSuccessfulWalletSignature, onClosing, closeBottomSheet],
   );
   const prevClosingRef = React.useRef<?boolean>();
   React.useEffect(() => {
     if (closing && !prevClosingRef.current) {
       closeBottomSheet?.();
     }
     prevClosingRef.current = closing;
   }, [closing, closeBottomSheet]);
 
   const source = React.useMemo(
     () => ({
       uri: commSIWE,
       headers: {
         'siwe-nonce': nonce,
         'siwe-primary-identity-public-key': primaryIdentityPublicKey,
       },
     }),
     [nonce, primaryIdentityPublicKey],
   );
 
   const onWebViewLoaded = React.useCallback(() => {
     setLoading(false);
   }, []);
 
   const walletConnectModalOpen = walletConnectModalHeight !== 0;
   const backgroundStyle = React.useMemo(
     () => ({
       backgroundColor: walletConnectModalOpen ? '#3396ff' : '#242529',
     }),
     [walletConnectModalOpen],
   );
 
   const bottomSheetHandleIndicatorStyle = React.useMemo(
     () => ({
       backgroundColor: 'white',
     }),
     [],
   );
 
   const { onClosed } = props;
   const onBottomSheetChange = React.useCallback(
     (index: number) => {
       if (index === -1) {
         onClosed();
       }
     },
     [onClosed],
   );
 
   let bottomSheet;
   if (nonce && primaryIdentityPublicKey) {
     bottomSheet = (
       <BottomSheet
         snapPoints={snapPoints}
         backgroundStyle={backgroundStyle}
         handleIndicatorStyle={bottomSheetHandleIndicatorStyle}
         enablePanDownToClose={true}
         onChange={onBottomSheetChange}
         ref={bottomSheetRef}
       >
         <WebView
           source={source}
           onMessage={handleMessage}
           onLoad={onWebViewLoaded}
           style={backgroundStyle}
           incognito={true}
         />
       </BottomSheet>
     );
   }
 
   const setLoadingProp = props.setLoading;
   const loading = !getSIWENonceCallFailed && (isLoading || siweAuthCallLoading);
   React.useEffect(() => {
     setLoadingProp(loading);
   }, [setLoadingProp, loading]);
 
   return bottomSheet;
 }
 
 export default SIWEPanel;
diff --git a/native/account/terms-and-privacy-modal.react.js b/native/account/terms-and-privacy-modal.react.js
index fa970c243..27d153dab 100644
--- a/native/account/terms-and-privacy-modal.react.js
+++ b/native/account/terms-and-privacy-modal.react.js
@@ -1,190 +1,190 @@
 // @flow
 
 import { useIsFocused } from '@react-navigation/native';
 import * as React from 'react';
 import {
   ActivityIndicator,
   BackHandler,
   Linking,
   Platform,
   Text,
   View,
 } from 'react-native';
 
 import {
   policyAcknowledgment,
   policyAcknowledgmentActionTypes,
 } from 'lib/actions/user-actions.js';
 import { type PolicyType, policyTypes } from 'lib/facts/policies.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 import { acknowledgePolicy } from 'lib/utils/policy-acknowledge-utlis.js';
 
 import Button from '../components/button.react.js';
 import Modal from '../components/modal.react.js';
 import type { RootNavigationProp } from '../navigation/root-navigator.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 
 export type TermsAndPrivacyModalParams = {
   +policyType: PolicyType,
 };
 
 type Props = {
   +navigation: RootNavigationProp<'TermsAndPrivacyModal'>,
   +route: NavigationRoute<'TermsAndPrivacyModal'>,
 };
 
 const loadingStatusSelector = createLoadingStatusSelector(
   policyAcknowledgmentActionTypes,
 );
 
 function TermsAndPrivacyModal(props: Props): React.Node {
   const loadingStatus = useSelector(loadingStatusSelector);
   const [acknowledgmentError, setAcknowledgmentError] = React.useState('');
   const sendAcknowledgmentRequest = useServerCall(policyAcknowledgment);
   const dispatchActionPromise = useDispatchActionPromise();
 
   const policyType = props.route.params.policyType;
   const policyState = useSelector(store => store.userPolicies[policyType]);
   const isAcknowledged = policyState?.isAcknowledged;
   const isFocused = useIsFocused();
 
   React.useEffect(() => {
     if (isAcknowledged && isFocused) {
       props.navigation.goBack();
     }
   }, [isAcknowledged, props.navigation, isFocused]);
 
   const onAccept = React.useCallback(() => {
     acknowledgePolicy(
       policyTypes.tosAndPrivacyPolicy,
       dispatchActionPromise,
       sendAcknowledgmentRequest,
       setAcknowledgmentError,
     );
   }, [dispatchActionPromise, sendAcknowledgmentRequest]);
 
   const styles = useStyles(unboundStyles);
 
   const buttonContent = React.useMemo(() => {
     if (loadingStatus === 'loading') {
       return (
         <View style={styles.loading}>
           <ActivityIndicator size="small" color="#D3D3D3" />
         </View>
       );
     }
     return <Text style={styles.buttonText}>I accept</Text>;
   }, [loadingStatus, styles.buttonText, styles.loading]);
 
   const onBackPress = props.navigation.isFocused;
   React.useEffect(() => {
     BackHandler.addEventListener('hardwareBackPress', onBackPress);
     return () => {
       BackHandler.removeEventListener('hardwareBackPress', onBackPress);
     };
   }, [onBackPress]);
 
   const safeAreaEdges = ['top', 'bottom'];
   return (
     <Modal
       disableClosing={true}
       modalStyle={styles.modal}
       safeAreaEdges={safeAreaEdges}
     >
       <Text style={styles.header}>Terms of Service and Privacy Policy</Text>
       <Text style={styles.label}>
         <Text>We recently updated our&nbsp;</Text>
         <Text style={styles.link} onPress={onTermsOfUsePressed}>
           Terms of Service
         </Text>
         <Text>&nbsp;&amp;&nbsp;</Text>
         <Text style={styles.link} onPress={onPrivacyPolicyPressed}>
           Privacy Policy
         </Text>
         <Text>
           . In order to continue using Comm, we&rsquo;re asking you to read
           through, acknowledge, and accept the updated policies.
         </Text>
       </Text>
 
       <View style={styles.buttonsContainer}>
         <Button style={styles.button} onPress={onAccept}>
           <Text style={styles.buttonText}>{buttonContent}</Text>
         </Button>
         <Text style={styles.error}>{acknowledgmentError}</Text>
       </View>
     </Modal>
   );
 }
 
 const unboundStyles = {
   modal: {
     backgroundColor: 'modalForeground',
     paddingBottom: 10,
     paddingTop: 32,
     paddingHorizontal: 32,
     flex: 0,
     borderColor: 'modalForegroundBorder',
   },
   header: {
     color: 'modalForegroundLabel',
     fontSize: 20,
     fontWeight: '600',
     textAlign: 'center',
     paddingBottom: 16,
   },
   label: {
     color: 'modalForegroundSecondaryLabel',
     fontSize: 16,
     lineHeight: 20,
     textAlign: 'center',
   },
   link: {
     color: 'purpleLink',
     fontWeight: 'bold',
   },
   buttonsContainer: {
     flexDirection: 'column',
     marginTop: 24,
     height: 72,
     paddingHorizontal: 16,
   },
   button: {
     borderRadius: 5,
     height: 48,
     justifyContent: 'center',
     alignItems: 'center',
     backgroundColor: 'purpleButton',
   },
   buttonText: {
     color: 'white',
     fontSize: 16,
     fontWeight: '600',
     textAlign: 'center',
   },
   error: {
     marginTop: 6,
     fontStyle: 'italic',
     color: 'redText',
     textAlign: 'center',
   },
   loading: {
     paddingTop: Platform.OS === 'android' ? 0 : 6,
   },
 };
 
 const onTermsOfUsePressed = () => {
-  Linking.openURL('https://comm.app/terms');
+  void Linking.openURL('https://comm.app/terms');
 };
 
 const onPrivacyPolicyPressed = () => {
-  Linking.openURL('https://comm.app/privacy');
+  void Linking.openURL('https://comm.app/privacy');
 };
 
 export default TermsAndPrivacyModal;
diff --git a/native/android/upload-aab.js b/native/android/upload-aab.js
index d0729907c..1ced3f998 100644
--- a/native/android/upload-aab.js
+++ b/native/android/upload-aab.js
@@ -1,45 +1,45 @@
 // @flow
 
 const { createReadStream } = require('fs');
 const { google } = require('googleapis');
 
 async function main() {
   try {
     const auth = new google.auth.GoogleAuth({
       keyFile: './PLAY_STORE_PUBLISHING_KEY.json',
       scopes: ['https://www.googleapis.com/auth/androidpublisher'],
     });
 
     const androidPublisher = google.androidpublisher({
       version: 'v3',
       auth: auth,
     });
     
     const aab = createReadStream(
       'app/build/outputs/bundle/release/app-release.aab',
     );
 
     const insertResp = await androidPublisher.edits.insert({
       packageName: 'app.comm.android',
     });
 
     await androidPublisher.edits.bundles.upload({
       editId: insertResp.data.id,
       packageName: 'app.comm.android',
       media: {
         mimeType: 'application/octet-stream',
         body: aab,
       },
     });
 
     await androidPublisher.edits.commit({
       packageName: 'app.comm.android',
       editId: insertResp.data.id,
     });
 
   } catch (error) {
     console.warn(error);
   }
 }
 
-main();
+void main();
diff --git a/native/backup/backup-handler.js b/native/backup/backup-handler.js
index f45bac099..eeed4e9fe 100644
--- a/native/backup/backup-handler.js
+++ b/native/backup/backup-handler.js
@@ -1,85 +1,85 @@
 // @flow
 
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import * as React from 'react';
 
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { accountHasPassword } from 'lib/shared/account-utils.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 
 import { BACKUP_HASH_STORAGE_KEY } from './constants.js';
 import { convertObjToBytes } from './conversion-utils.js';
 import { useClientBackup } from './use-client-backup.js';
 import { commUtilsModule } from '../native-modules.js';
 import { useSelector } from '../redux/redux-utils.js';
 import Alert from '../utils/alert.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 function BackupHandler(): null {
   const userStore = useSelector(state => state.userStore);
   const currentUserID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const isBackupEnabled = useSelector(
     state => state.localSettings.isBackupEnabled,
   );
   const loggedIn = useSelector(isLoggedIn);
   const staffCanSee = useStaffCanSee();
   const isAccountWithPassword = useSelector(state =>
     accountHasPassword(state.currentUserInfo),
   );
 
   const { uploadBackupProtocol } = useClientBackup();
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       if (
         !isBackupEnabled ||
         !loggedIn ||
         !staffCanSee ||
         !isAccountWithPassword
       ) {
         return;
       }
 
       const userData = { userStore };
       const userDataBytes = convertObjToBytes(userData);
       const currentBackupHash = commUtilsModule.sha256(userDataBytes.buffer);
 
       const mostRecentlyUploadedBackupHash = await AsyncStorage.getItem(
         BACKUP_HASH_STORAGE_KEY,
       );
 
       if (
         !mostRecentlyUploadedBackupHash ||
         currentBackupHash !== mostRecentlyUploadedBackupHash
       ) {
         try {
           await uploadBackupProtocol(userData);
           await AsyncStorage.setItem(
             BACKUP_HASH_STORAGE_KEY,
             currentBackupHash,
           );
         } catch (e) {
           console.error(`Backup uploading error: ${e}`);
           Alert.alert(
             'Backup protocol info',
             `Backup uploading error: ${String(getMessageForException(e))}`,
           );
         }
       }
     })();
   }, [
     currentUserID,
     isBackupEnabled,
     staffCanSee,
     loggedIn,
     uploadBackupProtocol,
     userStore,
     isAccountWithPassword,
   ]);
 
   return null;
 }
 
 export default BackupHandler;
diff --git a/native/calendar/calendar.react.js b/native/calendar/calendar.react.js
index 74dd52503..474a1b32f 100644
--- a/native/calendar/calendar.react.js
+++ b/native/calendar/calendar.react.js
@@ -1,1115 +1,1115 @@
 // @flow
 
 import invariant from 'invariant';
 import _filter from 'lodash/fp/filter.js';
 import _find from 'lodash/fp/find.js';
 import _findIndex from 'lodash/fp/findIndex.js';
 import _map from 'lodash/fp/map.js';
 import _pickBy from 'lodash/fp/pickBy.js';
 import _size from 'lodash/fp/size.js';
 import _sum from 'lodash/fp/sum.js';
 import _throttle from 'lodash/throttle.js';
 import * as React from 'react';
 import {
   View,
   Text,
   FlatList,
   AppState as NativeAppState,
   Platform,
   LayoutAnimation,
   TouchableWithoutFeedback,
 } from 'react-native';
 
 import {
   updateCalendarQueryActionTypes,
   useUpdateCalendarQuery,
 } from 'lib/actions/entry-actions.js';
 import type { UpdateCalendarQueryInput } from 'lib/actions/entry-actions.js';
 import { connectionSelector } from 'lib/selectors/keyserver-selectors.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { entryKey } from 'lib/shared/entry-utils.js';
 import type {
   EntryInfo,
   CalendarQuery,
   CalendarQueryUpdateResult,
 } from 'lib/types/entry-types.js';
 import type { CalendarFilter } from 'lib/types/filter-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { ConnectionStatus } from 'lib/types/socket-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import {
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import {
   dateString,
   prettyDate,
   dateFromString,
 } from 'lib/utils/date-utils.js';
 import sleep from 'lib/utils/sleep.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import CalendarInputBar from './calendar-input-bar.react.js';
 import {
   Entry,
   InternalEntry,
   dummyNodeForEntryHeightMeasurement,
 } from './entry.react.js';
 import SectionFooter from './section-footer.react.js';
 import ContentLoading from '../components/content-loading.react.js';
 import KeyboardAvoidingView from '../components/keyboard-avoiding-view.react.js';
 import ListLoadingIndicator from '../components/list-loading-indicator.react.js';
 import NodeHeightMeasurer from '../components/node-height-measurer.react.js';
 import {
   addKeyboardShowListener,
   addKeyboardDismissListener,
   removeKeyboardListener,
 } from '../keyboard/keyboard.js';
 import DisconnectedBar from '../navigation/disconnected-bar.react.js';
 import {
   createIsForegroundSelector,
   createActiveTabSelector,
 } from '../navigation/nav-selectors.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import {
   CalendarRouteName,
   ThreadPickerModalRouteName,
 } from '../navigation/route-names.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import type { TabNavigationProp } from '../navigation/tab-navigator.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { calendarListData } from '../selectors/calendar-selectors.js';
 import type {
   CalendarItem,
   SectionHeaderItem,
   SectionFooterItem,
   LoaderItem,
 } from '../selectors/calendar-selectors.js';
 import {
   type DerivedDimensionsInfo,
   derivedDimensionsInfoSelector,
 } from '../selectors/dimensions-selectors.js';
 import {
   useColors,
   useStyles,
   useIndicatorStyle,
   type Colors,
   type IndicatorStyle,
 } from '../themes/colors.js';
 import type {
   EventSubscription,
   ScrollEvent,
   ViewableItemsChange,
   KeyboardEvent,
 } from '../types/react-native.js';
 
 export type EntryInfoWithHeight = {
   ...EntryInfo,
   +textHeight: number,
 };
 type CalendarItemWithHeight =
   | LoaderItem
   | SectionHeaderItem
   | SectionFooterItem
   | {
       itemType: 'entryInfo',
       entryInfo: EntryInfoWithHeight,
       threadInfo: ThreadInfo,
     };
 type ExtraData = {
   +activeEntries: { +[key: string]: boolean },
   +visibleEntries: { +[key: string]: boolean },
 };
 
 const unboundStyles = {
   container: {
     backgroundColor: 'listBackground',
     flex: 1,
   },
   flatList: {
     backgroundColor: 'listBackground',
     flex: 1,
   },
   keyboardAvoidingViewContainer: {
     position: 'absolute',
     top: 0,
     bottom: 0,
     left: 0,
     right: 0,
   },
   keyboardAvoidingView: {
     position: 'absolute',
     left: 0,
     right: 0,
     bottom: 0,
   },
   sectionHeader: {
     backgroundColor: 'panelSecondaryForeground',
     borderBottomWidth: 2,
     borderColor: 'listBackground',
     height: 31,
   },
   sectionHeaderText: {
     color: 'listSeparatorLabel',
     fontWeight: 'bold',
     padding: 5,
   },
   weekendSectionHeader: {},
 };
 
 type BaseProps = {
   +navigation: TabNavigationProp<'Calendar'>,
   +route: NavigationRoute<'Calendar'>,
 };
 type Props = {
   ...BaseProps,
   // Nav state
   +calendarActive: boolean,
   // Redux state
   +listData: ?$ReadOnlyArray<CalendarItem>,
   +startDate: string,
   +endDate: string,
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +dimensions: DerivedDimensionsInfo,
   +loadingStatus: LoadingStatus,
   +connectionStatus: ConnectionStatus,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   +indicatorStyle: IndicatorStyle,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +updateCalendarQuery: (
     input: UpdateCalendarQueryInput,
   ) => Promise<CalendarQueryUpdateResult>,
 };
 type State = {
   +listDataWithHeights: ?$ReadOnlyArray<CalendarItemWithHeight>,
   +readyToShowList: boolean,
   +extraData: ExtraData,
   +currentlyEditing: $ReadOnlyArray<string>,
 };
 class Calendar extends React.PureComponent<Props, State> {
   flatList: ?FlatList<CalendarItemWithHeight> = null;
   currentState: ?string = NativeAppState.currentState;
   appStateListener: ?EventSubscription;
   lastForegrounded = 0;
   lastCalendarReset = 0;
   currentScrollPosition: ?number = null;
   // We don't always want an extraData update to trigger a state update, so we
   // cache the most recent value as a member here
   latestExtraData: ExtraData;
   // For some reason, we have to delay the scrollToToday call after the first
   // scroll upwards
   firstScrollComplete = false;
   // When an entry becomes active, we make a note of its key so that once the
   // keyboard event happens, we know where to move the scrollPos to
   lastEntryKeyActive: ?string = null;
   keyboardShowListener: ?EventSubscription;
   keyboardDismissListener: ?EventSubscription;
   keyboardShownHeight: ?number = null;
   // If the query fails, we try it again
   topLoadingFromScroll: ?CalendarQuery = null;
   bottomLoadingFromScroll: ?CalendarQuery = null;
   // We wait until the loaders leave view before letting them be triggered again
   topLoaderWaitingToLeaveView = true;
   bottomLoaderWaitingToLeaveView = true;
   // We keep refs to the entries so CalendarInputBar can save them
   entryRefs: Map<string, ?InternalEntry> = new Map();
 
   constructor(props: Props) {
     super(props);
     this.latestExtraData = {
       activeEntries: {},
       visibleEntries: {},
     };
     this.state = {
       listDataWithHeights: null,
       readyToShowList: false,
       extraData: this.latestExtraData,
       currentlyEditing: [],
     };
   }
 
   componentDidMount() {
     this.appStateListener = NativeAppState.addEventListener(
       'change',
       this.handleAppStateChange,
     );
     this.keyboardShowListener = addKeyboardShowListener(this.keyboardShow);
     this.keyboardDismissListener = addKeyboardDismissListener(
       this.keyboardDismiss,
     );
     this.props.navigation.addListener('tabPress', this.onTabPress);
   }
 
   componentWillUnmount() {
     if (this.appStateListener) {
       this.appStateListener.remove();
       this.appStateListener = null;
     }
     if (this.keyboardShowListener) {
       removeKeyboardListener(this.keyboardShowListener);
       this.keyboardShowListener = null;
     }
     if (this.keyboardDismissListener) {
       removeKeyboardListener(this.keyboardDismissListener);
       this.keyboardDismissListener = null;
     }
     this.props.navigation.removeListener('tabPress', this.onTabPress);
   }
 
   handleAppStateChange = (nextAppState: ?string) => {
     const lastState = this.currentState;
     this.currentState = nextAppState;
     if (
       !lastState ||
       !lastState.match(/inactive|background/) ||
       this.currentState !== 'active'
     ) {
       // We're only handling foregrounding here
       return;
     }
     if (Date.now() - this.lastCalendarReset < 500) {
       // If the calendar got reset right before this callback triggered, that
       // indicates we should reset the scroll position
       this.lastCalendarReset = 0;
       this.scrollToToday(false);
     } else {
       // Otherwise, it's possible that the calendar is about to get reset. We
       // record a timestamp here so we can scrollToToday there.
       this.lastForegrounded = Date.now();
     }
   };
 
   onTabPress = () => {
     if (this.props.navigation.isFocused()) {
       this.scrollToToday();
     }
   };
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (!this.props.listData && this.props.listData !== prevProps.listData) {
       this.latestExtraData = {
         activeEntries: {},
         visibleEntries: {},
       };
       this.setState({
         listDataWithHeights: null,
         readyToShowList: false,
         extraData: this.latestExtraData,
       });
       this.firstScrollComplete = false;
       this.topLoaderWaitingToLeaveView = true;
       this.bottomLoaderWaitingToLeaveView = true;
     }
 
     const { loadingStatus, connectionStatus } = this.props;
     const {
       loadingStatus: prevLoadingStatus,
       connectionStatus: prevConnectionStatus,
     } = prevProps;
     if (
       (loadingStatus === 'error' && prevLoadingStatus === 'loading') ||
       (connectionStatus === 'connected' && prevConnectionStatus !== 'connected')
     ) {
       this.loadMoreAbove();
       this.loadMoreBelow();
     }
 
     const lastLDWH = prevState.listDataWithHeights;
     const newLDWH = this.state.listDataWithHeights;
     if (!newLDWH) {
       return;
     } else if (!lastLDWH) {
       if (!this.props.calendarActive) {
         // FlatList has an initialScrollIndex prop, which is usually close to
         // centering but can be off when there is a particularly large Entry in
         // the list. scrollToToday lets us actually center, but gets overriden
         // by initialScrollIndex if we call it right after the FlatList mounts
-        sleep(50).then(() => this.scrollToToday());
+        void sleep(50).then(() => this.scrollToToday());
       }
       return;
     }
 
     if (newLDWH.length < lastLDWH.length) {
       this.topLoaderWaitingToLeaveView = true;
       this.bottomLoaderWaitingToLeaveView = true;
       if (this.flatList) {
         if (!this.props.calendarActive) {
           // If the currentCalendarQuery gets reset we scroll to the center
           this.scrollToToday();
         } else if (Date.now() - this.lastForegrounded < 500) {
           // If the app got foregrounded right before the calendar got reset,
           // that indicates we should reset the scroll position
           this.lastForegrounded = 0;
           this.scrollToToday(false);
         } else {
           // Otherwise, it's possible that we got triggered before the
           // foreground callback. Let's record a timestamp here so we can call
           // scrollToToday there
           this.lastCalendarReset = Date.now();
         }
       }
     }
 
     const { lastStartDate, newStartDate, lastEndDate, newEndDate } =
       Calendar.datesFromListData(lastLDWH, newLDWH);
 
     if (newStartDate > lastStartDate || newEndDate < lastEndDate) {
       // If there are fewer items in our new data, which happens when the
       // current calendar query gets reset due to inactivity, let's reset the
       // scroll position to the center (today)
       if (!this.props.calendarActive) {
-        sleep(50).then(() => this.scrollToToday());
+        void sleep(50).then(() => this.scrollToToday());
       }
       this.firstScrollComplete = false;
     } else if (newStartDate < lastStartDate) {
       this.updateScrollPositionAfterPrepend(lastLDWH, newLDWH);
     } else if (newEndDate > lastEndDate) {
       this.firstScrollComplete = true;
     } else if (newLDWH.length > lastLDWH.length) {
       LayoutAnimation.easeInEaseOut();
     }
 
     if (newStartDate < lastStartDate) {
       this.topLoadingFromScroll = null;
     }
     if (newEndDate > lastEndDate) {
       this.bottomLoadingFromScroll = null;
     }
 
     const { keyboardShownHeight, lastEntryKeyActive } = this;
     if (keyboardShownHeight && lastEntryKeyActive) {
       this.scrollToKey(lastEntryKeyActive, keyboardShownHeight);
       this.lastEntryKeyActive = null;
     }
   }
 
   static datesFromListData(
     lastLDWH: $ReadOnlyArray<CalendarItemWithHeight>,
     newLDWH: $ReadOnlyArray<CalendarItemWithHeight>,
   ): {
     +lastStartDate: Date,
     +newStartDate: Date,
     +lastEndDate: Date,
     +newEndDate: Date,
   } {
     const lastSecondItem = lastLDWH[1];
     const newSecondItem = newLDWH[1];
     invariant(
       newSecondItem.itemType === 'header' &&
         lastSecondItem.itemType === 'header',
       'second item in listData should be a header',
     );
     const lastStartDate = dateFromString(lastSecondItem.dateString);
     const newStartDate = dateFromString(newSecondItem.dateString);
 
     const lastPenultimateItem = lastLDWH[lastLDWH.length - 2];
     const newPenultimateItem = newLDWH[newLDWH.length - 2];
     invariant(
       newPenultimateItem.itemType === 'footer' &&
         lastPenultimateItem.itemType === 'footer',
       'penultimate item in listData should be a footer',
     );
     const lastEndDate = dateFromString(lastPenultimateItem.dateString);
     const newEndDate = dateFromString(newPenultimateItem.dateString);
 
     return { lastStartDate, newStartDate, lastEndDate, newEndDate };
   }
 
   /**
    * When prepending list items, FlatList isn't smart about preserving scroll
    * position. If we're at the start of the list before prepending, FlatList
    * will just keep us at the front after prepending. But we want to preserve
    * the previous on-screen items, so we have to do a calculation to get the new
    * scroll position. (And deal with the inherent glitchiness of trying to time
    * that change with the items getting prepended... *sigh*.)
    */
   updateScrollPositionAfterPrepend(
     lastLDWH: $ReadOnlyArray<CalendarItemWithHeight>,
     newLDWH: $ReadOnlyArray<CalendarItemWithHeight>,
   ) {
     const existingKeys = new Set(_map(Calendar.keyExtractor)(lastLDWH));
     const newItems = _filter(
       (item: CalendarItemWithHeight) =>
         !existingKeys.has(Calendar.keyExtractor(item)),
     )(newLDWH);
     const heightOfNewItems = Calendar.heightOfItems(newItems);
     const flatList = this.flatList;
     invariant(flatList, 'flatList should be set');
     const scrollAction = () => {
       invariant(
         this.currentScrollPosition !== undefined &&
           this.currentScrollPosition !== null,
         'currentScrollPosition should be set',
       );
       const currentScrollPosition = Math.max(this.currentScrollPosition, 0);
       const offset = currentScrollPosition + heightOfNewItems;
       flatList.scrollToOffset({
         offset,
         animated: false,
       });
     };
     scrollAction();
     if (!this.firstScrollComplete) {
       setTimeout(scrollAction, 0);
       this.firstScrollComplete = true;
     }
   }
 
   scrollToToday(animated: ?boolean = undefined) {
     if (animated === undefined) {
       animated = this.props.calendarActive;
     }
     const ldwh = this.state.listDataWithHeights;
     if (!ldwh) {
       return;
     }
     const todayIndex = _findIndex(['dateString', dateString(new Date())])(ldwh);
     invariant(this.flatList, "scrollToToday called, but flatList isn't set");
     this.flatList.scrollToIndex({
       index: todayIndex,
       animated,
       viewPosition: 0.5,
     });
   }
 
   // ESLint doesn't recognize that invariant always throws
   // eslint-disable-next-line consistent-return
   renderItem = (row: { +item: CalendarItemWithHeight, ... }): React.Node => {
     const item = row.item;
     if (item.itemType === 'loader') {
       return <ListLoadingIndicator />;
     } else if (item.itemType === 'header') {
       return this.renderSectionHeader(item);
     } else if (item.itemType === 'entryInfo') {
       const key = entryKey(item.entryInfo);
       return (
         <Entry
           navigation={this.props.navigation}
           entryInfo={item.entryInfo}
           threadInfo={item.threadInfo}
           active={!!this.state.extraData.activeEntries[key]}
           visible={!!this.state.extraData.visibleEntries[key]}
           makeActive={this.makeActive}
           onEnterEditMode={this.onEnterEntryEditMode}
           onConcludeEditMode={this.onConcludeEntryEditMode}
           onPressWhitespace={this.makeAllEntriesInactive}
           entryRef={this.entryRef}
         />
       );
     } else if (item.itemType === 'footer') {
       return this.renderSectionFooter(item);
     }
     invariant(false, 'renderItem conditions should be exhaustive');
   };
 
   renderSectionHeader = (item: SectionHeaderItem): React.Node => {
     let date = prettyDate(item.dateString);
     if (dateString(new Date()) === item.dateString) {
       date += ' (today)';
     }
     const dateObj = dateFromString(item.dateString).getDay();
     const weekendStyle =
       dateObj === 0 || dateObj === 6
         ? this.props.styles.weekendSectionHeader
         : null;
     return (
       <TouchableWithoutFeedback onPress={this.makeAllEntriesInactive}>
         <View style={[this.props.styles.sectionHeader, weekendStyle]}>
           <Text style={this.props.styles.sectionHeaderText}>{date}</Text>
         </View>
       </TouchableWithoutFeedback>
     );
   };
 
   renderSectionFooter = (item: SectionFooterItem): React.Node => {
     return (
       <SectionFooter
         dateString={item.dateString}
         onAdd={this.onAdd}
         onPressWhitespace={this.makeAllEntriesInactive}
       />
     );
   };
 
   onAdd = (dayString: string) => {
     this.props.navigation.navigate(ThreadPickerModalRouteName, {
       presentedFrom: this.props.route.key,
       dateString: dayString,
     });
   };
 
   static keyExtractor = (
     item: CalendarItemWithHeight | CalendarItem,
     // ESLint doesn't recognize that invariant always throws
     // eslint-disable-next-line consistent-return
   ): string => {
     if (item.itemType === 'loader') {
       return item.key;
     } else if (item.itemType === 'header') {
       return item.dateString + '/header';
     } else if (item.itemType === 'entryInfo') {
       return entryKey(item.entryInfo);
     } else if (item.itemType === 'footer') {
       return item.dateString + '/footer';
     }
     invariant(false, 'keyExtractor conditions should be exhaustive');
   };
 
   static getItemLayout = (
     data: ?$ReadOnlyArray<CalendarItemWithHeight>,
     index: number,
   ): { length: number, offset: number, index: number } => {
     if (!data) {
       return { length: 0, offset: 0, index };
     }
     const offset = Calendar.heightOfItems(data.filter((_, i) => i < index));
     const item = data[index];
     const length = item ? Calendar.itemHeight(item) : 0;
     return { length, offset, index };
   };
 
   // ESLint doesn't recognize that invariant always throws
   // eslint-disable-next-line consistent-return
   static itemHeight = (item: CalendarItemWithHeight): number => {
     if (item.itemType === 'loader') {
       return 56;
     } else if (item.itemType === 'header') {
       return 31;
     } else if (item.itemType === 'entryInfo') {
       const verticalPadding = 10;
       return verticalPadding + item.entryInfo.textHeight;
     } else if (item.itemType === 'footer') {
       return 40;
     }
     invariant(false, 'itemHeight conditions should be exhaustive');
   };
 
   static heightOfItems = (
     data: $ReadOnlyArray<CalendarItemWithHeight>,
   ): number => {
     return _sum(data.map(Calendar.itemHeight));
   };
 
   render(): React.Node {
     const { listDataWithHeights } = this.state;
     let flatList = null;
     if (listDataWithHeights) {
       const flatListStyle = { opacity: this.state.readyToShowList ? 1 : 0 };
       const initialScrollIndex = this.initialScrollIndex(listDataWithHeights);
       flatList = (
         <FlatList
           data={listDataWithHeights}
           renderItem={this.renderItem}
           keyExtractor={Calendar.keyExtractor}
           getItemLayout={Calendar.getItemLayout}
           onViewableItemsChanged={this.onViewableItemsChanged}
           onScroll={this.onScroll}
           initialScrollIndex={initialScrollIndex}
           keyboardShouldPersistTaps="handled"
           keyboardDismissMode="on-drag"
           onMomentumScrollEnd={this.onMomentumScrollEnd}
           onScrollEndDrag={this.onScrollEndDrag}
           scrollsToTop={false}
           extraData={this.state.extraData}
           style={[this.props.styles.flatList, flatListStyle]}
           indicatorStyle={this.props.indicatorStyle}
           ref={this.flatListRef}
         />
       );
     }
     let loadingIndicator = null;
     if (!listDataWithHeights || !this.state.readyToShowList) {
       loadingIndicator = (
         <ContentLoading fillType="absolute" colors={this.props.colors} />
       );
     }
     const disableInputBar = this.state.currentlyEditing.length === 0;
     return (
       <>
         <NodeHeightMeasurer
           listData={this.props.listData}
           itemToID={Calendar.keyExtractor}
           itemToMeasureKey={this.heightMeasurerKey}
           itemToDummy={this.heightMeasurerDummy}
           mergeItemWithHeight={this.heightMeasurerMergeItem}
           allHeightsMeasured={this.allHeightsMeasured}
         />
         <View style={this.props.styles.container}>
           <DisconnectedBar visible={this.props.calendarActive} />
           {loadingIndicator}
           {flatList}
         </View>
         <KeyboardAvoidingView
           behavior="position"
           style={this.props.styles.keyboardAvoidingViewContainer}
           contentContainerStyle={this.props.styles.keyboardAvoidingView}
           pointerEvents="box-none"
         >
           <CalendarInputBar
             onSave={this.onSaveEntry}
             disabled={disableInputBar}
           />
         </KeyboardAvoidingView>
       </>
     );
   }
 
   flatListHeight(): number {
     const { safeAreaHeight, tabBarHeight } = this.props.dimensions;
     return safeAreaHeight - tabBarHeight;
   }
 
   initialScrollIndex(data: $ReadOnlyArray<CalendarItemWithHeight>): number {
     const todayIndex = _findIndex(['dateString', dateString(new Date())])(data);
     const heightOfTodayHeader = Calendar.itemHeight(data[todayIndex]);
 
     let returnIndex = todayIndex;
     let heightLeft = (this.flatListHeight() - heightOfTodayHeader) / 2;
     while (heightLeft > 0) {
       heightLeft -= Calendar.itemHeight(data[--returnIndex]);
     }
     return returnIndex;
   }
 
   flatListRef = (flatList: ?FlatList<CalendarItemWithHeight>) => {
     this.flatList = flatList;
   };
 
   entryRef = (inEntryKey: string, entry: ?InternalEntry) => {
     this.entryRefs.set(inEntryKey, entry);
   };
 
   makeAllEntriesInactive = () => {
     if (_size(this.state.extraData.activeEntries) === 0) {
       if (_size(this.latestExtraData.activeEntries) !== 0) {
         this.latestExtraData = {
           visibleEntries: this.latestExtraData.visibleEntries,
           activeEntries: this.state.extraData.activeEntries,
         };
       }
       return;
     }
     this.latestExtraData = {
       visibleEntries: this.latestExtraData.visibleEntries,
       activeEntries: {},
     };
     this.setState({ extraData: this.latestExtraData });
   };
 
   makeActive = (key: string, active: boolean) => {
     if (!active) {
       const activeKeys = Object.keys(this.latestExtraData.activeEntries);
       if (activeKeys.length === 0) {
         if (Object.keys(this.state.extraData.activeEntries).length !== 0) {
           this.setState({ extraData: this.latestExtraData });
         }
         return;
       }
       const activeKey = activeKeys[0];
       if (activeKey === key) {
         this.latestExtraData = {
           visibleEntries: this.latestExtraData.visibleEntries,
           activeEntries: {},
         };
         this.setState({ extraData: this.latestExtraData });
       }
       return;
     }
 
     if (
       _size(this.state.extraData.activeEntries) === 1 &&
       this.state.extraData.activeEntries[key]
     ) {
       if (
         _size(this.latestExtraData.activeEntries) !== 1 ||
         !this.latestExtraData.activeEntries[key]
       ) {
         this.latestExtraData = {
           visibleEntries: this.latestExtraData.visibleEntries,
           activeEntries: this.state.extraData.activeEntries,
         };
       }
       return;
     }
     this.latestExtraData = {
       visibleEntries: this.latestExtraData.visibleEntries,
       activeEntries: { [key]: true },
     };
     this.setState({ extraData: this.latestExtraData });
   };
 
   onEnterEntryEditMode = (entryInfo: EntryInfoWithHeight) => {
     const key = entryKey(entryInfo);
     const keyboardShownHeight = this.keyboardShownHeight;
     if (keyboardShownHeight && this.state.listDataWithHeights) {
       this.scrollToKey(key, keyboardShownHeight);
     } else {
       this.lastEntryKeyActive = key;
     }
     const newCurrentlyEditing = [
       ...new Set([...this.state.currentlyEditing, key]),
     ];
     if (newCurrentlyEditing.length > this.state.currentlyEditing.length) {
       this.setState({ currentlyEditing: newCurrentlyEditing });
     }
   };
 
   onConcludeEntryEditMode = (entryInfo: EntryInfoWithHeight) => {
     const key = entryKey(entryInfo);
     const newCurrentlyEditing = this.state.currentlyEditing.filter(
       k => k !== key,
     );
     if (newCurrentlyEditing.length < this.state.currentlyEditing.length) {
       this.setState({ currentlyEditing: newCurrentlyEditing });
     }
   };
 
   keyboardShow = (event: KeyboardEvent) => {
     // flatListHeight() factors in the size of the tab bar,
     // but it is hidden by the keyboard since it is at the bottom
     const { bottomInset, tabBarHeight } = this.props.dimensions;
     const inputBarHeight = Platform.OS === 'android' ? 37.7 : 35.5;
     const keyboardHeight: number = Platform.select({
       // Android doesn't include the bottomInset in this height measurement
       android: event.endCoordinates.height,
       default: Math.max(event.endCoordinates.height - bottomInset, 0),
     });
     const keyboardShownHeight =
       inputBarHeight + Math.max(keyboardHeight - tabBarHeight, 0);
     this.keyboardShownHeight = keyboardShownHeight;
 
     const lastEntryKeyActive = this.lastEntryKeyActive;
     if (lastEntryKeyActive && this.state.listDataWithHeights) {
       this.scrollToKey(lastEntryKeyActive, keyboardShownHeight);
       this.lastEntryKeyActive = null;
     }
   };
 
   keyboardDismiss = () => {
     this.keyboardShownHeight = null;
   };
 
   scrollToKey(lastEntryKeyActive: string, keyboardHeight: number) {
     const data = this.state.listDataWithHeights;
     invariant(data, 'should be set');
     const index = data.findIndex(
       (item: CalendarItemWithHeight) =>
         Calendar.keyExtractor(item) === lastEntryKeyActive,
     );
     if (index === -1) {
       return;
     }
     const itemStart = Calendar.heightOfItems(data.filter((_, i) => i < index));
     const itemHeight = Calendar.itemHeight(data[index]);
     const entryAdditionalActiveHeight = Platform.OS === 'android' ? 21 : 20;
     const itemEnd = itemStart + itemHeight + entryAdditionalActiveHeight;
     const visibleHeight = this.flatListHeight() - keyboardHeight;
     if (
       this.currentScrollPosition !== undefined &&
       this.currentScrollPosition !== null &&
       itemStart > this.currentScrollPosition &&
       itemEnd < this.currentScrollPosition + visibleHeight
     ) {
       return;
     }
     const offset = itemStart - (visibleHeight - itemHeight) / 2;
     invariant(this.flatList, 'flatList should be set');
     this.flatList.scrollToOffset({ offset, animated: true });
   }
 
   heightMeasurerKey = (item: CalendarItem): ?string => {
     if (item.itemType !== 'entryInfo') {
       return null;
     }
     return item.entryInfo.text;
   };
 
   heightMeasurerDummy = (item: CalendarItem): React.MixedElement => {
     invariant(
       item.itemType === 'entryInfo',
       'NodeHeightMeasurer asked for dummy for non-entryInfo item',
     );
     return dummyNodeForEntryHeightMeasurement(item.entryInfo.text);
   };
 
   heightMeasurerMergeItem = (
     item: CalendarItem,
     height: ?number,
   ): CalendarItemWithHeight => {
     if (item.itemType !== 'entryInfo') {
       return item;
     }
     invariant(height !== null && height !== undefined, 'height should be set');
     const { entryInfo } = item;
     return {
       itemType: 'entryInfo',
       entryInfo: Calendar.entryInfoWithHeight(entryInfo, height),
       threadInfo: item.threadInfo,
     };
   };
 
   static entryInfoWithHeight(
     entryInfo: EntryInfo,
     textHeight: number,
   ): EntryInfoWithHeight {
     // Blame Flow for not accepting object spread on exact types
     if (entryInfo.id && entryInfo.localID) {
       return {
         id: entryInfo.id,
         localID: entryInfo.localID,
         threadID: entryInfo.threadID,
         text: entryInfo.text,
         year: entryInfo.year,
         month: entryInfo.month,
         day: entryInfo.day,
         creationTime: entryInfo.creationTime,
         creator: entryInfo.creator,
         deleted: entryInfo.deleted,
         textHeight: Math.ceil(textHeight),
       };
     } else if (entryInfo.id) {
       return {
         id: entryInfo.id,
         threadID: entryInfo.threadID,
         text: entryInfo.text,
         year: entryInfo.year,
         month: entryInfo.month,
         day: entryInfo.day,
         creationTime: entryInfo.creationTime,
         creator: entryInfo.creator,
         deleted: entryInfo.deleted,
         textHeight: Math.ceil(textHeight),
       };
     } else {
       return {
         localID: entryInfo.localID,
         threadID: entryInfo.threadID,
         text: entryInfo.text,
         year: entryInfo.year,
         month: entryInfo.month,
         day: entryInfo.day,
         creationTime: entryInfo.creationTime,
         creator: entryInfo.creator,
         deleted: entryInfo.deleted,
         textHeight: Math.ceil(textHeight),
       };
     }
   }
 
   allHeightsMeasured = (
     listDataWithHeights: $ReadOnlyArray<CalendarItemWithHeight>,
   ) => {
     this.setState({ listDataWithHeights });
   };
 
   onViewableItemsChanged = (info: ViewableItemsChange) => {
     const ldwh = this.state.listDataWithHeights;
     if (!ldwh) {
       // This indicates the listData was cleared (set to null) right before this
       // callback was called. Since this leads to the FlatList getting cleared,
       // we'll just ignore this callback.
       return;
     }
 
     const visibleEntries: { [string]: boolean } = {};
     for (const token of info.viewableItems) {
       if (token.item.itemType === 'entryInfo') {
         visibleEntries[entryKey(token.item.entryInfo)] = true;
       }
     }
     this.latestExtraData = {
       activeEntries: _pickBy((_, key: string) => {
         if (visibleEntries[key]) {
           return true;
         }
         // We don't automatically set scrolled-away entries to be inactive
         // because entries can be out-of-view at creation time if they need to
         // be scrolled into view (see onEnterEntryEditMode). If Entry could
         // distinguish the reasons its active prop gets set to false, it could
         // differentiate the out-of-view case from the something-pressed case,
         // and then we could set scrolled-away entries to be inactive without
         // worrying about this edge case. Until then...
         const foundItem = _find(
           item => item.entryInfo && entryKey(item.entryInfo) === key,
         )(ldwh);
         return !!foundItem;
       })(this.latestExtraData.activeEntries),
       visibleEntries,
     };
 
     const topLoader = _find({ key: 'TopLoader' })(info.viewableItems);
     if (this.topLoaderWaitingToLeaveView && !topLoader) {
       this.topLoaderWaitingToLeaveView = false;
       this.topLoadingFromScroll = null;
     }
 
     const bottomLoader = _find({ key: 'BottomLoader' })(info.viewableItems);
     if (this.bottomLoaderWaitingToLeaveView && !bottomLoader) {
       this.bottomLoaderWaitingToLeaveView = false;
       this.bottomLoadingFromScroll = null;
     }
 
     if (
       !this.state.readyToShowList &&
       !this.topLoaderWaitingToLeaveView &&
       !this.bottomLoaderWaitingToLeaveView &&
       info.viewableItems.length > 0
     ) {
       this.setState({
         readyToShowList: true,
         extraData: this.latestExtraData,
       });
     }
 
     if (
       topLoader &&
       !this.topLoaderWaitingToLeaveView &&
       !this.topLoadingFromScroll
     ) {
       this.topLoaderWaitingToLeaveView = true;
       const start = dateFromString(this.props.startDate);
       start.setDate(start.getDate() - 31);
       const startDate = dateString(start);
       const endDate = this.props.endDate;
       this.topLoadingFromScroll = {
         startDate,
         endDate,
         filters: this.props.calendarFilters,
       };
       this.loadMoreAbove();
     } else if (
       bottomLoader &&
       !this.bottomLoaderWaitingToLeaveView &&
       !this.bottomLoadingFromScroll
     ) {
       this.bottomLoaderWaitingToLeaveView = true;
       const end = dateFromString(this.props.endDate);
       end.setDate(end.getDate() + 31);
       const endDate = dateString(end);
       const startDate = this.props.startDate;
       this.bottomLoadingFromScroll = {
         startDate,
         endDate,
         filters: this.props.calendarFilters,
       };
       this.loadMoreBelow();
     }
   };
 
   dispatchCalendarQueryUpdate(calendarQuery: CalendarQuery) {
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       updateCalendarQueryActionTypes,
       this.props.updateCalendarQuery({ calendarQuery }),
     );
   }
 
   loadMoreAbove: () => void = _throttle(() => {
     if (
       this.topLoadingFromScroll &&
       this.topLoaderWaitingToLeaveView &&
       this.props.connectionStatus === 'connected'
     ) {
       this.dispatchCalendarQueryUpdate(this.topLoadingFromScroll);
     }
   }, 1000);
 
   loadMoreBelow: () => void = _throttle(() => {
     if (
       this.bottomLoadingFromScroll &&
       this.bottomLoaderWaitingToLeaveView &&
       this.props.connectionStatus === 'connected'
     ) {
       this.dispatchCalendarQueryUpdate(this.bottomLoadingFromScroll);
     }
   }, 1000);
 
   onScroll = (event: ScrollEvent) => {
     this.currentScrollPosition = event.nativeEvent.contentOffset.y;
   };
 
   // When the user "flicks" the scroll view, this callback gets triggered after
   // the scrolling ends
   onMomentumScrollEnd = () => {
     this.setState({ extraData: this.latestExtraData });
   };
 
   // This callback gets triggered when the user lets go of scrolling the scroll
   // view, regardless of whether it was a "flick" or a pan
   onScrollEndDrag = () => {
     // We need to figure out if this was a flick or not. If it's a flick, we'll
     // let onMomentumScrollEnd handle it once scroll position stabilizes
     const currentScrollPosition = this.currentScrollPosition;
     setTimeout(() => {
       if (this.currentScrollPosition === currentScrollPosition) {
         this.setState({ extraData: this.latestExtraData });
       }
     }, 50);
   };
 
   onSaveEntry = () => {
     const entryKeys = Object.keys(this.latestExtraData.activeEntries);
     if (entryKeys.length === 0) {
       return;
     }
     const entryRef = this.entryRefs.get(entryKeys[0]);
     if (entryRef) {
       entryRef.completeEdit();
     }
   };
 }
 
 const loadingStatusSelector = createLoadingStatusSelector(
   updateCalendarQueryActionTypes,
 );
 const activeTabSelector = createActiveTabSelector(CalendarRouteName);
 const activeThreadPickerSelector = createIsForegroundSelector(
   ThreadPickerModalRouteName,
 );
 
 const ConnectedCalendar: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedCalendar(props: BaseProps) {
     const navContext = React.useContext(NavContext);
     const calendarActive =
       activeTabSelector(navContext) || activeThreadPickerSelector(navContext);
 
     const listData = useSelector(calendarListData);
     const startDate = useSelector(state => state.navInfo.startDate);
     const endDate = useSelector(state => state.navInfo.endDate);
     const calendarFilters = useSelector(state => state.calendarFilters);
     const dimensions = useSelector(derivedDimensionsInfoSelector);
     const loadingStatus = useSelector(loadingStatusSelector);
     const connection = useSelector(connectionSelector(ashoatKeyserverID));
     invariant(connection, 'keyserver missing from keyserverStore');
     const connectionStatus = connection.status;
     const colors = useColors();
     const styles = useStyles(unboundStyles);
     const indicatorStyle = useIndicatorStyle();
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callUpdateCalendarQuery = useUpdateCalendarQuery();
 
     return (
       <Calendar
         {...props}
         calendarActive={calendarActive}
         listData={listData}
         startDate={startDate}
         endDate={endDate}
         calendarFilters={calendarFilters}
         dimensions={dimensions}
         loadingStatus={loadingStatus}
         connectionStatus={connectionStatus}
         colors={colors}
         styles={styles}
         indicatorStyle={indicatorStyle}
         dispatchActionPromise={dispatchActionPromise}
         updateCalendarQuery={callUpdateCalendarQuery}
       />
     );
   },
 );
 
 export default ConnectedCalendar;
diff --git a/native/calendar/entry.react.js b/native/calendar/entry.react.js
index 7c9d58ebe..237d4f7be 100644
--- a/native/calendar/entry.react.js
+++ b/native/calendar/entry.react.js
@@ -1,818 +1,818 @@
 // @flow
 
 import Icon from '@expo/vector-icons/FontAwesome.js';
 import invariant from 'invariant';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _omit from 'lodash/fp/omit.js';
 import * as React from 'react';
 import {
   View,
   Text,
   TextInput as BaseTextInput,
   Platform,
   TouchableWithoutFeedback,
   LayoutAnimation,
   Keyboard,
 } from 'react-native';
 import shallowequal from 'shallowequal';
 import tinycolor from 'tinycolor2';
 
 import {
   createEntryActionTypes,
   useCreateEntry,
   saveEntryActionTypes,
   useSaveEntry,
   deleteEntryActionTypes,
   useDeleteEntry,
   concurrentModificationResetActionType,
 } from 'lib/actions/entry-actions.js';
 import { registerFetchKey } from 'lib/reducers/loading-reducer.js';
 import { connectionSelector } from 'lib/selectors/keyserver-selectors.js';
 import { colorIsDark } from 'lib/shared/color-utils.js';
 import { entryKey } from 'lib/shared/entry-utils.js';
 import { threadHasPermission } from 'lib/shared/thread-utils.js';
 import type {
   CreateEntryInfo,
   SaveEntryInfo,
   SaveEntryResult,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryInfo,
   DeleteEntryResult,
   CalendarQuery,
 } from 'lib/types/entry-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import type { ResolvedThreadInfo, ThreadInfo } from 'lib/types/thread-types.js';
 import {
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { dateString } from 'lib/utils/date-utils.js';
 import { useResolvedThreadInfo } from 'lib/utils/entity-helpers.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import sleep from 'lib/utils/sleep.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import type { EntryInfoWithHeight } from './calendar.react.js';
 import LoadingIndicator from './loading-indicator.react.js';
 import {
   type MessageListParams,
   useNavigateToThread,
 } from '../chat/message-list-types.js';
 import Button from '../components/button.react.js';
 import SingleLine from '../components/single-line.react.js';
 import TextInput from '../components/text-input.react.js';
 import Markdown from '../markdown/markdown.react.js';
 import { inlineMarkdownRules } from '../markdown/rules.react.js';
 import {
   createIsForegroundSelector,
   nonThreadCalendarQuery,
 } from '../navigation/nav-selectors.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import { ThreadPickerModalRouteName } from '../navigation/route-names.js';
 import type { TabNavigationProp } from '../navigation/tab-navigator.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { colors, useStyles } from '../themes/colors.js';
 import type { LayoutEvent } from '../types/react-native.js';
 import Alert from '../utils/alert.js';
 import { waitForInteractions } from '../utils/timers.js';
 
 function hueDistance(firstColor: string, secondColor: string): number {
   const firstHue = tinycolor(firstColor).toHsv().h;
   const secondHue = tinycolor(secondColor).toHsv().h;
   const distance = Math.abs(firstHue - secondHue);
   return distance > 180 ? 360 - distance : distance;
 }
 const omitEntryInfo = _omit(['entryInfo']);
 
 function dummyNodeForEntryHeightMeasurement(
   entryText: string,
 ): React.Element<typeof View> {
   const text = entryText === '' ? ' ' : entryText;
   return (
     <View style={[unboundStyles.entry, unboundStyles.textContainer]}>
       <Text style={unboundStyles.text}>{text}</Text>
     </View>
   );
 }
 
 const unboundStyles = {
   actionLinks: {
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'space-between',
     marginTop: -5,
   },
   button: {
     padding: 5,
   },
   buttonContents: {
     flex: 1,
     flexDirection: 'row',
   },
   container: {
     backgroundColor: 'listBackground',
   },
   entry: {
     borderRadius: 8,
     margin: 5,
     overflow: 'hidden',
   },
   leftLinks: {
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'flex-start',
     paddingHorizontal: 5,
   },
   leftLinksText: {
     fontSize: 12,
     fontWeight: 'bold',
     paddingLeft: 5,
   },
   pencilIcon: {
     lineHeight: 13,
     paddingTop: 1,
   },
   rightLinks: {
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'flex-end',
     paddingHorizontal: 5,
   },
   rightLinksText: {
     fontSize: 12,
     fontWeight: 'bold',
   },
   text: {
     fontFamily: 'System',
     fontSize: 16,
   },
   textContainer: {
     position: 'absolute',
     top: 0,
     paddingBottom: 6,
     paddingLeft: 10,
     paddingRight: 10,
     paddingTop: 5,
     transform: (Platform.select({
       ios: [{ translateY: -1 / 3 }],
       default: [],
     }): $ReadOnlyArray<{ +translateY: number }>),
   },
   textInput: {
     fontFamily: 'System',
     fontSize: 16,
     left: ((Platform.OS === 'android' ? 9.8 : 10): number),
     margin: 0,
     padding: 0,
     position: 'absolute',
     right: 10,
     top: ((Platform.OS === 'android' ? 4.8 : 0.5): number),
   },
 };
 
 type SharedProps = {
   +navigation: TabNavigationProp<'Calendar'>,
   +entryInfo: EntryInfoWithHeight,
   +visible: boolean,
   +active: boolean,
   +makeActive: (entryKey: string, active: boolean) => void,
   +onEnterEditMode: (entryInfo: EntryInfoWithHeight) => void,
   +onConcludeEditMode: (entryInfo: EntryInfoWithHeight) => void,
   +onPressWhitespace: () => void,
   +entryRef: (entryKey: string, entry: ?InternalEntry) => void,
 };
 type BaseProps = {
   ...SharedProps,
   +threadInfo: ThreadInfo,
 };
 type Props = {
   ...SharedProps,
   +threadInfo: ResolvedThreadInfo,
   // Redux state
   +calendarQuery: () => CalendarQuery,
   +online: boolean,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Nav state
   +threadPickerActive: boolean,
   +navigateToThread: (params: MessageListParams) => void,
   // Redux dispatch functions
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +createEntry: (info: CreateEntryInfo) => Promise<CreateEntryPayload>,
   +saveEntry: (info: SaveEntryInfo) => Promise<SaveEntryResult>,
   +deleteEntry: (info: DeleteEntryInfo) => Promise<DeleteEntryResult>,
 };
 type State = {
   +editing: boolean,
   +text: string,
   +loadingStatus: LoadingStatus,
   +height: number,
 };
 class InternalEntry extends React.Component<Props, State> {
   textInput: ?React.ElementRef<typeof BaseTextInput>;
   creating: boolean = false;
   needsUpdateAfterCreation: boolean = false;
   needsDeleteAfterCreation: boolean = false;
   nextSaveAttemptIndex: number = 0;
   mounted: boolean = false;
   deleted: boolean = false;
   currentlySaving: ?string;
 
   constructor(props: Props) {
     super(props);
     this.state = {
       editing: false,
       text: props.entryInfo.text,
       loadingStatus: 'inactive',
       height: props.entryInfo.textHeight,
     };
     this.state = {
       ...this.state,
       editing: InternalEntry.isActive(props, this.state),
     };
   }
 
   guardedSetState(input: Partial<State>) {
     if (this.mounted) {
       this.setState(input);
     }
   }
 
   shouldComponentUpdate(nextProps: Props, nextState: State): boolean {
     return (
       !shallowequal(nextState, this.state) ||
       !shallowequal(omitEntryInfo(nextProps), omitEntryInfo(this.props)) ||
       !_isEqual(nextProps.entryInfo)(this.props.entryInfo)
     );
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     const wasActive = InternalEntry.isActive(prevProps, prevState);
     const isActive = InternalEntry.isActive(this.props, this.state);
 
     if (
       !isActive &&
       (this.props.entryInfo.text !== prevProps.entryInfo.text ||
         this.props.entryInfo.textHeight !== prevProps.entryInfo.textHeight) &&
       (this.props.entryInfo.text !== this.state.text ||
         this.props.entryInfo.textHeight !== this.state.height)
     ) {
       this.guardedSetState({
         text: this.props.entryInfo.text,
         height: this.props.entryInfo.textHeight,
       });
       this.currentlySaving = null;
     }
 
     if (
       !this.props.active &&
       this.state.text === prevState.text &&
       this.state.height !== prevState.height &&
       this.state.height !== this.props.entryInfo.textHeight
     ) {
       const approxMeasuredHeight = Math.round(this.state.height * 1000) / 1000;
       const approxExpectedHeight =
         Math.round(this.props.entryInfo.textHeight * 1000) / 1000;
       console.log(
         `Entry height for ${entryKey(this.props.entryInfo)} was expected to ` +
           `be ${approxExpectedHeight} but is actually ` +
           `${approxMeasuredHeight}. This means Calendar's FlatList isn't ` +
           'getting the right item height for some of its nodes, which is ' +
           'guaranteed to cause glitchy behavior. Please investigate!!',
       );
     }
 
     // Our parent will set the active prop to false if something else gets
     // pressed or if the Entry is scrolled out of view. In either of those cases
     // we should complete the edit process.
     if (!this.props.active && prevProps.active) {
       this.completeEdit();
     }
 
     if (this.state.height !== prevState.height || isActive !== wasActive) {
       LayoutAnimation.easeInEaseOut();
     }
 
     if (
       this.props.online &&
       !prevProps.online &&
       this.state.loadingStatus === 'error'
     ) {
       this.save();
     }
 
     if (
       this.state.editing &&
       prevState.editing &&
       (this.state.text.trim() === '') !== (prevState.text.trim() === '')
     ) {
       LayoutAnimation.easeInEaseOut();
     }
   }
 
   componentDidMount() {
     this.mounted = true;
     this.props.entryRef(entryKey(this.props.entryInfo), this);
   }
 
   componentWillUnmount() {
     this.mounted = false;
     this.props.entryRef(entryKey(this.props.entryInfo), null);
     this.props.onConcludeEditMode(this.props.entryInfo);
   }
 
   static isActive(props: Props, state: State): boolean {
     return (
       props.active ||
       state.editing ||
       !props.entryInfo.id ||
       state.loadingStatus !== 'inactive'
     );
   }
 
   render(): React.Node {
     const active = InternalEntry.isActive(this.props, this.state);
     const { editing } = this.state;
     const threadColor = `#${this.props.threadInfo.color}`;
 
     const darkColor = colorIsDark(this.props.threadInfo.color);
     let actionLinks = null;
     if (active) {
       const actionLinksColor = darkColor ? '#D3D3D3' : '#404040';
       const actionLinksTextStyle = { color: actionLinksColor };
       const { modalIosHighlightUnderlay: actionLinksUnderlayColor } = darkColor
         ? colors.dark
         : colors.light;
       const loadingIndicatorCanUseRed = hueDistance('red', threadColor) > 50;
       let editButtonContent = null;
       if (editing && this.state.text.trim() === '') {
         // nothing
       } else if (editing) {
         editButtonContent = (
           <React.Fragment>
             <Icon name="check" size={14} color={actionLinksColor} />
             <Text
               style={[this.props.styles.leftLinksText, actionLinksTextStyle]}
             >
               SAVE
             </Text>
           </React.Fragment>
         );
       } else {
         editButtonContent = (
           <React.Fragment>
             <Icon
               name="pencil"
               size={12}
               color={actionLinksColor}
               style={this.props.styles.pencilIcon}
             />
             <Text
               style={[this.props.styles.leftLinksText, actionLinksTextStyle]}
             >
               EDIT
             </Text>
           </React.Fragment>
         );
       }
       actionLinks = (
         <View style={this.props.styles.actionLinks}>
           <View style={this.props.styles.leftLinks}>
             <Button
               onPress={this.delete}
               iosFormat="highlight"
               iosHighlightUnderlayColor={actionLinksUnderlayColor}
               iosActiveOpacity={0.85}
               style={this.props.styles.button}
             >
               <View style={this.props.styles.buttonContents}>
                 <Icon name="close" size={14} color={actionLinksColor} />
                 <Text
                   style={[
                     this.props.styles.leftLinksText,
                     actionLinksTextStyle,
                   ]}
                 >
                   DELETE
                 </Text>
               </View>
             </Button>
             <Button
               onPress={this.onPressEdit}
               iosFormat="highlight"
               iosHighlightUnderlayColor={actionLinksUnderlayColor}
               iosActiveOpacity={0.85}
               style={this.props.styles.button}
             >
               <View style={this.props.styles.buttonContents}>
                 {editButtonContent}
               </View>
             </Button>
           </View>
           <View style={this.props.styles.rightLinks}>
             <LoadingIndicator
               loadingStatus={this.state.loadingStatus}
               color={actionLinksColor}
               canUseRed={loadingIndicatorCanUseRed}
             />
             <Button
               onPress={this.onPressThreadName}
               iosFormat="highlight"
               iosHighlightUnderlayColor={actionLinksUnderlayColor}
               iosActiveOpacity={0.85}
               style={this.props.styles.button}
             >
               <SingleLine
                 style={[this.props.styles.rightLinksText, actionLinksTextStyle]}
               >
                 {this.props.threadInfo.uiName}
               </SingleLine>
             </Button>
           </View>
         </View>
       );
     }
 
     const textColor = darkColor ? 'white' : 'black';
     let textInput;
     if (editing) {
       const textInputStyle = {
         color: textColor,
         backgroundColor: threadColor,
       };
       const selectionColor = darkColor ? '#129AFF' : '#036AFF';
       textInput = (
         <TextInput
           style={[this.props.styles.textInput, textInputStyle]}
           value={this.state.text}
           onChangeText={this.onChangeText}
           multiline={true}
           onFocus={this.onFocus}
           onBlur={this.onBlur}
           selectionColor={selectionColor}
           ref={this.textInputRef}
         />
       );
     }
 
     let rawText = this.state.text;
     if (rawText === '' || rawText.slice(-1) === '\n') {
       rawText += ' ';
     }
     const textStyle = {
       ...this.props.styles.text,
       color: textColor,
       opacity: textInput ? 0 : 1,
     };
     // We use an empty View to set the height of the entry, and then position
     // the Text and TextInput absolutely. This allows to measure height changes
     // to the Text while controlling the actual height of the entry.
     const heightStyle = { height: this.state.height };
     const entryStyle = { backgroundColor: threadColor };
     const opacity = editing ? 1.0 : 0.6;
     const canEditEntry = threadHasPermission(
       this.props.threadInfo,
       threadPermissions.EDIT_ENTRIES,
     );
     return (
       <TouchableWithoutFeedback onPress={this.props.onPressWhitespace}>
         <View style={this.props.styles.container}>
           <Button
             disabled={!canEditEntry}
             onPress={this.setActive}
             style={[this.props.styles.entry, entryStyle]}
             androidFormat="opacity"
             iosActiveOpacity={opacity}
           >
             <View>
               <View style={heightStyle} />
               <View
                 style={this.props.styles.textContainer}
                 onLayout={this.onTextContainerLayout}
               >
                 <Markdown
                   style={textStyle}
                   rules={inlineMarkdownRules(darkColor)}
                 >
                   {rawText}
                 </Markdown>
               </View>
               {textInput}
             </View>
             {actionLinks}
           </Button>
         </View>
       </TouchableWithoutFeedback>
     );
   }
 
   textInputRef: (textInput: ?React.ElementRef<typeof BaseTextInput>) => void =
     textInput => {
       this.textInput = textInput;
       if (textInput && this.state.editing) {
-        this.enterEditMode();
+        void this.enterEditMode();
       }
     };
 
   enterEditMode: () => Promise<void> = async () => {
     this.setActive();
     this.props.onEnterEditMode(this.props.entryInfo);
     if (Platform.OS === 'android') {
       // If we don't do this, the TextInput focuses
       // but the soft keyboard doesn't come up
       await waitForInteractions();
       await sleep(15);
     }
     this.focus();
   };
 
   focus: () => void = () => {
     const { textInput } = this;
     if (!textInput) {
       return;
     }
     textInput.focus();
   };
 
   onFocus: () => void = () => {
     if (this.props.threadPickerActive) {
       this.props.navigation.goBack();
     }
   };
 
   setActive: () => void = () => this.makeActive(true);
 
   completeEdit: () => void = () => {
     // This gets called from CalendarInputBar (save button above keyboard),
     // onPressEdit (save button in Entry action links), and in
     // componentDidUpdate above when Calendar sets this Entry to inactive.
     // Calendar does this if something else gets pressed or the Entry is
     // scrolled out of view. Note that an Entry won't consider itself inactive
     // until it's done updating the server with its state, and if the network
     // requests fail it may stay "active".
     if (this.textInput) {
       this.textInput.blur();
     }
     this.onBlur();
   };
 
   onBlur: () => void = () => {
     if (this.state.text.trim() === '') {
       this.delete();
     } else if (this.props.entryInfo.text !== this.state.text) {
       this.save();
     }
     this.guardedSetState({ editing: false });
     this.makeActive(false);
     this.props.onConcludeEditMode(this.props.entryInfo);
   };
 
   save: () => void = () => {
     this.dispatchSave(this.props.entryInfo.id, this.state.text);
   };
 
   onTextContainerLayout: (event: LayoutEvent) => void = event => {
     this.guardedSetState({
       height: Math.ceil(event.nativeEvent.layout.height),
     });
   };
 
   onChangeText: (newText: string) => void = newText => {
     this.guardedSetState({ text: newText });
   };
 
   makeActive(active: boolean) {
     const { threadInfo } = this.props;
     if (!threadHasPermission(threadInfo, threadPermissions.EDIT_ENTRIES)) {
       return;
     }
     this.props.makeActive(entryKey(this.props.entryInfo), active);
   }
 
   dispatchSave(serverID: ?string, newText: string) {
     if (this.currentlySaving === newText) {
       return;
     }
     this.currentlySaving = newText;
 
     if (newText.trim() === '') {
       // We don't save the empty string, since as soon as the element becomes
       // inactive it'll get deleted
       return;
     }
 
     if (!serverID) {
       if (this.creating) {
         // We need the first save call to return so we know the ID of the entry
         // we're updating, so we'll need to handle this save later
         this.needsUpdateAfterCreation = true;
         return;
       } else {
         this.creating = true;
       }
     }
 
     this.guardedSetState({ loadingStatus: 'loading' });
     if (!serverID) {
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         createEntryActionTypes,
         this.createAction(newText),
       );
     } else {
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         saveEntryActionTypes,
         this.saveAction(serverID, newText),
       );
     }
   }
 
   async createAction(text: string): Promise<CreateEntryPayload> {
     const localID = this.props.entryInfo.localID;
     invariant(localID, "if there's no serverID, there should be a localID");
     const curSaveAttempt = this.nextSaveAttemptIndex++;
     try {
       const response = await this.props.createEntry({
         text,
         timestamp: this.props.entryInfo.creationTime,
         date: dateString(
           this.props.entryInfo.year,
           this.props.entryInfo.month,
           this.props.entryInfo.day,
         ),
         threadID: this.props.entryInfo.threadID,
         localID,
         calendarQuery: this.props.calendarQuery(),
       });
       if (curSaveAttempt + 1 === this.nextSaveAttemptIndex) {
         this.guardedSetState({ loadingStatus: 'inactive' });
       }
       this.creating = false;
       if (this.needsUpdateAfterCreation) {
         this.needsUpdateAfterCreation = false;
         this.dispatchSave(response.entryID, this.state.text);
       }
       if (this.needsDeleteAfterCreation) {
         this.needsDeleteAfterCreation = false;
         this.dispatchDelete(response.entryID);
       }
       return response;
     } catch (e) {
       if (curSaveAttempt + 1 === this.nextSaveAttemptIndex) {
         this.guardedSetState({ loadingStatus: 'error' });
       }
       this.currentlySaving = null;
       this.creating = false;
       throw e;
     }
   }
 
   async saveAction(
     entryID: string,
     newText: string,
   ): Promise<SaveEntryPayload> {
     const curSaveAttempt = this.nextSaveAttemptIndex++;
     try {
       const response = await this.props.saveEntry({
         entryID,
         text: newText,
         prevText: this.props.entryInfo.text,
         timestamp: Date.now(),
         calendarQuery: this.props.calendarQuery(),
       });
       if (curSaveAttempt + 1 === this.nextSaveAttemptIndex) {
         this.guardedSetState({ loadingStatus: 'inactive' });
       }
       return { ...response, threadID: this.props.entryInfo.threadID };
     } catch (e) {
       if (curSaveAttempt + 1 === this.nextSaveAttemptIndex) {
         this.guardedSetState({ loadingStatus: 'error' });
       }
       this.currentlySaving = null;
       if (e instanceof ServerError && e.message === 'concurrent_modification') {
         const revertedText = e.payload?.db;
         const onRefresh = () => {
           this.guardedSetState({
             loadingStatus: 'inactive',
             text: revertedText,
           });
           this.props.dispatch({
             type: concurrentModificationResetActionType,
             payload: { id: entryID, dbText: revertedText },
           });
         };
         Alert.alert(
           'Concurrent modification',
           'It looks like somebody is attempting to modify that field at the ' +
             'same time as you! Please try again.',
           [{ text: 'OK', onPress: onRefresh }],
           { cancelable: false },
         );
       }
       throw e;
     }
   }
 
   delete: () => void = () => {
     this.dispatchDelete(this.props.entryInfo.id);
   };
 
   onPressEdit: () => void = () => {
     if (this.state.editing) {
       this.completeEdit();
     } else {
       this.guardedSetState({ editing: true });
     }
   };
 
   dispatchDelete(serverID: ?string) {
     if (this.deleted) {
       return;
     }
     this.deleted = true;
     LayoutAnimation.easeInEaseOut();
     const { localID } = this.props.entryInfo;
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       deleteEntryActionTypes,
       this.deleteAction(serverID),
       undefined,
       { localID, serverID },
     );
   }
 
   async deleteAction(serverID: ?string): Promise<?DeleteEntryResult> {
     if (serverID) {
       return await this.props.deleteEntry({
         entryID: serverID,
         prevText: this.props.entryInfo.text,
         calendarQuery: this.props.calendarQuery(),
       });
     } else if (this.creating) {
       this.needsDeleteAfterCreation = true;
     }
     return null;
   }
 
   onPressThreadName: () => void = () => {
     Keyboard.dismiss();
     this.props.navigateToThread({ threadInfo: this.props.threadInfo });
   };
 }
 
 registerFetchKey(saveEntryActionTypes);
 registerFetchKey(deleteEntryActionTypes);
 const activeThreadPickerSelector = createIsForegroundSelector(
   ThreadPickerModalRouteName,
 );
 
 const Entry: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedEntry(props: BaseProps) {
     const navContext = React.useContext(NavContext);
     const threadPickerActive = activeThreadPickerSelector(navContext);
 
     const calendarQuery = useSelector(state =>
       nonThreadCalendarQuery({
         redux: state,
         navContext,
       }),
     );
     const connection = useSelector(connectionSelector(ashoatKeyserverID));
     invariant(connection, 'keyserver missing from keyserverStore');
     const online = connection.status === 'connected';
     const styles = useStyles(unboundStyles);
 
     const navigateToThread = useNavigateToThread();
 
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const callCreateEntry = useCreateEntry();
     const callSaveEntry = useSaveEntry();
     const callDeleteEntry = useDeleteEntry();
 
     const { threadInfo: unresolvedThreadInfo, ...restProps } = props;
     const threadInfo = useResolvedThreadInfo(unresolvedThreadInfo);
 
     return (
       <InternalEntry
         {...restProps}
         threadPickerActive={threadPickerActive}
         calendarQuery={calendarQuery}
         online={online}
         styles={styles}
         navigateToThread={navigateToThread}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         createEntry={callCreateEntry}
         saveEntry={callSaveEntry}
         deleteEntry={callDeleteEntry}
         threadInfo={threadInfo}
       />
     );
   },
 );
 
 export { InternalEntry, Entry, dummyNodeForEntryHeightMeasurement };
diff --git a/native/chat/chat-input-bar.react.js b/native/chat/chat-input-bar.react.js
index 3fbddc316..3d7e78942 100644
--- a/native/chat/chat-input-bar.react.js
+++ b/native/chat/chat-input-bar.react.js
@@ -1,1453 +1,1456 @@
 // @flow
 
 import Icon from '@expo/vector-icons/Ionicons.js';
 import type { GenericNavigationAction } from '@react-navigation/core';
 import invariant from 'invariant';
 import _throttle from 'lodash/throttle.js';
 import * as React from 'react';
 import {
   View,
   TextInput,
   TouchableOpacity,
   Platform,
   Text,
   ActivityIndicator,
   TouchableWithoutFeedback,
   NativeAppEventEmitter,
 } from 'react-native';
 import { TextInputKeyboardMangerIOS } from 'react-native-keyboard-input';
 import Animated, {
   EasingNode,
   FadeInDown,
   FadeOutDown,
 } from 'react-native-reanimated';
 
 import {
   moveDraftActionType,
   updateDraftActionType,
 } from 'lib/actions/draft-actions.js';
 import {
   joinThreadActionTypes,
   useJoinThread,
   newThreadActionTypes,
 } from 'lib/actions/thread-actions.js';
 import {
   useChatMentionContext,
   useThreadChatMentionCandidates,
 } from 'lib/hooks/chat-mention-hooks.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { userStoreMentionSearchIndex } from 'lib/selectors/user-selectors.js';
 import { colorIsDark } from 'lib/shared/color-utils.js';
 import { useEditMessage } from 'lib/shared/edit-messages-utils.js';
 import {
   getMentionTypeaheadUserSuggestions,
   getMentionTypeaheadChatSuggestions,
   getTypeaheadRegexMatches,
   type Selection,
   getUserMentionsCandidates,
 } from 'lib/shared/mention-utils.js';
 import {
   useNextLocalID,
   trimMessage,
   useMessagePreview,
   messageKey,
   type MessagePreviewResult,
 } from 'lib/shared/message-utils.js';
 import SentencePrefixSearchIndex from 'lib/shared/sentence-prefix-search-index.js';
 import {
   threadHasPermission,
   viewerIsMember,
   threadFrozenDueToViewerBlock,
   threadActualMembers,
   checkIfDefaultMembersAreVoiced,
   draftKeyFromThreadID,
 } from 'lib/shared/thread-utils.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { PhotoPaste } from 'lib/types/media-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import type {
   SendEditMessageResponse,
   MessageInfo,
 } from 'lib/types/message-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import type {
   ClientThreadJoinRequest,
   ThreadJoinPayload,
   ChatMentionCandidates,
   RelativeMemberInfo,
   ThreadInfo,
 } from 'lib/types/thread-types.js';
 import { type UserInfos } from 'lib/types/user-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import { ChatContext } from './chat-context.js';
 import type { ChatNavigationProp } from './chat.react.js';
 import {
   MessageEditingContext,
   type MessageEditingContextType,
 } from './message-editing-context.react.js';
 import type { RemoveEditMode } from './message-list-types.js';
 import TypeaheadTooltip from './typeahead-tooltip.react.js';
 import MentionTypeaheadTooltipButton from '../chat/mention-typeahead-tooltip-button.react.js';
 import Button from '../components/button.react.js';
 // eslint-disable-next-line import/extensions
 import ClearableTextInput from '../components/clearable-text-input.react';
 import type { SyncedSelectionData } from '../components/selectable-text-input.js';
 // eslint-disable-next-line import/extensions
 import SelectableTextInput from '../components/selectable-text-input.react';
 import SingleLine from '../components/single-line.react.js';
 import SWMansionIcon from '../components/swmansion-icon.react.js';
 import {
   type InputState,
   InputStateContext,
   type EditInputBarMessageParameters,
 } from '../input/input-state.js';
 import KeyboardInputHost from '../keyboard/keyboard-input-host.react.js';
 import {
   type KeyboardState,
   KeyboardContext,
 } from '../keyboard/keyboard-state.js';
 import { getKeyboardHeight } from '../keyboard/keyboard.js';
 import { getDefaultTextMessageRules } from '../markdown/rules.react.js';
 import {
   nonThreadCalendarQuery,
   activeThreadSelector,
 } from '../navigation/nav-selectors.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import { OverlayContext } from '../navigation/overlay-context.js';
 import type { OverlayContextType } from '../navigation/overlay-context.js';
 import {
   type NavigationRoute,
   ChatCameraModalRouteName,
   ImagePasteModalRouteName,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { type Colors, useStyles, useColors } from '../themes/colors.js';
 import type { LayoutEvent, ImagePasteEvent } from '../types/react-native.js';
 import {
   type AnimatedViewStyle,
   AnimatedView,
   type ViewStyle,
 } from '../types/styles.js';
 import Alert from '../utils/alert.js';
 import { runTiming } from '../utils/animation-utils.js';
 import { exitEditAlert } from '../utils/edit-messages-utils.js';
 import {
   nativeMentionTypeaheadRegex,
   mentionTypeaheadTooltipActions,
 } from '../utils/typeahead-utils.js';
 
 /* eslint-disable import/no-named-as-default-member */
 const { Value, Clock, block, set, cond, neq, sub, interpolateNode, stopClock } =
   Animated;
 /* eslint-enable import/no-named-as-default-member */
 
 const expandoButtonsAnimationConfig = {
   duration: 150,
   easing: EasingNode.inOut(EasingNode.ease),
 };
 const sendButtonAnimationConfig = {
   duration: 150,
   easing: EasingNode.inOut(EasingNode.ease),
 };
 
 const unboundStyles = {
   cameraIcon: {
     paddingBottom: Platform.OS === 'android' ? 11 : 8,
     paddingRight: 5,
   },
   cameraRollIcon: {
     paddingBottom: Platform.OS === 'android' ? 11 : 8,
     paddingRight: 5,
   },
   container: {
     backgroundColor: 'listBackground',
     paddingLeft: Platform.OS === 'android' ? 10 : 5,
   },
   expandButton: {
     bottom: 0,
     position: 'absolute',
     right: 0,
   },
   expandIcon: {
     paddingBottom: Platform.OS === 'android' ? 13 : 11,
     paddingRight: 2,
   },
   expandoButtons: {
     alignSelf: 'flex-end',
   },
   explanation: {
     color: 'listBackgroundSecondaryLabel',
     paddingBottom: 4,
     paddingTop: 1,
     textAlign: 'center',
   },
   innerExpandoButtons: {
     alignItems: 'flex-end',
     alignSelf: 'flex-end',
     flexDirection: 'row',
   },
   inputContainer: {
     flexDirection: 'row',
   },
   joinButton: {
     borderRadius: 8,
     flex: 1,
     justifyContent: 'center',
     marginHorizontal: 12,
     marginVertical: 3,
   },
   joinButtonContainer: {
     flexDirection: 'row',
     height: 48,
     marginBottom: 8,
   },
   editView: {
     marginLeft: 20,
     marginRight: 20,
     padding: 10,
     flexDirection: 'row',
     justifyContent: 'space-between',
   },
   editViewContent: {
     flex: 1,
     paddingRight: 6,
   },
   exitEditButton: {
     marginTop: 6,
   },
   editingLabel: {
     paddingBottom: 4,
   },
   editingMessagePreview: {
     color: 'listForegroundLabel',
   },
   joinButtonContent: {
     flexDirection: 'row',
     justifyContent: 'center',
     alignItems: 'center',
   },
   joinButtonTextLight: {
     color: 'white',
     fontSize: 20,
     marginHorizontal: 4,
   },
   joinButtonTextDark: {
     color: 'black',
     fontSize: 20,
     marginHorizontal: 4,
   },
   joinThreadLoadingIndicator: {
     paddingVertical: 2,
   },
   sendButton: {
     position: 'absolute',
     bottom: 4,
     left: 0,
   },
   sendIcon: {
     paddingLeft: 9,
     paddingRight: 8,
     paddingVertical: 6,
   },
   textInput: {
     backgroundColor: 'listInputBackground',
     borderRadius: 8,
     color: 'listForegroundLabel',
     fontSize: 16,
     marginLeft: 4,
     marginRight: 4,
     marginTop: 6,
     marginBottom: 8,
     maxHeight: 110,
     paddingHorizontal: 10,
     paddingVertical: 5,
   },
 };
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
 };
 type Props = {
   ...BaseProps,
   +viewerID: ?string,
   +draft: string,
   +joinThreadLoadingStatus: LoadingStatus,
   +threadCreationInProgress: boolean,
   +calendarQuery: () => CalendarQuery,
   +nextLocalID: string,
   +userInfos: UserInfos,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   +onInputBarLayout?: (event: LayoutEvent) => mixed,
   +openCamera: () => mixed,
   +isActive: boolean,
   +keyboardState: ?KeyboardState,
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   +joinThread: (request: ClientThreadJoinRequest) => Promise<ThreadJoinPayload>,
   +inputState: ?InputState,
   +userSearchIndex: SentencePrefixSearchIndex,
   +userMentionsCandidates: $ReadOnlyArray<RelativeMemberInfo>,
   +chatMentionSearchIndex: SentencePrefixSearchIndex,
   +chatMentionCandidates: ChatMentionCandidates,
   +parentThreadInfo: ?ThreadInfo,
   +editedMessagePreview: ?MessagePreviewResult,
   +editedMessageInfo: ?MessageInfo,
   +editMessage: (
     messageID: string,
     text: string,
   ) => Promise<SendEditMessageResponse>,
   +navigation: ?ChatNavigationProp<'MessageList'>,
   +overlayContext: ?OverlayContextType,
   +messageEditingContext: ?MessageEditingContextType,
 };
 type State = {
   +text: string,
   +textEdited: boolean,
   +buttonsExpanded: boolean,
   +selectionState: SyncedSelectionData,
   +isExitingDuringEditMode: boolean,
 };
 class ChatInputBar extends React.PureComponent<Props, State> {
   textInput: ?React.ElementRef<typeof TextInput>;
   clearableTextInput: ?ClearableTextInput;
   selectableTextInput: ?React.ElementRef<typeof SelectableTextInput>;
 
   expandoButtonsOpen: Value;
   targetExpandoButtonsOpen: Value;
   expandoButtonsStyle: AnimatedViewStyle;
   cameraRollIconStyle: AnimatedViewStyle;
   cameraIconStyle: AnimatedViewStyle;
   expandIconStyle: AnimatedViewStyle;
 
   sendButtonContainerOpen: Value;
   targetSendButtonContainerOpen: Value;
   sendButtonContainerStyle: AnimatedViewStyle;
 
   clearBeforeRemoveListener: () => void;
   clearFocusListener: () => void;
   clearBlurListener: () => void;
 
   constructor(props: Props) {
     super(props);
     this.state = {
       text: props.draft,
       textEdited: false,
       buttonsExpanded: true,
       selectionState: { text: props.draft, selection: { start: 0, end: 0 } },
       isExitingDuringEditMode: false,
     };
 
     this.setUpActionIconAnimations();
     this.setUpSendIconAnimations();
   }
 
   setUpActionIconAnimations() {
     this.expandoButtonsOpen = new Value(1);
     this.targetExpandoButtonsOpen = new Value(1);
     const prevTargetExpandoButtonsOpen = new Value(1);
     const expandoButtonClock = new Clock();
     const expandoButtonsOpen = block([
       cond(neq(this.targetExpandoButtonsOpen, prevTargetExpandoButtonsOpen), [
         stopClock(expandoButtonClock),
         set(prevTargetExpandoButtonsOpen, this.targetExpandoButtonsOpen),
       ]),
       cond(
         neq(this.expandoButtonsOpen, this.targetExpandoButtonsOpen),
         set(
           this.expandoButtonsOpen,
           runTiming(
             expandoButtonClock,
             this.expandoButtonsOpen,
             this.targetExpandoButtonsOpen,
             true,
             expandoButtonsAnimationConfig,
           ),
         ),
       ),
       this.expandoButtonsOpen,
     ]);
 
     this.cameraRollIconStyle = {
       ...unboundStyles.cameraRollIcon,
       opacity: expandoButtonsOpen,
     };
     this.cameraIconStyle = {
       ...unboundStyles.cameraIcon,
       opacity: expandoButtonsOpen,
     };
 
     const expandoButtonsWidth = interpolateNode(expandoButtonsOpen, {
       inputRange: [0, 1],
       outputRange: [26, 66],
     });
     this.expandoButtonsStyle = {
       ...unboundStyles.expandoButtons,
       width: expandoButtonsWidth,
     };
 
     const expandOpacity = sub(1, expandoButtonsOpen);
     this.expandIconStyle = {
       ...unboundStyles.expandIcon,
       opacity: expandOpacity,
     };
   }
 
   setUpSendIconAnimations() {
     const initialSendButtonContainerOpen = trimMessage(this.props.draft)
       ? 1
       : 0;
     this.sendButtonContainerOpen = new Value(initialSendButtonContainerOpen);
     this.targetSendButtonContainerOpen = new Value(
       initialSendButtonContainerOpen,
     );
     const prevTargetSendButtonContainerOpen = new Value(
       initialSendButtonContainerOpen,
     );
     const sendButtonClock = new Clock();
     const sendButtonContainerOpen = block([
       cond(
         neq(
           this.targetSendButtonContainerOpen,
           prevTargetSendButtonContainerOpen,
         ),
         [
           stopClock(sendButtonClock),
           set(
             prevTargetSendButtonContainerOpen,
             this.targetSendButtonContainerOpen,
           ),
         ],
       ),
       cond(
         neq(this.sendButtonContainerOpen, this.targetSendButtonContainerOpen),
         set(
           this.sendButtonContainerOpen,
           runTiming(
             sendButtonClock,
             this.sendButtonContainerOpen,
             this.targetSendButtonContainerOpen,
             true,
             sendButtonAnimationConfig,
           ),
         ),
       ),
       this.sendButtonContainerOpen,
     ]);
 
     const sendButtonContainerWidth = interpolateNode(sendButtonContainerOpen, {
       inputRange: [0, 1],
       outputRange: [4, 38],
     });
     this.sendButtonContainerStyle = { width: sendButtonContainerWidth };
   }
 
   static mediaGalleryOpen(props: Props): boolean {
     const { keyboardState } = props;
     return !!(keyboardState && keyboardState.mediaGalleryOpen);
   }
 
   static systemKeyboardShowing(props: Props): boolean {
     const { keyboardState } = props;
     return !!(keyboardState && keyboardState.systemKeyboardShowing);
   }
 
   get systemKeyboardShowing(): boolean {
     return ChatInputBar.systemKeyboardShowing(this.props);
   }
 
   immediatelyShowSendButton() {
     this.sendButtonContainerOpen.setValue(1);
     this.targetSendButtonContainerOpen.setValue(1);
   }
 
   updateSendButton(currentText: string) {
     if (this.shouldShowTextInput) {
       this.targetSendButtonContainerOpen.setValue(currentText === '' ? 0 : 1);
     } else {
       this.setUpSendIconAnimations();
     }
   }
 
   componentDidMount() {
     const { isActive, navigation } = this.props;
     if (isActive) {
       this.addEditInputMessageListener();
     }
     if (!navigation) {
       return;
     }
     this.clearBeforeRemoveListener = navigation.addListener(
       'beforeRemove',
       this.onNavigationBeforeRemove,
     );
     this.clearFocusListener = navigation.addListener(
       'focus',
       this.onNavigationFocus,
     );
     this.clearBlurListener = navigation.addListener(
       'blur',
       this.onNavigationBlur,
     );
   }
 
   componentWillUnmount() {
     if (this.props.isActive) {
       this.removeEditInputMessageListener();
     }
     if (this.clearBeforeRemoveListener) {
       this.clearBeforeRemoveListener();
     }
     if (this.clearFocusListener) {
       this.clearFocusListener();
     }
     if (this.clearBlurListener) {
       this.clearBlurListener();
     }
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (
       this.state.textEdited &&
       this.state.text &&
       this.props.threadInfo.id !== prevProps.threadInfo.id
     ) {
       this.props.dispatch({
         type: moveDraftActionType,
         payload: {
           oldKey: draftKeyFromThreadID(prevProps.threadInfo.id),
           newKey: draftKeyFromThreadID(this.props.threadInfo.id),
         },
       });
     } else if (!this.state.textEdited && this.props.draft !== prevProps.draft) {
       this.setState({ text: this.props.draft });
     }
     if (this.props.isActive && !prevProps.isActive) {
       this.addEditInputMessageListener();
     } else if (!this.props.isActive && prevProps.isActive) {
       this.removeEditInputMessageListener();
     }
 
     const currentText = trimMessage(this.state.text);
     const prevText = trimMessage(prevState.text);
 
     if (
       (currentText === '' && prevText !== '') ||
       (currentText !== '' && prevText === '')
     ) {
       this.updateSendButton(currentText);
     }
 
     const systemKeyboardIsShowing = ChatInputBar.systemKeyboardShowing(
       this.props,
     );
     const systemKeyboardWasShowing =
       ChatInputBar.systemKeyboardShowing(prevProps);
     if (systemKeyboardIsShowing && !systemKeyboardWasShowing) {
       this.hideButtons();
     } else if (!systemKeyboardIsShowing && systemKeyboardWasShowing) {
       this.expandButtons();
     }
 
     const imageGalleryIsOpen = ChatInputBar.mediaGalleryOpen(this.props);
     const imageGalleryWasOpen = ChatInputBar.mediaGalleryOpen(prevProps);
     if (!imageGalleryIsOpen && imageGalleryWasOpen) {
       this.hideButtons();
     } else if (imageGalleryIsOpen && !imageGalleryWasOpen) {
       this.expandButtons();
       this.setIOSKeyboardHeight();
     }
 
     if (
       this.props.messageEditingContext?.editState.editedMessage &&
       !prevProps.messageEditingContext?.editState.editedMessage
     ) {
       this.blockNavigation();
     }
   }
 
   addEditInputMessageListener() {
     invariant(
       this.props.inputState,
       'inputState should be set in addEditInputMessageListener',
     );
     this.props.inputState.addEditInputMessageListener(this.focusAndUpdateText);
   }
 
   removeEditInputMessageListener() {
     invariant(
       this.props.inputState,
       'inputState should be set in removeEditInputMessageListener',
     );
     this.props.inputState.removeEditInputMessageListener(
       this.focusAndUpdateText,
     );
   }
 
   setIOSKeyboardHeight() {
     if (Platform.OS !== 'ios') {
       return;
     }
     const { textInput } = this;
     if (!textInput) {
       return;
     }
     const keyboardHeight = getKeyboardHeight();
     if (keyboardHeight === null || keyboardHeight === undefined) {
       return;
     }
     TextInputKeyboardMangerIOS.setKeyboardHeight(textInput, keyboardHeight);
   }
 
   get shouldShowTextInput(): boolean {
     if (threadHasPermission(this.props.threadInfo, threadPermissions.VOICED)) {
       return true;
     }
     // If the thread is created by somebody else while the viewer is attempting
     // to create it, the threadInfo might be modified in-place
     // and won't list the viewer as a member,
     // which will end up hiding the input.
     // In this case, we will assume that our creation action
     // will get translated into a join, and as long
     // as members are voiced, we can show the input.
     if (!this.props.threadCreationInProgress) {
       return false;
     }
     return checkIfDefaultMembersAreVoiced(this.props.threadInfo);
   }
 
   render(): React.Node {
     const isMember = viewerIsMember(this.props.threadInfo);
     const canJoin = threadHasPermission(
       this.props.threadInfo,
       threadPermissions.JOIN_THREAD,
     );
     let joinButton = null;
     const threadColor = `#${this.props.threadInfo.color}`;
     const isEditMode = this.isEditMode();
     if (!isMember && canJoin && !this.props.threadCreationInProgress) {
       let buttonContent;
       if (this.props.joinThreadLoadingStatus === 'loading') {
         buttonContent = (
           <ActivityIndicator
             size="small"
             color="white"
             style={this.props.styles.joinThreadLoadingIndicator}
           />
         );
       } else {
         const textStyle = colorIsDark(this.props.threadInfo.color)
           ? this.props.styles.joinButtonTextLight
           : this.props.styles.joinButtonTextDark;
         buttonContent = (
           <View style={this.props.styles.joinButtonContent}>
             <SWMansionIcon name="plus" style={textStyle} />
             <Text style={textStyle}>Join Chat</Text>
           </View>
         );
       }
       joinButton = (
         <View style={this.props.styles.joinButtonContainer}>
           <Button
             onPress={this.onPressJoin}
             iosActiveOpacity={0.85}
             style={[
               this.props.styles.joinButton,
               { backgroundColor: threadColor },
             ]}
           >
             {buttonContent}
           </Button>
         </View>
       );
     }
 
     const typeaheadRegexMatches = getTypeaheadRegexMatches(
       this.state.selectionState.text,
       this.state.selectionState.selection,
       nativeMentionTypeaheadRegex,
     );
 
     let typeaheadTooltip = null;
 
     if (typeaheadRegexMatches && !isEditMode) {
       const typeaheadMatchedStrings = {
         textBeforeAtSymbol: typeaheadRegexMatches[1] ?? '',
         query: typeaheadRegexMatches[4] ?? '',
       };
 
       const suggestedUsers = getMentionTypeaheadUserSuggestions(
         this.props.userSearchIndex,
         this.props.userMentionsCandidates,
         this.props.viewerID,
         typeaheadMatchedStrings.query,
       );
       const suggestedChats = getMentionTypeaheadChatSuggestions(
         this.props.chatMentionSearchIndex,
         this.props.chatMentionCandidates,
         typeaheadMatchedStrings.query,
       );
       const suggestions = [...suggestedUsers, ...suggestedChats];
 
       if (suggestions.length > 0) {
         typeaheadTooltip = (
           <TypeaheadTooltip
             text={this.state.text}
             matchedStrings={typeaheadMatchedStrings}
             suggestions={suggestions}
             focusAndUpdateTextAndSelection={this.focusAndUpdateTextAndSelection}
             typeaheadTooltipActionsGetter={mentionTypeaheadTooltipActions}
             TypeaheadTooltipButtonComponent={MentionTypeaheadTooltipButton}
           />
         );
       }
     }
 
     let content;
     const defaultMembersAreVoiced = checkIfDefaultMembersAreVoiced(
       this.props.threadInfo,
     );
     if (this.shouldShowTextInput) {
       content = this.renderInput();
     } else if (
       threadFrozenDueToViewerBlock(
         this.props.threadInfo,
         this.props.viewerID,
         this.props.userInfos,
       ) &&
       threadActualMembers(this.props.threadInfo.members).length === 2
     ) {
       content = (
         <Text style={this.props.styles.explanation}>
           You can&rsquo;t send messages to a user that you&rsquo;ve blocked.
         </Text>
       );
     } else if (isMember) {
       content = (
         <Text style={this.props.styles.explanation}>
           You don&rsquo;t have permission to send messages.
         </Text>
       );
     } else if (defaultMembersAreVoiced && canJoin) {
       content = null;
     } else {
       content = (
         <Text style={this.props.styles.explanation}>
           You don&rsquo;t have permission to send messages.
         </Text>
       );
     }
 
     const keyboardInputHost =
       Platform.OS === 'android' ? null : (
         <KeyboardInputHost textInputRef={this.textInput} />
       );
 
     let editedMessage;
     if (isEditMode && this.props.editedMessagePreview) {
       const { message } = this.props.editedMessagePreview;
       editedMessage = (
         <AnimatedView
           style={this.props.styles.editView}
           entering={FadeInDown}
           exiting={FadeOutDown}
         >
           <View style={this.props.styles.editViewContent}>
             <TouchableOpacity
               onPress={this.scrollToEditedMessage}
               activeOpacity={0.4}
             >
               <Text
                 style={[{ color: threadColor }, this.props.styles.editingLabel]}
               >
                 Editing message
               </Text>
               <SingleLine style={this.props.styles.editingMessagePreview}>
                 {message.text}
               </SingleLine>
             </TouchableOpacity>
           </View>
           <SWMansionIcon
             style={this.props.styles.exitEditButton}
             name="cross"
             size={22}
             color={threadColor}
             onPress={this.onPressExitEditMode}
           />
         </AnimatedView>
       );
     }
 
     return (
       <AnimatedView
         style={this.props.styles.container}
         onLayout={this.props.onInputBarLayout}
       >
         {typeaheadTooltip}
         {joinButton}
         {editedMessage}
         {content}
         {keyboardInputHost}
       </AnimatedView>
     );
   }
 
   renderInput(): React.Node {
     const expandoButton = (
       <TouchableOpacity
         onPress={this.expandButtons}
         activeOpacity={0.4}
         style={this.props.styles.expandButton}
       >
         <AnimatedView style={this.expandIconStyle}>
           <SWMansionIcon
             name="chevron-right"
             size={22}
             color={`#${this.props.threadInfo.color}`}
           />
         </AnimatedView>
       </TouchableOpacity>
     );
     const threadColor = `#${this.props.threadInfo.color}`;
     const expandoButtonsViewStyle: Array<ViewStyle> = [
       this.props.styles.innerExpandoButtons,
     ];
     if (this.isEditMode()) {
       expandoButtonsViewStyle.push({ display: 'none' });
     }
     return (
       <TouchableWithoutFeedback onPress={this.dismissKeyboard}>
         <View style={this.props.styles.inputContainer}>
           <AnimatedView style={this.expandoButtonsStyle}>
             <View style={expandoButtonsViewStyle}>
               {this.state.buttonsExpanded ? expandoButton : null}
               <TouchableOpacity
                 onPress={this.showMediaGallery}
                 activeOpacity={0.4}
               >
                 <AnimatedView style={this.cameraRollIconStyle}>
                   <SWMansionIcon
                     name="image-1"
                     size={28}
                     color={`#${this.props.threadInfo.color}`}
                   />
                 </AnimatedView>
               </TouchableOpacity>
               <TouchableOpacity
                 onPress={this.props.openCamera}
                 activeOpacity={0.4}
                 disabled={!this.state.buttonsExpanded}
               >
                 <AnimatedView style={this.cameraIconStyle}>
                   <SWMansionIcon
                     name="camera"
                     size={28}
                     color={`#${this.props.threadInfo.color}`}
                   />
                 </AnimatedView>
               </TouchableOpacity>
               {this.state.buttonsExpanded ? null : expandoButton}
             </View>
           </AnimatedView>
           <SelectableTextInput
             allowImagePasteForThreadID={this.props.threadInfo.id}
             value={this.state.text}
             onChangeText={this.updateText}
             selection={this.state.selectionState.selection}
             onUpdateSyncedSelectionData={this.updateSelectionState}
             placeholder="Send a message..."
             placeholderTextColor={this.props.colors.listInputButton}
             multiline={true}
             style={this.props.styles.textInput}
             textInputRef={this.textInputRef}
             clearableTextInputRef={this.clearableTextInputRef}
             ref={this.selectableTextInputRef}
             selectionColor={`#${this.props.threadInfo.color}`}
           />
           <AnimatedView style={this.sendButtonContainerStyle}>
             <TouchableOpacity
               onPress={this.onSend}
               activeOpacity={0.4}
               style={this.props.styles.sendButton}
               disabled={trimMessage(this.state.text) === ''}
             >
               <Icon
                 name="md-send"
                 size={25}
                 style={this.props.styles.sendIcon}
                 color={threadColor}
               />
             </TouchableOpacity>
           </AnimatedView>
         </View>
       </TouchableWithoutFeedback>
     );
   }
 
   textInputRef = (textInput: ?React.ElementRef<typeof TextInput>) => {
     this.textInput = textInput;
   };
 
   clearableTextInputRef = (clearableTextInput: ?ClearableTextInput) => {
     this.clearableTextInput = clearableTextInput;
   };
 
   selectableTextInputRef = (
     selectableTextInput: ?React.ElementRef<typeof SelectableTextInput>,
   ) => {
     this.selectableTextInput = selectableTextInput;
   };
 
   updateText = (text: string) => {
     if (this.state.isExitingDuringEditMode) {
       return;
     }
     this.setState({ text, textEdited: true });
     this.props.messageEditingContext?.setEditedMessageChanged(
       this.isMessageEdited(text),
     );
     if (this.isEditMode()) {
       return;
     }
     this.saveDraft(text);
   };
 
   updateSelectionState: (data: SyncedSelectionData) => void = data => {
     this.setState({ selectionState: data });
   };
 
   saveDraft: (text: string) => void = _throttle(text => {
     this.props.dispatch({
       type: updateDraftActionType,
       payload: {
         key: draftKeyFromThreadID(this.props.threadInfo.id),
         text,
       },
     });
   }, 400);
 
   focusAndUpdateTextAndSelection = (text: string, selection: Selection) => {
     this.selectableTextInput?.prepareForSelectionMutation(text, selection);
     this.setState({
       text,
       textEdited: true,
       selectionState: { text, selection },
     });
     this.saveDraft(text);
 
     this.focusAndUpdateButtonsVisibility();
   };
 
   focusAndUpdateText = (params: EditInputBarMessageParameters) => {
     const { message: text, mode } = params;
     const currentText = this.state.text;
     if (mode === 'replace') {
       this.updateText(text);
     } else if (!currentText.startsWith(text)) {
       const prependedText = text.concat(currentText);
       this.updateText(prependedText);
     }
 
     this.focusAndUpdateButtonsVisibility();
   };
 
   focusAndUpdateButtonsVisibility = () => {
     const { textInput } = this;
     if (!textInput) {
       return;
     }
 
     this.immediatelyShowSendButton();
     this.immediatelyHideButtons();
     textInput.focus();
   };
 
   onSend = async () => {
     if (!trimMessage(this.state.text)) {
       return;
     }
 
     const editedMessage = this.getEditedMessage();
     if (editedMessage && editedMessage.id) {
       await this.editMessage(editedMessage.id, this.state.text);
       return;
     }
 
     this.updateSendButton('');
 
     const { clearableTextInput } = this;
     invariant(
       clearableTextInput,
       'clearableTextInput should be sent in onSend',
     );
     let text = await clearableTextInput.getValueAndReset();
     text = trimMessage(text);
     if (!text) {
       return;
     }
 
     const localID = this.props.nextLocalID;
     const creatorID = this.props.viewerID;
     invariant(creatorID, 'should have viewer ID in order to send a message');
     invariant(
       this.props.inputState,
       'inputState should be set in ChatInputBar.onSend',
     );
 
     await this.props.inputState.sendTextMessage(
       {
         type: messageTypes.TEXT,
         localID,
         threadID: this.props.threadInfo.id,
         text,
         creatorID,
         time: Date.now(),
       },
       this.props.threadInfo,
       this.props.parentThreadInfo,
     );
   };
 
   isEditMode = (): boolean => {
     const editState = this.props.messageEditingContext?.editState;
     const isThisThread =
       editState?.editedMessage?.threadID === this.props.threadInfo.id;
     return editState?.editedMessage !== null && isThisThread;
   };
 
   isMessageEdited = (newText?: string): boolean => {
     let text = newText ?? this.state.text;
     text = trimMessage(text);
     const originalText = this.props.editedMessageInfo?.text;
     return text !== originalText;
   };
 
   unblockNavigation = () => {
     const { navigation } = this.props;
     if (!navigation) {
       return;
     }
     navigation.setParams({ removeEditMode: null });
   };
 
   removeEditMode: RemoveEditMode = action => {
     const { navigation } = this.props;
     if (!navigation || this.state.isExitingDuringEditMode) {
       return 'ignore_action';
     }
     if (!this.isMessageEdited()) {
       this.unblockNavigation();
       return 'reduce_action';
     }
     const unblockAndDispatch = () => {
       this.unblockNavigation();
       navigation.dispatch(action);
     };
     const onContinueEditing = () => {
       this.props.overlayContext?.resetScrollBlockingModalStatus();
     };
     exitEditAlert({
       onDiscard: unblockAndDispatch,
       onContinueEditing,
     });
     return 'ignore_action';
   };
 
   blockNavigation = () => {
     const { navigation } = this.props;
     if (!navigation || !navigation.isFocused()) {
       return;
     }
     navigation.setParams({
       removeEditMode: this.removeEditMode,
     });
   };
 
   editMessage = async (messageID: string, text: string) => {
     if (!this.isMessageEdited()) {
       this.exitEditMode();
       return;
     }
     text = trimMessage(text);
     try {
       await this.props.editMessage(messageID, text);
       this.exitEditMode();
     } catch (error) {
       Alert.alert(
         'Couldn’t edit the message',
         'Please try again later',
         [{ text: 'OK' }],
         {
           cancelable: true,
         },
       );
     }
   };
 
   getEditedMessage = (): ?MessageInfo => {
     const editState = this.props.messageEditingContext?.editState;
     return editState?.editedMessage;
   };
 
   onPressExitEditMode = () => {
     if (!this.isMessageEdited()) {
       this.exitEditMode();
       return;
     }
     exitEditAlert({
       onDiscard: this.exitEditMode,
     });
   };
 
   scrollToEditedMessage = () => {
     const editedMessage = this.getEditedMessage();
     if (!editedMessage) {
       return;
     }
     const editedMessageKey = messageKey(editedMessage);
     this.props.inputState?.scrollToMessage(editedMessageKey);
   };
 
   exitEditMode = () => {
     this.props.messageEditingContext?.setEditedMessage(null, () => {
       this.unblockNavigation();
       this.updateText(this.props.draft);
       this.focusAndUpdateButtonsVisibility();
       this.updateSendButton(this.props.draft);
     });
   };
 
   onNavigationFocus = () => {
     this.setState({ isExitingDuringEditMode: false });
   };
 
   onNavigationBlur = () => {
     if (!this.isEditMode()) {
       return;
     }
     this.setState(
       { text: this.props.draft, isExitingDuringEditMode: true },
       this.exitEditMode,
     );
   };
 
   onNavigationBeforeRemove = (e: {
     +data: { +action: GenericNavigationAction },
     +preventDefault: () => void,
     ...
   }) => {
     if (!this.isEditMode()) {
       return;
     }
     const { action } = e.data;
     e.preventDefault();
     const saveExit = () => {
       this.props.messageEditingContext?.setEditedMessage(null, () => {
         this.setState({ isExitingDuringEditMode: true }, () => {
           if (!this.props.navigation) {
             return;
           }
           this.props.navigation.dispatch(action);
         });
       });
     };
     if (!this.isMessageEdited()) {
       saveExit();
       return;
     }
     exitEditAlert({
       onDiscard: saveExit,
     });
   };
 
   onPressJoin = () => {
-    this.props.dispatchActionPromise(joinThreadActionTypes, this.joinAction());
+    void this.props.dispatchActionPromise(
+      joinThreadActionTypes,
+      this.joinAction(),
+    );
   };
 
   async joinAction(): Promise<ThreadJoinPayload> {
     const query = this.props.calendarQuery();
     return await this.props.joinThread({
       threadID: this.props.threadInfo.id,
       calendarQuery: {
         startDate: query.startDate,
         endDate: query.endDate,
         filters: [
           ...query.filters,
           { type: 'threads', threadIDs: [this.props.threadInfo.id] },
         ],
       },
     });
   }
 
   expandButtons = () => {
     if (this.state.buttonsExpanded || this.isEditMode()) {
       return;
     }
     this.targetExpandoButtonsOpen.setValue(1);
     this.setState({ buttonsExpanded: true });
   };
 
   hideButtons() {
     if (
       ChatInputBar.mediaGalleryOpen(this.props) ||
       !this.systemKeyboardShowing ||
       !this.state.buttonsExpanded
     ) {
       return;
     }
     this.targetExpandoButtonsOpen.setValue(0);
     this.setState({ buttonsExpanded: false });
   }
 
   immediatelyHideButtons() {
     this.expandoButtonsOpen.setValue(0);
     this.targetExpandoButtonsOpen.setValue(0);
     this.setState({ buttonsExpanded: false });
   }
 
   showMediaGallery = () => {
     const { keyboardState } = this.props;
     invariant(keyboardState, 'keyboardState should be initialized');
     keyboardState.showMediaGallery(this.props.threadInfo);
   };
 
   dismissKeyboard = () => {
     const { keyboardState } = this.props;
     keyboardState && keyboardState.dismissKeyboard();
   };
 }
 
 const joinThreadLoadingStatusSelector = createLoadingStatusSelector(
   joinThreadActionTypes,
 );
 const createThreadLoadingStatusSelector =
   createLoadingStatusSelector(newThreadActionTypes);
 
 type ConnectedChatInputBarBaseProps = {
   ...BaseProps,
   +onInputBarLayout?: (event: LayoutEvent) => mixed,
   +openCamera: () => mixed,
   +navigation?: ChatNavigationProp<'MessageList'>,
 };
 function ConnectedChatInputBarBase(props: ConnectedChatInputBarBaseProps) {
   const navContext = React.useContext(NavContext);
   const keyboardState = React.useContext(KeyboardContext);
   const inputState = React.useContext(InputStateContext);
   const overlayContext = React.useContext(OverlayContext);
 
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const draft = useSelector(
     state =>
       state.draftStore.drafts[draftKeyFromThreadID(props.threadInfo.id)] ?? '',
   );
   const joinThreadLoadingStatus = useSelector(joinThreadLoadingStatusSelector);
   const createThreadLoadingStatus = useSelector(
     createThreadLoadingStatusSelector,
   );
   const threadCreationInProgress = createThreadLoadingStatus === 'loading';
   const calendarQuery = useSelector(state =>
     nonThreadCalendarQuery({
       redux: state,
       navContext,
     }),
   );
   const nextLocalID = useNextLocalID();
   const userInfos = useSelector(state => state.userStore.userInfos);
 
   const styles = useStyles(unboundStyles);
   const colors = useColors();
 
   const isActive = React.useMemo(
     () => props.threadInfo.id === activeThreadSelector(navContext),
     [props.threadInfo.id, navContext],
   );
 
   const dispatch = useDispatch();
   const dispatchActionPromise = useDispatchActionPromise();
   const callJoinThread = useJoinThread();
 
   const userSearchIndex = useSelector(userStoreMentionSearchIndex);
 
   const { getChatMentionSearchIndex } = useChatMentionContext();
   const chatMentionSearchIndex = getChatMentionSearchIndex(props.threadInfo);
 
   const { parentThreadID } = props.threadInfo;
   const parentThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
 
   const userMentionsCandidates = getUserMentionsCandidates(
     props.threadInfo,
     parentThreadInfo,
   );
 
   const chatMentionCandidates = useThreadChatMentionCandidates(
     props.threadInfo,
   );
 
   const messageEditingContext = React.useContext(MessageEditingContext);
 
   const editedMessageInfo = messageEditingContext?.editState.editedMessage;
   const editedMessagePreview = useMessagePreview(
     editedMessageInfo,
     props.threadInfo,
     getDefaultTextMessageRules(chatMentionCandidates).simpleMarkdownRules,
   );
   const editMessage = useEditMessage();
 
   return (
     <ChatInputBar
       {...props}
       viewerID={viewerID}
       draft={draft}
       joinThreadLoadingStatus={joinThreadLoadingStatus}
       threadCreationInProgress={threadCreationInProgress}
       calendarQuery={calendarQuery}
       nextLocalID={nextLocalID}
       userInfos={userInfos}
       colors={colors}
       styles={styles}
       isActive={isActive}
       keyboardState={keyboardState}
       dispatch={dispatch}
       dispatchActionPromise={dispatchActionPromise}
       joinThread={callJoinThread}
       inputState={inputState}
       userSearchIndex={userSearchIndex}
       userMentionsCandidates={userMentionsCandidates}
       chatMentionSearchIndex={chatMentionSearchIndex}
       chatMentionCandidates={chatMentionCandidates}
       parentThreadInfo={parentThreadInfo}
       editedMessagePreview={editedMessagePreview}
       editedMessageInfo={editedMessageInfo}
       editMessage={editMessage}
       navigation={props.navigation}
       overlayContext={overlayContext}
       messageEditingContext={messageEditingContext}
     />
   );
 }
 
 type DummyChatInputBarProps = {
   ...BaseProps,
   +onHeightMeasured: (height: number) => mixed,
 };
 const noop = () => {};
 function DummyChatInputBar(props: DummyChatInputBarProps): React.Node {
   const { onHeightMeasured, ...restProps } = props;
   const onInputBarLayout = React.useCallback(
     (event: LayoutEvent) => {
       const { height } = event.nativeEvent.layout;
       onHeightMeasured(height);
     },
     [onHeightMeasured],
   );
   return (
     <View pointerEvents="none">
       <ConnectedChatInputBarBase
         {...restProps}
         onInputBarLayout={onInputBarLayout}
         openCamera={noop}
       />
     </View>
   );
 }
 
 type ChatInputBarProps = {
   ...BaseProps,
   +navigation: ChatNavigationProp<'MessageList'>,
   +route: NavigationRoute<'MessageList'>,
 };
 const ConnectedChatInputBar: React.ComponentType<ChatInputBarProps> =
   React.memo<ChatInputBarProps>(function ConnectedChatInputBar(
     props: ChatInputBarProps,
   ) {
     const { navigation, route, ...restProps } = props;
     const keyboardState = React.useContext(KeyboardContext);
 
     const { threadInfo } = props;
     const imagePastedCallback = React.useCallback(
       (imagePastedEvent: ImagePasteEvent) => {
         if (threadInfo.id !== imagePastedEvent.threadID) {
           return;
         }
         const pastedImage: PhotoPaste = {
           step: 'photo_paste',
           dimensions: {
             height: imagePastedEvent.height,
             width: imagePastedEvent.width,
           },
           filename: imagePastedEvent.fileName,
           uri: 'file://' + imagePastedEvent.filePath,
           selectTime: 0,
           sendTime: 0,
           retries: 0,
         };
         navigation.navigate<'ImagePasteModal'>({
           name: ImagePasteModalRouteName,
           params: {
             imagePasteStagingInfo: pastedImage,
             thread: threadInfo,
           },
         });
       },
       [navigation, threadInfo],
     );
 
     React.useEffect(() => {
       const imagePasteListener = NativeAppEventEmitter.addListener(
         'imagePasted',
         imagePastedCallback,
       );
       return () => imagePasteListener.remove();
     }, [imagePastedCallback]);
 
     const chatContext = React.useContext(ChatContext);
     invariant(chatContext, 'should be set');
     const { setChatInputBarHeight, deleteChatInputBarHeight } = chatContext;
     const onInputBarLayout = React.useCallback(
       (event: LayoutEvent) => {
         const { height } = event.nativeEvent.layout;
         setChatInputBarHeight(threadInfo.id, height);
       },
       [threadInfo.id, setChatInputBarHeight],
     );
 
     React.useEffect(() => {
       return () => {
         deleteChatInputBarHeight(threadInfo.id);
       };
     }, [deleteChatInputBarHeight, threadInfo.id]);
 
     const openCamera = React.useCallback(() => {
       keyboardState?.dismissKeyboard();
       navigation.navigate<'ChatCameraModal'>({
         name: ChatCameraModalRouteName,
         params: {
           presentedFrom: route.key,
           thread: threadInfo,
         },
       });
     }, [keyboardState, navigation, route.key, threadInfo]);
 
     return (
       <ConnectedChatInputBarBase
         {...restProps}
         onInputBarLayout={onInputBarLayout}
         openCamera={openCamera}
         navigation={navigation}
       />
     );
   });
 
 export { ConnectedChatInputBar as ChatInputBar, DummyChatInputBar };
diff --git a/native/chat/compose-subchannel.react.js b/native/chat/compose-subchannel.react.js
index be49ed120..2b8a1f26d 100644
--- a/native/chat/compose-subchannel.react.js
+++ b/native/chat/compose-subchannel.react.js
@@ -1,386 +1,386 @@
 // @flow
 
 import invariant from 'invariant';
 import _filter from 'lodash/fp/filter.js';
 import _flow from 'lodash/fp/flow.js';
 import _sortBy from 'lodash/fp/sortBy.js';
 import * as React from 'react';
 import { View, Text } from 'react-native';
 
 import {
   newThreadActionTypes,
   useNewThread,
 } from 'lib/actions/thread-actions.js';
 import { useENSNames } from 'lib/hooks/ens-cache.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import {
   userInfoSelectorForPotentialMembers,
   userSearchIndexForPotentialMembers,
 } from 'lib/selectors/user-selectors.js';
 import { getPotentialMemberItems } from 'lib/shared/search-utils.js';
 import { threadInFilterList, userIsMember } from 'lib/shared/thread-utils.js';
 import { type ThreadType, threadTypes } from 'lib/types/thread-types-enum.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import { type AccountUserInfo } from 'lib/types/user-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import type { ChatNavigationProp } from './chat.react.js';
 import { useNavigateToThread } from './message-list-types.js';
 import ParentThreadHeader from './parent-thread-header.react.js';
 import LinkButton from '../components/link-button.react.js';
 import {
   createTagInput,
   type BaseTagInput,
 } from '../components/tag-input.react.js';
 import ThreadList from '../components/thread-list.react.js';
 import UserList from '../components/user-list.react.js';
 import { useCalendarQuery } from '../navigation/nav-selectors.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 import Alert from '../utils/alert.js';
 
 const TagInput = createTagInput<AccountUserInfo>();
 
 const tagInputProps = {
   placeholder: 'username',
   autoFocus: true,
   returnKeyType: 'go',
 };
 
 const tagDataLabelExtractor = (userInfo: AccountUserInfo) => userInfo.username;
 
 export type ComposeSubchannelParams = {
   +threadType: ThreadType,
   +parentThreadInfo: ThreadInfo,
 };
 
 type Props = {
   +navigation: ChatNavigationProp<'ComposeSubchannel'>,
   +route: NavigationRoute<'ComposeSubchannel'>,
 };
 function ComposeSubchannel(props: Props): React.Node {
   const [usernameInputText, setUsernameInputText] = React.useState<string>('');
   const [userInfoInputArray, setUserInfoInputArray] = React.useState<
     $ReadOnlyArray<AccountUserInfo>,
   >([]);
   const [createButtonEnabled, setCreateButtonEnabled] =
     React.useState<boolean>(true);
 
   const tagInputRef = React.useRef<?BaseTagInput<AccountUserInfo>>();
   const onUnknownErrorAlertAcknowledged = React.useCallback(() => {
     setUsernameInputText('');
     tagInputRef.current?.focus();
   }, []);
 
   const waitingOnThreadIDRef = React.useRef<?string>();
 
   const { threadType, parentThreadInfo } = props.route.params;
   const userInfoInputIDs = userInfoInputArray.map(userInfo => userInfo.id);
   const callNewThread = useNewThread();
   const calendarQuery = useCalendarQuery();
   const newChatThreadAction = React.useCallback(async () => {
     try {
       const assumedThreadType =
         threadType ?? threadTypes.COMMUNITY_SECRET_SUBTHREAD;
       const query = calendarQuery();
       invariant(
         assumedThreadType === 3 ||
           assumedThreadType === 4 ||
           assumedThreadType === 6 ||
           assumedThreadType === 7,
         "Sidebars and communities can't be created from the thread composer",
       );
       const result = await callNewThread({
         type: assumedThreadType,
         parentThreadID: parentThreadInfo.id,
         initialMemberIDs: userInfoInputIDs,
         color: parentThreadInfo.color,
         calendarQuery: query,
       });
       waitingOnThreadIDRef.current = result.newThreadID;
       return result;
     } catch (e) {
       setCreateButtonEnabled(true);
       Alert.alert(
         'Unknown error',
         'Uhh... try again?',
         [{ text: 'OK', onPress: onUnknownErrorAlertAcknowledged }],
         { cancelable: false },
       );
       throw e;
     }
   }, [
     threadType,
     userInfoInputIDs,
     calendarQuery,
     parentThreadInfo,
     callNewThread,
     onUnknownErrorAlertAcknowledged,
   ]);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const dispatchNewChatThreadAction = React.useCallback(() => {
     setCreateButtonEnabled(false);
-    dispatchActionPromise(newThreadActionTypes, newChatThreadAction());
+    void dispatchActionPromise(newThreadActionTypes, newChatThreadAction());
   }, [dispatchActionPromise, newChatThreadAction]);
 
   const userInfoInputArrayEmpty = userInfoInputArray.length === 0;
   const onPressCreateThread = React.useCallback(() => {
     if (!createButtonEnabled) {
       return;
     }
     if (userInfoInputArrayEmpty) {
       Alert.alert(
         'Chatting to yourself?',
         'Are you sure you want to create a channel containing only yourself?',
         [
           { text: 'Cancel', style: 'cancel' },
           { text: 'Confirm', onPress: dispatchNewChatThreadAction },
         ],
         { cancelable: true },
       );
     } else {
       dispatchNewChatThreadAction();
     }
   }, [
     createButtonEnabled,
     userInfoInputArrayEmpty,
     dispatchNewChatThreadAction,
   ]);
 
   const { navigation } = props;
   const { setOptions } = navigation;
   React.useEffect(() => {
     setOptions({
       // eslint-disable-next-line react/display-name
       headerRight: () => (
         <LinkButton
           text="Create"
           onPress={onPressCreateThread}
           disabled={!createButtonEnabled}
         />
       ),
     });
   }, [setOptions, onPressCreateThread, createButtonEnabled]);
 
   const { setParams } = navigation;
   const parentThreadInfoID = parentThreadInfo.id;
   const reduxParentThreadInfo = useSelector(
     state => threadInfoSelector(state)[parentThreadInfoID],
   );
   React.useEffect(() => {
     if (reduxParentThreadInfo) {
       setParams({ parentThreadInfo: reduxParentThreadInfo });
     }
   }, [reduxParentThreadInfo, setParams]);
 
   const threadInfos = useSelector(threadInfoSelector);
   const newlyCreatedThreadInfo = waitingOnThreadIDRef.current
     ? threadInfos[waitingOnThreadIDRef.current]
     : null;
   const { pushNewThread } = navigation;
   React.useEffect(() => {
     if (!newlyCreatedThreadInfo) {
       return;
     }
 
     const waitingOnThreadID = waitingOnThreadIDRef.current;
     if (waitingOnThreadID === null || waitingOnThreadID === undefined) {
       return;
     }
     waitingOnThreadIDRef.current = undefined;
 
     pushNewThread(newlyCreatedThreadInfo);
   }, [newlyCreatedThreadInfo, pushNewThread]);
 
   const otherUserInfos = useSelector(userInfoSelectorForPotentialMembers);
   const userSearchIndex = useSelector(userSearchIndexForPotentialMembers);
   const { community } = parentThreadInfo;
   const communityThreadInfo = useSelector(state =>
     community ? threadInfoSelector(state)[community] : null,
   );
   const userSearchResults = React.useMemo(
     () =>
       getPotentialMemberItems({
         text: usernameInputText,
         userInfos: otherUserInfos,
         searchIndex: userSearchIndex,
         excludeUserIDs: userInfoInputIDs,
         inputParentThreadInfo: parentThreadInfo,
         inputCommunityThreadInfo: communityThreadInfo,
         threadType,
       }),
     [
       usernameInputText,
       otherUserInfos,
       userSearchIndex,
       userInfoInputIDs,
       parentThreadInfo,
       communityThreadInfo,
       threadType,
     ],
   );
 
   const existingThreads: $ReadOnlyArray<ThreadInfo> = React.useMemo(() => {
     if (userInfoInputIDs.length === 0) {
       return [];
     }
     return _flow(
       _filter(
         (threadInfo: ThreadInfo) =>
           threadInFilterList(threadInfo) &&
           threadInfo.parentThreadID === parentThreadInfo.id &&
           userInfoInputIDs.every(userID => userIsMember(threadInfo, userID)),
       ),
       _sortBy(
         ([
           'members.length',
           (threadInfo: ThreadInfo) => (threadInfo.name ? 1 : 0),
         ]: $ReadOnlyArray<string | ((threadInfo: ThreadInfo) => mixed)>),
       ),
     )(threadInfos);
   }, [userInfoInputIDs, threadInfos, parentThreadInfo]);
 
   const navigateToThread = useNavigateToThread();
   const onSelectExistingThread = React.useCallback(
     (threadID: string) => {
       const threadInfo = threadInfos[threadID];
       navigateToThread({ threadInfo });
     },
     [threadInfos, navigateToThread],
   );
 
   const onUserSelect = React.useCallback(
     ({ id }: AccountUserInfo) => {
       if (userInfoInputIDs.some(existingUserID => id === existingUserID)) {
         return;
       }
       setUserInfoInputArray(oldUserInfoInputArray => [
         ...oldUserInfoInputArray,
         otherUserInfos[id],
       ]);
       setUsernameInputText('');
     },
     [userInfoInputIDs, otherUserInfos],
   );
 
   const styles = useStyles(unboundStyles);
 
   let existingThreadsSection = null;
   if (existingThreads.length > 0) {
     existingThreadsSection = (
       <View style={styles.existingThreads}>
         <View style={styles.existingThreadsRow}>
           <Text style={styles.existingThreadsLabel}>Existing channels</Text>
         </View>
         <View style={styles.existingThreadList}>
           <ThreadList
             threadInfos={existingThreads}
             onSelect={onSelectExistingThread}
             itemTextStyle={styles.listItem}
           />
         </View>
       </View>
     );
   }
 
   const inputProps = React.useMemo(
     () => ({
       ...tagInputProps,
       onSubmitEditing: onPressCreateThread,
     }),
     [onPressCreateThread],
   );
   const userSearchResultWithENSNames = useENSNames(userSearchResults);
   const userInfoInputArrayWithENSNames = useENSNames(userInfoInputArray);
   return (
     <View style={styles.container}>
       <ParentThreadHeader
         parentThreadInfo={parentThreadInfo}
         childThreadType={threadType}
       />
       <View style={styles.userSelectionRow}>
         <Text style={styles.tagInputLabel}>To: </Text>
         <View style={styles.tagInputContainer}>
           <TagInput
             value={userInfoInputArrayWithENSNames}
             onChange={setUserInfoInputArray}
             text={usernameInputText}
             onChangeText={setUsernameInputText}
             labelExtractor={tagDataLabelExtractor}
             inputProps={inputProps}
             ref={tagInputRef}
           />
         </View>
       </View>
       <View style={styles.userList}>
         <UserList
           userInfos={userSearchResultWithENSNames}
           onSelect={onUserSelect}
           itemTextStyle={styles.listItem}
         />
       </View>
       {existingThreadsSection}
     </View>
   );
 }
 
 const unboundStyles = {
   container: {
     flex: 1,
   },
   existingThreadList: {
     backgroundColor: 'modalBackground',
     flex: 1,
     paddingRight: 12,
   },
   existingThreads: {
     flex: 1,
   },
   existingThreadsLabel: {
     color: 'modalForegroundSecondaryLabel',
     fontSize: 16,
     paddingLeft: 12,
     textAlign: 'center',
   },
   existingThreadsRow: {
     backgroundColor: 'modalForeground',
     borderBottomWidth: 1,
     borderColor: 'modalForegroundBorder',
     borderTopWidth: 1,
     paddingVertical: 6,
   },
   listItem: {
     color: 'modalForegroundLabel',
   },
   tagInputContainer: {
     flex: 1,
     marginLeft: 8,
     paddingRight: 12,
   },
   tagInputLabel: {
     color: 'modalForegroundSecondaryLabel',
     fontSize: 16,
     paddingLeft: 12,
   },
   userList: {
     backgroundColor: 'modalBackground',
     flex: 1,
     paddingLeft: 35,
     paddingRight: 12,
   },
   userSelectionRow: {
     alignItems: 'center',
     backgroundColor: 'modalForeground',
     borderBottomWidth: 1,
     borderColor: 'modalForegroundBorder',
     flexDirection: 'row',
     paddingVertical: 6,
   },
 };
 
 const MemoizedComposeSubchannel: React.ComponentType<Props> =
   React.memo<Props>(ComposeSubchannel);
 
 export default MemoizedComposeSubchannel;
diff --git a/native/chat/failed-send.react.js b/native/chat/failed-send.react.js
index d7c9ac35a..66f616c8a 100644
--- a/native/chat/failed-send.react.js
+++ b/native/chat/failed-send.react.js
@@ -1,177 +1,177 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { messageID } from 'lib/shared/message-utils.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import { assertComposableRawMessage } from 'lib/types/message-types.js';
 import type { RawComposableMessageInfo } from 'lib/types/message-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 
 import { multimediaMessageSendFailed } from './multimedia-message-utils.js';
 import textMessageSendFailed from './text-message-send-failed.js';
 import Button from '../components/button.react.js';
 import { type InputState, InputStateContext } from '../input/input-state.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 import type { ChatMessageInfoItemWithHeight } from '../types/chat-types.js';
 
 const failedSendHeight = 22;
 
 const unboundStyles = {
   deliveryFailed: {
     color: 'listSeparatorLabel',
     paddingHorizontal: 3,
   },
   failedSendInfo: {
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'flex-end',
     marginRight: 20,
     paddingTop: 5,
   },
   retrySend: {
     paddingHorizontal: 3,
   },
 };
 
 type BaseProps = {
   +item: ChatMessageInfoItemWithHeight,
 };
 type Props = {
   ...BaseProps,
   +rawMessageInfo: ?RawComposableMessageInfo,
   +styles: $ReadOnly<typeof unboundStyles>,
   +inputState: ?InputState,
   +parentThreadInfo: ?ThreadInfo,
 };
 class FailedSend extends React.PureComponent<Props> {
   retryingText = false;
   retryingMedia = false;
 
   componentDidUpdate(prevProps: Props) {
     const newItem = this.props.item;
     const prevItem = prevProps.item;
     if (
       newItem.messageShapeType === 'multimedia' &&
       prevItem.messageShapeType === 'multimedia'
     ) {
       const isFailed = multimediaMessageSendFailed(newItem);
       const wasFailed = multimediaMessageSendFailed(prevItem);
       const isDone =
         newItem.messageInfo.id !== null && newItem.messageInfo.id !== undefined;
       const wasDone =
         prevItem.messageInfo.id !== null &&
         prevItem.messageInfo.id !== undefined;
       if ((isFailed && !wasFailed) || (isDone && !wasDone)) {
         this.retryingMedia = false;
       }
     } else if (
       newItem.messageShapeType === 'text' &&
       prevItem.messageShapeType === 'text'
     ) {
       const isFailed = textMessageSendFailed(newItem);
       const wasFailed = textMessageSendFailed(prevItem);
       const isDone =
         newItem.messageInfo.id !== null && newItem.messageInfo.id !== undefined;
       const wasDone =
         prevItem.messageInfo.id !== null &&
         prevItem.messageInfo.id !== undefined;
       if ((isFailed && !wasFailed) || (isDone && !wasDone)) {
         this.retryingText = false;
       }
     }
   }
 
   render(): React.Node {
     if (!this.props.rawMessageInfo) {
       return null;
     }
     const threadColor = {
       color: `#${this.props.item.threadInfo.color}`,
     };
 
     return (
       <View style={this.props.styles.failedSendInfo}>
         <Text style={this.props.styles.deliveryFailed} numberOfLines={1}>
           DELIVERY FAILED.
         </Text>
         <Button onPress={this.retrySend}>
           <Text
             style={{
               ...this.props.styles.retrySend,
               ...threadColor,
             }}
             numberOfLines={1}
           >
             {'RETRY?'}
           </Text>
         </Button>
       </View>
     );
   }
 
   retrySend = () => {
     const { rawMessageInfo } = this.props;
     if (!rawMessageInfo) {
       return;
     }
 
     if (rawMessageInfo.type === messageTypes.TEXT) {
       if (this.retryingText) {
         return;
       }
       this.retryingText = true;
     } else if (
       rawMessageInfo.type === messageTypes.IMAGES ||
       rawMessageInfo.type === messageTypes.MULTIMEDIA
     ) {
       if (this.retryingMedia) {
         return;
       }
       this.retryingMedia = true;
     }
 
     const { inputState } = this.props;
     invariant(
       inputState,
       'inputState should be initialized before user can hit retry',
     );
     const { localID } = rawMessageInfo;
     invariant(localID, 'failed RawMessageInfo should have localID');
-    inputState.retryMessage(
+    void inputState.retryMessage(
       localID,
       this.props.item.threadInfo,
       this.props.parentThreadInfo,
     );
   };
 }
 
 const ConnectedFailedSend: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedFailedSend(props: BaseProps) {
     const id = messageID(props.item.messageInfo);
     const rawMessageInfo = useSelector(state => {
       const message = state.messageStore.messages[id];
       return message ? assertComposableRawMessage(message) : null;
     });
     const styles = useStyles(unboundStyles);
     const inputState = React.useContext(InputStateContext);
     const { parentThreadID } = props.item.threadInfo;
     const parentThreadInfo = useSelector(state =>
       parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
     );
     return (
       <FailedSend
         {...props}
         rawMessageInfo={rawMessageInfo}
         styles={styles}
         inputState={inputState}
         parentThreadInfo={parentThreadInfo}
       />
     );
   });
 
 export { ConnectedFailedSend as FailedSend, failedSendHeight };
diff --git a/native/chat/message-list.react.js b/native/chat/message-list.react.js
index b08236c60..2715b7818 100644
--- a/native/chat/message-list.react.js
+++ b/native/chat/message-list.react.js
@@ -1,373 +1,373 @@
 // @flow
 
 import invariant from 'invariant';
 import _find from 'lodash/fp/find.js';
 import * as React from 'react';
 import { View, TouchableWithoutFeedback } from 'react-native';
 import { createSelector } from 'reselect';
 
 import {
   fetchMessagesBeforeCursorActionTypes,
   useFetchMessagesBeforeCursor,
   fetchMostRecentMessagesActionTypes,
   useFetchMostRecentMessages,
   type FetchMostRecentMessagesInput,
   type FetchMessagesBeforeCursorInput,
 } from 'lib/actions/message-actions.js';
 import { useOldestMessageServerID } from 'lib/hooks/message-hooks.js';
 import { registerFetchKey } from 'lib/reducers/loading-reducer.js';
 import { messageKey } from 'lib/shared/message-utils.js';
 import { useWatchThread } from 'lib/shared/thread-utils.js';
 import type { FetchMessageInfosPayload } from 'lib/types/message-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import ChatList from './chat-list.react.js';
 import type { ChatNavigationProp } from './chat.react.js';
 import Message from './message.react.js';
 import RelationshipPrompt from './relationship-prompt.react.js';
 import ListLoadingIndicator from '../components/list-loading-indicator.react.js';
 import {
   type KeyboardState,
   KeyboardContext,
 } from '../keyboard/keyboard-state.js';
 import { defaultStackScreenOptions } from '../navigation/options.js';
 import {
   OverlayContext,
   type OverlayContextType,
 } from '../navigation/overlay-context.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import {
   useStyles,
   type IndicatorStyle,
   useIndicatorStyle,
 } from '../themes/colors.js';
 import type {
   ChatMessageInfoItemWithHeight,
   ChatMessageItemWithHeight,
 } from '../types/chat-types.js';
 import type { VerticalBounds } from '../types/layout-types.js';
 import type { ViewableItemsChange } from '../types/react-native.js';
 
 const unboundStyles = {
   container: {
     backgroundColor: 'listBackground',
     flex: 1,
   },
   header: {
     height: 12,
   },
   listLoadingIndicator: {
     flex: 1,
   },
 };
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
   +messageListData: $ReadOnlyArray<ChatMessageItemWithHeight>,
   +navigation: ChatNavigationProp<'MessageList'>,
   +route: NavigationRoute<'MessageList'>,
 };
 type Props = {
   ...BaseProps,
   +startReached: boolean,
   +styles: $ReadOnly<typeof unboundStyles>,
   +indicatorStyle: IndicatorStyle,
   +dispatchActionPromise: DispatchActionPromise,
   +fetchMessagesBeforeCursor: (
     input: FetchMessagesBeforeCursorInput,
   ) => Promise<FetchMessageInfosPayload>,
   +fetchMostRecentMessages: (
     input: FetchMostRecentMessagesInput,
   ) => Promise<FetchMessageInfosPayload>,
   +overlayContext: ?OverlayContextType,
   +keyboardState: ?KeyboardState,
   +oldestMessageServerID: ?string,
 };
 type State = {
   +focusedMessageKey: ?string,
   +messageListVerticalBounds: ?VerticalBounds,
   +loadingFromScroll: boolean,
 };
 type PropsAndState = {
   ...Props,
   ...State,
 };
 type FlatListExtraData = {
   messageListVerticalBounds: ?VerticalBounds,
   focusedMessageKey: ?string,
   navigation: ChatNavigationProp<'MessageList'>,
   route: NavigationRoute<'MessageList'>,
 };
 class MessageList extends React.PureComponent<Props, State> {
   state: State = {
     focusedMessageKey: null,
     messageListVerticalBounds: null,
     loadingFromScroll: false,
   };
   flatListContainer: ?React.ElementRef<typeof View>;
 
   flatListExtraDataSelector: PropsAndState => FlatListExtraData =
     createSelector(
       (propsAndState: PropsAndState) => propsAndState.messageListVerticalBounds,
       (propsAndState: PropsAndState) => propsAndState.focusedMessageKey,
       (propsAndState: PropsAndState) => propsAndState.navigation,
       (propsAndState: PropsAndState) => propsAndState.route,
       (
         messageListVerticalBounds: ?VerticalBounds,
         focusedMessageKey: ?string,
         navigation: ChatNavigationProp<'MessageList'>,
         route: NavigationRoute<'MessageList'>,
       ) => ({
         messageListVerticalBounds,
         focusedMessageKey,
         navigation,
         route,
       }),
     );
 
   get flatListExtraData(): FlatListExtraData {
     return this.flatListExtraDataSelector({ ...this.props, ...this.state });
   }
 
   static getOverlayContext(props: Props): OverlayContextType {
     const { overlayContext } = props;
     invariant(overlayContext, 'MessageList should have OverlayContext');
     return overlayContext;
   }
 
   static scrollDisabled(props: Props): boolean {
     const overlayContext = MessageList.getOverlayContext(props);
     return overlayContext.scrollBlockingModalStatus !== 'closed';
   }
 
   static modalOpen(props: Props): boolean {
     const overlayContext = MessageList.getOverlayContext(props);
     return overlayContext.scrollBlockingModalStatus === 'open';
   }
 
   componentDidUpdate(prevProps: Props) {
     const modalIsOpen = MessageList.modalOpen(this.props);
     const modalWasOpen = MessageList.modalOpen(prevProps);
     if (!modalIsOpen && modalWasOpen) {
       this.setState({ focusedMessageKey: null });
     }
 
     if (defaultStackScreenOptions.gestureEnabled) {
       const scrollIsDisabled = MessageList.scrollDisabled(this.props);
       const scrollWasDisabled = MessageList.scrollDisabled(prevProps);
       if (!scrollWasDisabled && scrollIsDisabled) {
         this.props.navigation.setOptions({ gestureEnabled: false });
       } else if (scrollWasDisabled && !scrollIsDisabled) {
         this.props.navigation.setOptions({ gestureEnabled: true });
       }
     }
   }
 
   dismissKeyboard = () => {
     const { keyboardState } = this.props;
     keyboardState && keyboardState.dismissKeyboard();
   };
 
   renderItem = (row: { item: ChatMessageItemWithHeight, ... }): React.Node => {
     if (row.item.itemType === 'loader') {
       return (
         <TouchableWithoutFeedback onPress={this.dismissKeyboard}>
           <View style={this.props.styles.listLoadingIndicator}>
             <ListLoadingIndicator />
           </View>
         </TouchableWithoutFeedback>
       );
     }
     const messageInfoItem: ChatMessageInfoItemWithHeight = row.item;
     const { messageListVerticalBounds, focusedMessageKey, navigation, route } =
       this.flatListExtraData;
     const focused =
       messageKey(messageInfoItem.messageInfo) === focusedMessageKey;
     return (
       <Message
         item={messageInfoItem}
         focused={focused}
         navigation={navigation}
         route={route}
         toggleFocus={this.toggleMessageFocus}
         verticalBounds={messageListVerticalBounds}
         shouldDisplayPinIndicator={true}
       />
     );
   };
 
   toggleMessageFocus = (inMessageKey: string) => {
     if (this.state.focusedMessageKey === inMessageKey) {
       this.setState({ focusedMessageKey: null });
     } else {
       this.setState({ focusedMessageKey: inMessageKey });
     }
   };
 
   // Actually header, it's just that our FlatList is inverted
   ListFooterComponent = (): React.Node => (
     <View style={this.props.styles.header} />
   );
 
   render(): React.Node {
     const { messageListData, startReached } = this.props;
     const footer = startReached ? this.ListFooterComponent : undefined;
     let relationshipPrompt = null;
     if (this.props.threadInfo.type === threadTypes.PERSONAL) {
       relationshipPrompt = (
         <RelationshipPrompt
           pendingPersonalThreadUserInfo={
             this.props.route.params.pendingPersonalThreadUserInfo
           }
           threadInfo={this.props.threadInfo}
         />
       );
     }
     return (
       <View
         style={this.props.styles.container}
         ref={this.flatListContainerRef}
         onLayout={this.onFlatListContainerLayout}
       >
         {relationshipPrompt}
         <ChatList
           navigation={this.props.navigation}
           inverted={true}
           data={messageListData}
           renderItem={this.renderItem}
           onViewableItemsChanged={this.onViewableItemsChanged}
           ListFooterComponent={footer}
           scrollsToTop={false}
           scrollEnabled={!MessageList.scrollDisabled(this.props)}
           extraData={this.flatListExtraData}
           indicatorStyle={this.props.indicatorStyle}
           keyboardShouldPersistTaps="always"
         />
       </View>
     );
   }
 
   flatListContainerRef = (
     flatListContainer: ?React.ElementRef<typeof View>,
   ) => {
     this.flatListContainer = flatListContainer;
   };
 
   onFlatListContainerLayout = () => {
     const { flatListContainer } = this;
     if (!flatListContainer) {
       return;
     }
     flatListContainer.measure((x, y, width, height, pageX, pageY) => {
       if (
         height === null ||
         height === undefined ||
         pageY === null ||
         pageY === undefined
       ) {
         return;
       }
       this.setState({ messageListVerticalBounds: { height, y: pageY } });
     });
   };
 
   onViewableItemsChanged = (info: ViewableItemsChange) => {
     if (this.state.focusedMessageKey) {
       let focusedMessageVisible = false;
       for (const token of info.viewableItems) {
         if (
           token.item.itemType === 'message' &&
           messageKey(token.item.messageInfo) === this.state.focusedMessageKey
         ) {
           focusedMessageVisible = true;
           break;
         }
       }
       if (!focusedMessageVisible) {
         this.setState({ focusedMessageKey: null });
       }
     }
 
     const loader = _find({ key: 'loader' })(info.viewableItems);
     if (!loader || this.state.loadingFromScroll) {
       return;
     }
 
     this.setState({ loadingFromScroll: true });
     const { oldestMessageServerID } = this.props;
     const threadID = this.props.threadInfo.id;
 
-    (async () => {
+    void (async () => {
       try {
         if (oldestMessageServerID) {
           await this.props.dispatchActionPromise(
             fetchMessagesBeforeCursorActionTypes,
             this.props.fetchMessagesBeforeCursor({
               threadID,
               beforeMessageID: oldestMessageServerID,
             }),
           );
         } else {
           await this.props.dispatchActionPromise(
             fetchMostRecentMessagesActionTypes,
             this.props.fetchMostRecentMessages({ threadID }),
           );
         }
       } finally {
         this.setState({ loadingFromScroll: false });
       }
     })();
   };
 }
 
 registerFetchKey(fetchMessagesBeforeCursorActionTypes);
 registerFetchKey(fetchMostRecentMessagesActionTypes);
 
 const ConnectedMessageList: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedMessageList(props: BaseProps) {
     const keyboardState = React.useContext(KeyboardContext);
     const overlayContext = React.useContext(OverlayContext);
 
     const threadID = props.threadInfo.id;
     const startReached = useSelector(
       state =>
         !!(
           state.messageStore.threads[threadID] &&
           state.messageStore.threads[threadID].startReached
         ),
     );
 
     const styles = useStyles(unboundStyles);
     const indicatorStyle = useIndicatorStyle();
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callFetchMessagesBeforeCursor = useFetchMessagesBeforeCursor();
     const callFetchMostRecentMessages = useFetchMostRecentMessages();
 
     const oldestMessageServerID = useOldestMessageServerID(threadID);
 
     useWatchThread(props.threadInfo);
 
     return (
       <MessageList
         {...props}
         startReached={startReached}
         styles={styles}
         indicatorStyle={indicatorStyle}
         dispatchActionPromise={dispatchActionPromise}
         fetchMessagesBeforeCursor={callFetchMessagesBeforeCursor}
         fetchMostRecentMessages={callFetchMostRecentMessages}
         overlayContext={overlayContext}
         keyboardState={keyboardState}
         oldestMessageServerID={oldestMessageServerID}
       />
     );
   });
 
 export default ConnectedMessageList;
diff --git a/native/chat/message-report-utils.js b/native/chat/message-report-utils.js
index d7cd59a9e..2617e91cc 100644
--- a/native/chat/message-report-utils.js
+++ b/native/chat/message-report-utils.js
@@ -1,58 +1,61 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useSendMessageReport,
   sendMessageReportActionTypes,
 } from 'lib/actions/message-report-actions.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import { displayActionResultModal } from '../navigation/action-result-modal.js';
 import type { TooltipRoute } from '../tooltip/tooltip.react.js';
 import Alert from '../utils/alert.js';
 
 const confirmReport = () => displayActionResultModal('reported to admin');
 
 function useOnPressReport(
   route:
     | TooltipRoute<'TextMessageTooltipModal'>
     | TooltipRoute<'MultimediaMessageTooltipModal'>,
 ): () => mixed {
   const messageID = route.params.item.messageInfo.id;
   const dispatchActionPromise = useDispatchActionPromise();
   const callSendMessageReport = useSendMessageReport();
   return React.useCallback(() => {
     if (!messageID) {
       Alert.alert(
         'Couldn’t send the report',
         'Uhh... try again?',
         [{ text: 'OK' }],
         {
           cancelable: false,
         },
       );
       return;
     }
     const messageReportPromise = (async () => {
       try {
         const result = await callSendMessageReport({ messageID });
         confirmReport();
         return result;
       } catch (e) {
         Alert.alert(
           'Couldn’t send the report',
           'Uhh... try again?',
           [{ text: 'OK' }],
           {
             cancelable: false,
           },
         );
         throw e;
       }
     })();
-    dispatchActionPromise(sendMessageReportActionTypes, messageReportPromise);
+    void dispatchActionPromise(
+      sendMessageReportActionTypes,
+      messageReportPromise,
+    );
   }, [callSendMessageReport, messageID, dispatchActionPromise]);
 }
 
 export { useOnPressReport };
diff --git a/native/chat/message-results-screen.react.js b/native/chat/message-results-screen.react.js
index bdf49eabd..2a89749eb 100644
--- a/native/chat/message-results-screen.react.js
+++ b/native/chat/message-results-screen.react.js
@@ -1,195 +1,195 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View } from 'react-native';
 import { ScrollView } from 'react-native-gesture-handler';
 
 import { useFetchPinnedMessages } from 'lib/actions/message-actions.js';
 import {
   messageListData,
   type ChatMessageInfoItem,
 } from 'lib/selectors/chat-selectors.js';
 import {
   createMessageInfo,
   isInvalidPinSourceForThread,
 } from 'lib/shared/message-utils.js';
 import type { RawMessageInfo } from 'lib/types/message-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 
 import { useHeightMeasurer } from './chat-context.js';
 import type { ChatNavigationProp } from './chat.react';
 import type { NativeChatMessageItem } from './message-data.react.js';
 import MessageResult from './message-result.react.js';
 import type { NavigationRoute } from '../navigation/route-names';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 import type { ChatMessageItemWithHeight } from '../types/chat-types.js';
 import type { VerticalBounds } from '../types/layout-types.js';
 
 export type MessageResultsScreenParams = {
   +threadInfo: ThreadInfo,
 };
 
 type MessageResultsScreenProps = {
   +navigation: ChatNavigationProp<'MessageResultsScreen'>,
   +route: NavigationRoute<'MessageResultsScreen'>,
 };
 
 function MessageResultsScreen(props: MessageResultsScreenProps): React.Node {
   const { navigation, route } = props;
   const { threadInfo } = route.params;
   const styles = useStyles(unboundStyles);
   const { id: threadID } = threadInfo;
   const [rawMessageResults, setRawMessageResults] = React.useState<
     $ReadOnlyArray<RawMessageInfo>,
   >([]);
 
   const measureMessages = useHeightMeasurer();
   const [measuredMessages, setMeasuredMessages] = React.useState<
     $ReadOnlyArray<ChatMessageItemWithHeight>,
   >([]);
 
   const [messageVerticalBounds, setMessageVerticalBounds] =
     React.useState<?VerticalBounds>();
   const scrollViewContainerRef = React.useRef<?React.ElementRef<typeof View>>();
 
   const callFetchPinnedMessages = useFetchPinnedMessages();
   const userInfos = useSelector(state => state.userStore.userInfos);
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       const result = await callFetchPinnedMessages({ threadID });
       setRawMessageResults(result.pinnedMessages);
     })();
   }, [callFetchPinnedMessages, threadID]);
 
   const translatedMessageResults = React.useMemo(() => {
     const threadInfos = { [threadID]: threadInfo };
 
     return rawMessageResults
       .map(messageInfo =>
         createMessageInfo(messageInfo, null, userInfos, threadInfos),
       )
       .filter(Boolean);
   }, [rawMessageResults, userInfos, threadID, threadInfo]);
 
   const chatMessageInfos = useSelector(
     messageListData(threadInfo.id, translatedMessageResults),
   );
 
   const sortedUniqueChatMessageInfoItems: $ReadOnlyArray<NativeChatMessageItem> =
     React.useMemo(() => {
       if (!chatMessageInfos) {
         return [];
       }
 
       const chatMessageInfoItems = chatMessageInfos.filter(
         item =>
           item.itemType === 'message' &&
           item.isPinned &&
           !isInvalidPinSourceForThread(item.messageInfo, threadInfo),
       );
 
       // By the nature of using messageListData and passing in
       // the desired translatedMessageResults as additional
       // messages, we will have duplicate ChatMessageInfoItems.
       const uniqueChatMessageInfoItemsMap = new Map<
         string,
         ChatMessageInfoItem,
       >();
       chatMessageInfoItems.forEach(
         item =>
           item.messageInfo &&
           item.messageInfo.id &&
           uniqueChatMessageInfoItemsMap.set(item.messageInfo.id, item),
       );
 
       // Push the items in the order they appear in the rawMessageResults
       // since the messages fetched from the server are already sorted
       // in the order of pin_time (newest first).
       const sortedChatMessageInfoItems = [];
       for (let i = 0; i < rawMessageResults.length; i++) {
         const { id } = rawMessageResults[i];
         invariant(id, 'pinned message returned from server should have ID');
         sortedChatMessageInfoItems.push(uniqueChatMessageInfoItemsMap.get(id));
       }
 
       return sortedChatMessageInfoItems.filter(Boolean);
     }, [chatMessageInfos, rawMessageResults, threadInfo]);
 
   const measureCallback = React.useCallback(
     (listDataWithHeights: $ReadOnlyArray<ChatMessageItemWithHeight>) => {
       setMeasuredMessages(listDataWithHeights);
     },
     [],
   );
 
   React.useEffect(() => {
     measureMessages(
       sortedUniqueChatMessageInfoItems,
       threadInfo,
       measureCallback,
     );
   }, [
     measureCallback,
     measureMessages,
     sortedUniqueChatMessageInfoItems,
     threadInfo,
   ]);
 
   const onLayout = React.useCallback(() => {
     scrollViewContainerRef.current?.measure(
       (x, y, width, height, pageX, pageY) => {
         if (
           height === null ||
           height === undefined ||
           pageY === null ||
           pageY === undefined
         ) {
           return;
         }
 
         setMessageVerticalBounds({ height, y: pageY });
       },
     );
   }, []);
 
   const messageResultsToDisplay = React.useMemo(
     () =>
       measuredMessages.map(item => {
         invariant(item.itemType !== 'loader', 'should not be loader');
 
         return (
           <MessageResult
             key={item.messageInfo.id}
             item={item}
             threadInfo={threadInfo}
             navigation={navigation}
             route={route}
             messageVerticalBounds={messageVerticalBounds}
             scrollable={false}
           />
         );
       }),
     [measuredMessages, threadInfo, navigation, route, messageVerticalBounds],
   );
 
   return (
     <View
       ref={scrollViewContainerRef}
       onLayout={onLayout}
       style={styles.scrollViewContainer}
     >
       <ScrollView>{messageResultsToDisplay}</ScrollView>
     </View>
   );
 }
 
 const unboundStyles = {
   scrollViewContainer: {
     flex: 1,
   },
 };
 
 export default MessageResultsScreen;
diff --git a/native/chat/reaction-message-utils.js b/native/chat/reaction-message-utils.js
index 72192b595..e12b35161 100644
--- a/native/chat/reaction-message-utils.js
+++ b/native/chat/reaction-message-utils.js
@@ -1,207 +1,207 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   useSendReactionMessage,
   sendReactionMessageActionTypes,
 } from 'lib/actions/message-actions.js';
 import type { ReactionInfo } from 'lib/selectors/chat-selectors.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import type { RawReactionMessageInfo } from 'lib/types/messages/reaction.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { cloneError } from 'lib/utils/errors.js';
 
 import { useSelector } from '../redux/redux-utils.js';
 import type {
   LayoutCoordinates,
   VerticalBounds,
 } from '../types/layout-types.js';
 import Alert from '../utils/alert.js';
 
 function useSendReaction(
   messageID: ?string,
   localID: string,
   threadID: string,
   reactions: ReactionInfo,
 ): (reaction: string) => mixed {
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
 
   const callSendReactionMessage = useSendReactionMessage();
   const dispatchActionPromise = useDispatchActionPromise();
 
   return React.useCallback(
     reaction => {
       if (!messageID) {
         return;
       }
 
       invariant(viewerID, 'viewerID should be set');
 
       const viewerReacted = reactions[reaction]
         ? reactions[reaction].viewerReacted
         : false;
       const action = viewerReacted ? 'remove_reaction' : 'add_reaction';
 
       const reactionMessagePromise = (async () => {
         try {
           const result = await callSendReactionMessage({
             threadID,
             localID,
             targetMessageID: messageID,
             reaction,
             action,
           });
           return {
             localID,
             serverID: result.id,
             threadID,
             time: result.time,
             interface: result.interface,
           };
         } catch (e) {
           Alert.alert(
             'Couldn’t send the reaction',
             'Please try again later',
             [{ text: 'OK' }],
             {
               cancelable: true,
             },
           );
 
           const copy = cloneError(e);
           copy.localID = localID;
           copy.threadID = threadID;
           throw copy;
         }
       })();
 
       const startingPayload: RawReactionMessageInfo = {
         type: messageTypes.REACTION,
         threadID,
         localID,
         creatorID: viewerID,
         time: Date.now(),
         targetMessageID: messageID,
         reaction,
         action,
       };
 
-      dispatchActionPromise(
+      void dispatchActionPromise(
         sendReactionMessageActionTypes,
         reactionMessagePromise,
         undefined,
         startingPayload,
       );
     },
     [
       messageID,
       viewerID,
       reactions,
       threadID,
       localID,
       dispatchActionPromise,
       callSendReactionMessage,
     ],
   );
 }
 
 type ReactionSelectionPopoverPositionArgs = {
   +initialCoordinates: LayoutCoordinates,
   +verticalBounds: VerticalBounds,
   +margin: ?number,
 };
 
 type WritableContainerStyle = {
   position: 'absolute',
   left?: number,
   right?: number,
   bottom?: number,
   top?: number,
   ...
 };
 type ContainerStyle = $ReadOnly<WritableContainerStyle>;
 
 type ReactionSelectionPopoverPosition = {
   +containerStyle: ContainerStyle,
   +popoverLocation: 'above' | 'below',
 };
 function useReactionSelectionPopoverPosition({
   initialCoordinates,
   verticalBounds,
   margin,
 }: ReactionSelectionPopoverPositionArgs): ReactionSelectionPopoverPosition {
   const calculatedMargin = getCalculatedMargin(margin);
 
   const windowWidth = useSelector(state => state.dimensions.width);
 
   const popoverLocation: 'above' | 'below' = (() => {
     const { y, height } = initialCoordinates;
     const contentTop = y;
     const contentBottom = y + height;
     const boundsTop = verticalBounds.y;
     const boundsBottom = verticalBounds.y + verticalBounds.height;
 
     const fullHeight =
       reactionSelectionPopoverDimensions.height + calculatedMargin;
 
     if (
       contentBottom + fullHeight > boundsBottom &&
       contentTop - fullHeight > boundsTop
     ) {
       return 'above';
     }
 
     return 'below';
   })();
 
   const containerStyle = React.useMemo(() => {
     const { x, width, height } = initialCoordinates;
 
     const style: WritableContainerStyle = {
       position: 'absolute',
     };
 
     const extraLeftSpace = x;
     const extraRightSpace = windowWidth - width - x;
     if (extraLeftSpace < extraRightSpace) {
       style.left = 0;
     } else {
       style.right = 0;
     }
 
     if (popoverLocation === 'above') {
       style.bottom = height + calculatedMargin / 2;
     } else {
       style.top = height + calculatedMargin / 2;
     }
 
     return style;
   }, [calculatedMargin, initialCoordinates, popoverLocation, windowWidth]);
   return React.useMemo(
     () => ({
       popoverLocation,
       containerStyle,
     }),
     [popoverLocation, containerStyle],
   );
 }
 
 function getCalculatedMargin(margin: ?number): number {
   return margin ?? 16;
 }
 
 const reactionSelectionPopoverDimensions = {
   height: 56,
   width: 316,
 };
 
 export {
   useSendReaction,
   useReactionSelectionPopoverPosition,
   getCalculatedMargin,
   reactionSelectionPopoverDimensions,
 };
diff --git a/native/chat/settings/add-users-modal.react.js b/native/chat/settings/add-users-modal.react.js
index cd0ab539b..ef90e5700 100644
--- a/native/chat/settings/add-users-modal.react.js
+++ b/native/chat/settings/add-users-modal.react.js
@@ -1,299 +1,302 @@
 // @flow
 
 import * as React from 'react';
 import { View, Text, ActivityIndicator } from 'react-native';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from 'lib/actions/thread-actions.js';
 import { useENSNames } from 'lib/hooks/ens-cache.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import {
   userInfoSelectorForPotentialMembers,
   userSearchIndexForPotentialMembers,
 } from 'lib/selectors/user-selectors.js';
 import { getPotentialMemberItems } from 'lib/shared/search-utils.js';
 import { threadActualMembers } from 'lib/shared/thread-utils.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import { type AccountUserInfo } from 'lib/types/user-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import Button from '../../components/button.react.js';
 import Modal from '../../components/modal.react.js';
 import {
   createTagInput,
   type BaseTagInput,
 } from '../../components/tag-input.react.js';
 import UserList from '../../components/user-list.react.js';
 import type { RootNavigationProp } from '../../navigation/root-navigator.react.js';
 import type { NavigationRoute } from '../../navigation/route-names.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { useStyles } from '../../themes/colors.js';
 import Alert from '../../utils/alert.js';
 
 const TagInput = createTagInput<AccountUserInfo>();
 
 const tagInputProps = {
   placeholder: 'Select users to add',
   autoFocus: true,
   returnKeyType: 'go',
 };
 
 const tagDataLabelExtractor = (userInfo: AccountUserInfo) => userInfo.username;
 
 export type AddUsersModalParams = {
   +presentedFrom: string,
   +threadInfo: ThreadInfo,
 };
 
 type Props = {
   +navigation: RootNavigationProp<'AddUsersModal'>,
   +route: NavigationRoute<'AddUsersModal'>,
 };
 function AddUsersModal(props: Props): React.Node {
   const [usernameInputText, setUsernameInputText] = React.useState<string>('');
   const [userInfoInputArray, setUserInfoInputArray] = React.useState<
     $ReadOnlyArray<AccountUserInfo>,
   >([]);
 
   const tagInputRef = React.useRef<?BaseTagInput<AccountUserInfo>>();
   const onUnknownErrorAlertAcknowledged = React.useCallback(() => {
     setUsernameInputText('');
     setUserInfoInputArray([]);
     tagInputRef.current?.focus();
   }, []);
 
   const { navigation } = props;
   const { goBackOnce } = navigation;
   const close = React.useCallback(() => {
     goBackOnce();
   }, [goBackOnce]);
 
   const callChangeThreadSettings = useChangeThreadSettings();
   const userInfoInputIDs = userInfoInputArray.map(userInfo => userInfo.id);
   const { route } = props;
   const { threadInfo } = route.params;
   const threadID = threadInfo.id;
   const addUsersToThread = React.useCallback(async () => {
     try {
       const result = await callChangeThreadSettings({
         threadID: threadID,
         changes: { newMemberIDs: userInfoInputIDs },
       });
       close();
       return result;
     } catch (e) {
       Alert.alert(
         'Unknown error',
         'Uhh... try again?',
         [{ text: 'OK', onPress: onUnknownErrorAlertAcknowledged }],
         { cancelable: false },
       );
       throw e;
     }
   }, [
     callChangeThreadSettings,
     threadID,
     userInfoInputIDs,
     close,
     onUnknownErrorAlertAcknowledged,
   ]);
 
   const inputLength = userInfoInputArray.length;
   const dispatchActionPromise = useDispatchActionPromise();
   const userInfoInputArrayEmpty = inputLength === 0;
   const onPressAdd = React.useCallback(() => {
     if (userInfoInputArrayEmpty) {
       return;
     }
-    dispatchActionPromise(changeThreadSettingsActionTypes, addUsersToThread());
+    void dispatchActionPromise(
+      changeThreadSettingsActionTypes,
+      addUsersToThread(),
+    );
   }, [userInfoInputArrayEmpty, dispatchActionPromise, addUsersToThread]);
 
   const changeThreadSettingsLoadingStatus = useSelector(
     createLoadingStatusSelector(changeThreadSettingsActionTypes),
   );
   const isLoading = changeThreadSettingsLoadingStatus === 'loading';
 
   const styles = useStyles(unboundStyles);
 
   let addButton = null;
   if (inputLength > 0) {
     let activityIndicator = null;
     if (isLoading) {
       activityIndicator = (
         <View style={styles.activityIndicator}>
           <ActivityIndicator color="white" />
         </View>
       );
     }
     const addButtonText = `Add (${inputLength})`;
     addButton = (
       <Button
         onPress={onPressAdd}
         style={styles.addButton}
         disabled={isLoading}
       >
         {activityIndicator}
         <Text style={styles.addText}>{addButtonText}</Text>
       </Button>
     );
   }
 
   let cancelButton;
   if (!isLoading) {
     cancelButton = (
       <Button onPress={close} style={styles.cancelButton}>
         <Text style={styles.cancelText}>Cancel</Text>
       </Button>
     );
   } else {
     cancelButton = <View />;
   }
 
   const threadMemberIDs = React.useMemo(
     () => threadActualMembers(threadInfo.members),
     [threadInfo.members],
   );
   const excludeUserIDs = React.useMemo(
     () => userInfoInputIDs.concat(threadMemberIDs),
     [userInfoInputIDs, threadMemberIDs],
   );
 
   const otherUserInfos = useSelector(userInfoSelectorForPotentialMembers);
   const userSearchIndex = useSelector(userSearchIndexForPotentialMembers);
   const { parentThreadID, community } = props.route.params.threadInfo;
   const parentThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
   const communityThreadInfo = useSelector(state =>
     community ? threadInfoSelector(state)[community] : null,
   );
   const userSearchResults = React.useMemo(
     () =>
       getPotentialMemberItems({
         text: usernameInputText,
         userInfos: otherUserInfos,
         searchIndex: userSearchIndex,
         excludeUserIDs,
         inputParentThreadInfo: parentThreadInfo,
         inputCommunityThreadInfo: communityThreadInfo,
         threadType: threadInfo.type,
       }),
     [
       usernameInputText,
       otherUserInfos,
       userSearchIndex,
       excludeUserIDs,
       parentThreadInfo,
       communityThreadInfo,
       threadInfo.type,
     ],
   );
 
   const onChangeTagInput = React.useCallback(
     (newUserInfoInputArray: $ReadOnlyArray<AccountUserInfo>) => {
       if (!isLoading) {
         setUserInfoInputArray(newUserInfoInputArray);
       }
     },
     [isLoading],
   );
 
   const onChangeTagInputText = React.useCallback(
     (text: string) => {
       if (!isLoading) {
         setUsernameInputText(text);
       }
     },
     [isLoading],
   );
 
   const onUserSelect = React.useCallback(
     ({ id }: AccountUserInfo) => {
       if (isLoading) {
         return;
       }
       if (userInfoInputIDs.some(existingUserID => id === existingUserID)) {
         return;
       }
       setUserInfoInputArray(oldUserInfoInputArray => [
         ...oldUserInfoInputArray,
         otherUserInfos[id],
       ]);
       setUsernameInputText('');
     },
     [isLoading, userInfoInputIDs, otherUserInfos],
   );
 
   const inputProps = React.useMemo(
     () => ({
       ...tagInputProps,
       onSubmitEditing: onPressAdd,
     }),
     [onPressAdd],
   );
   const userSearchResultWithENSNames = useENSNames(userSearchResults);
   const userInfoInputArrayWithENSNames = useENSNames(userInfoInputArray);
   return (
     <Modal>
       <TagInput
         value={userInfoInputArrayWithENSNames}
         onChange={onChangeTagInput}
         text={usernameInputText}
         onChangeText={onChangeTagInputText}
         labelExtractor={tagDataLabelExtractor}
         defaultInputWidth={160}
         maxHeight={36}
         inputProps={inputProps}
         ref={tagInputRef}
       />
       <UserList
         userInfos={userSearchResultWithENSNames}
         onSelect={onUserSelect}
       />
       <View style={styles.buttons}>
         {cancelButton}
         {addButton}
       </View>
     </Modal>
   );
 }
 
 const unboundStyles = {
   activityIndicator: {
     paddingRight: 6,
   },
   addButton: {
     backgroundColor: 'vibrantGreenButton',
     borderRadius: 3,
     flexDirection: 'row',
     paddingHorizontal: 10,
     paddingVertical: 4,
   },
   addText: {
     color: 'white',
     fontSize: 18,
   },
   buttons: {
     flexDirection: 'row',
     justifyContent: 'space-between',
     marginTop: 12,
   },
   cancelButton: {
     backgroundColor: 'modalButton',
     borderRadius: 3,
     paddingHorizontal: 10,
     paddingVertical: 4,
   },
   cancelText: {
     color: 'modalButtonLabel',
     fontSize: 18,
   },
 };
 
 const MemoizedAddUsersModal: React.ComponentType<Props> =
   React.memo<Props>(AddUsersModal);
 
 export default MemoizedAddUsersModal;
diff --git a/native/chat/settings/color-selector-modal.react.js b/native/chat/settings/color-selector-modal.react.js
index 4e80c0a43..0b7c85604 100644
--- a/native/chat/settings/color-selector-modal.react.js
+++ b/native/chat/settings/color-selector-modal.react.js
@@ -1,190 +1,190 @@
 // @flow
 
 import Icon from '@expo/vector-icons/FontAwesome.js';
 import * as React from 'react';
 import { TouchableHighlight } from 'react-native';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from 'lib/actions/thread-actions.js';
 import {
   type ChangeThreadSettingsPayload,
   type UpdateThreadRequest,
   type ThreadInfo,
 } from 'lib/types/thread-types.js';
 import type { DispatchActionPromise } from 'lib/utils/action-utils.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import ColorSelector from '../../components/color-selector.react.js';
 import Modal from '../../components/modal.react.js';
 import type { RootNavigationProp } from '../../navigation/root-navigator.react.js';
 import type { NavigationRoute } from '../../navigation/route-names.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { type Colors, useStyles, useColors } from '../../themes/colors.js';
 import Alert from '../../utils/alert.js';
 
 export type ColorSelectorModalParams = {
   +presentedFrom: string,
   +color: string,
   +threadInfo: ThreadInfo,
   +setColor: (color: string) => void,
 };
 
 const unboundStyles = {
   closeButton: {
     borderRadius: 3,
     height: 18,
     position: 'absolute',
     right: 5,
     top: 5,
     width: 18,
   },
   closeButtonIcon: {
     color: 'modalBackgroundSecondaryLabel',
     left: 3,
     position: 'absolute',
   },
   colorSelector: {
     bottom: 10,
     left: 10,
     position: 'absolute',
     right: 10,
     top: 10,
   },
   colorSelectorContainer: {
     backgroundColor: 'modalBackground',
     borderRadius: 5,
     flex: 0,
     marginHorizontal: 15,
     marginVertical: 20,
   },
 };
 
 type BaseProps = {
   +navigation: RootNavigationProp<'ColorSelectorModal'>,
   +route: NavigationRoute<'ColorSelectorModal'>,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   +windowWidth: number,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +changeThreadSettings: (
     request: UpdateThreadRequest,
   ) => Promise<ChangeThreadSettingsPayload>,
 };
 function ColorSelectorModal(props: Props): React.Node {
   const {
     changeThreadSettings: updateThreadSettings,
     dispatchActionPromise,
     windowWidth,
   } = props;
   const { threadInfo, setColor } = props.route.params;
 
   const close = props.navigation.goBackOnce;
 
   const onErrorAcknowledged = React.useCallback(() => {
     setColor(threadInfo.color);
   }, [setColor, threadInfo.color]);
 
   const editColor = React.useCallback(
     async (newColor: string) => {
       const threadID = threadInfo.id;
       try {
         return await updateThreadSettings({
           threadID,
           changes: { color: newColor },
         });
       } catch (e) {
         Alert.alert(
           'Unknown error',
           'Uhh... try again?',
           [{ text: 'OK', onPress: onErrorAcknowledged }],
           { cancelable: false },
         );
         throw e;
       }
     },
     [onErrorAcknowledged, threadInfo.id, updateThreadSettings],
   );
 
   const onColorSelected = React.useCallback(
     (color: string) => {
       const colorEditValue = color.substr(1);
       setColor(colorEditValue);
       close();
 
       const action = changeThreadSettingsActionTypes.started;
       const threadID = props.route.params.threadInfo.id;
-      dispatchActionPromise(
+      void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         editColor(colorEditValue),
         {
           customKeyName: `${action}:${threadID}:color`,
         },
       );
     },
     [
       setColor,
       close,
       dispatchActionPromise,
       editColor,
       props.route.params.threadInfo.id,
     ],
   );
 
   const { colorSelectorContainer, closeButton, closeButtonIcon } = props.styles;
   // Based on the assumption we are always in portrait,
   // and consequently width is the lowest dimensions
   const modalStyle = React.useMemo(
     () => [colorSelectorContainer, { height: 0.75 * windowWidth }],
     [colorSelectorContainer, windowWidth],
   );
 
   const { modalIosHighlightUnderlay } = props.colors;
   const { color } = props.route.params;
   return (
     <Modal modalStyle={modalStyle}>
       <ColorSelector
         currentColor={color}
         windowWidth={windowWidth}
         onColorSelected={onColorSelected}
       />
       <TouchableHighlight
         onPress={close}
         style={closeButton}
         underlayColor={modalIosHighlightUnderlay}
       >
         <Icon name="close" size={16} style={closeButtonIcon} />
       </TouchableHighlight>
     </Modal>
   );
 }
 
 const ConnectedColorSelectorModal: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedColorSelectorModal(props: BaseProps) {
     const styles = useStyles(unboundStyles);
     const colors = useColors();
     const windowWidth = useSelector(state => state.dimensions.width);
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callChangeThreadSettings = useChangeThreadSettings();
 
     return (
       <ColorSelectorModal
         {...props}
         styles={styles}
         colors={colors}
         windowWidth={windowWidth}
         dispatchActionPromise={dispatchActionPromise}
         changeThreadSettings={callChangeThreadSettings}
       />
     );
   });
 
 export default ConnectedColorSelectorModal;
diff --git a/native/chat/settings/delete-thread.react.js b/native/chat/settings/delete-thread.react.js
index 8f0b35726..fc5599dc4 100644
--- a/native/chat/settings/delete-thread.react.js
+++ b/native/chat/settings/delete-thread.react.js
@@ -1,293 +1,293 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   Text,
   View,
   TextInput as BaseTextInput,
   ActivityIndicator,
 } from 'react-native';
 import { ScrollView } from 'react-native-gesture-handler';
 
 import {
   deleteThreadActionTypes,
   useDeleteThread,
 } from 'lib/actions/thread-actions.js';
 import type { DeleteThreadInput } from 'lib/actions/thread-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import {
   threadInfoSelector,
   containedThreadInfos,
 } from 'lib/selectors/thread-selectors.js';
 import {
   identifyInvalidatedThreads,
   getThreadsToDeleteText,
 } from 'lib/shared/thread-utils.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type {
   LeaveThreadPayload,
   ThreadInfo,
   ResolvedThreadInfo,
 } from 'lib/types/thread-types.js';
 import {
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { useResolvedThreadInfo } from 'lib/utils/entity-helpers.js';
 
 import Button from '../../components/button.react.js';
 import { clearThreadsActionType } from '../../navigation/action-types.js';
 import {
   NavContext,
   type NavAction,
 } from '../../navigation/navigation-context.js';
 import type { NavigationRoute } from '../../navigation/route-names.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { type Colors, useColors, useStyles } from '../../themes/colors.js';
 import Alert from '../../utils/alert.js';
 import type { ChatNavigationProp } from '../chat.react.js';
 
 export type DeleteThreadParams = {
   +threadInfo: ThreadInfo,
 };
 
 const unboundStyles = {
   deleteButton: {
     backgroundColor: 'vibrantRedButton',
     borderRadius: 5,
     flex: 1,
     marginHorizontal: 24,
     marginVertical: 12,
     padding: 12,
   },
   deleteText: {
     color: 'white',
     fontSize: 18,
     textAlign: 'center',
   },
   header: {
     color: 'panelBackgroundLabel',
     fontSize: 12,
     fontWeight: '400',
     paddingBottom: 3,
     paddingHorizontal: 24,
   },
   input: {
     color: 'panelForegroundLabel',
     flex: 1,
     fontFamily: 'Arial',
     fontSize: 16,
     paddingVertical: 0,
     borderBottomColor: 'transparent',
   },
   scrollView: {
     backgroundColor: 'panelBackground',
   },
   scrollViewContentContainer: {
     paddingTop: 24,
   },
   section: {
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     borderTopWidth: 1,
     flexDirection: 'row',
     justifyContent: 'space-between',
     marginBottom: 24,
     paddingHorizontal: 24,
     paddingVertical: 12,
   },
   warningText: {
     color: 'panelForegroundLabel',
     fontSize: 16,
     marginBottom: 24,
     marginHorizontal: 24,
     textAlign: 'center',
   },
 };
 
 type BaseProps = {
   +navigation: ChatNavigationProp<'DeleteThread'>,
   +route: NavigationRoute<'DeleteThread'>,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +threadInfo: ResolvedThreadInfo,
   +shouldUseDeleteConfirmationAlert: boolean,
   +loadingStatus: LoadingStatus,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +deleteThread: (input: DeleteThreadInput) => Promise<LeaveThreadPayload>,
   // withNavContext
   +navDispatch: (action: NavAction) => void,
 };
 class DeleteThread extends React.PureComponent<Props> {
   mounted = false;
   passwordInput: ?React.ElementRef<typeof BaseTextInput>;
 
   componentDidMount() {
     this.mounted = true;
   }
 
   componentWillUnmount() {
     this.mounted = false;
   }
 
   render(): React.Node {
     const buttonContent =
       this.props.loadingStatus === 'loading' ? (
         <ActivityIndicator size="small" color="white" />
       ) : (
         <Text style={this.props.styles.deleteText}>Delete chat</Text>
       );
     const { threadInfo } = this.props;
     return (
       <ScrollView
         contentContainerStyle={this.props.styles.scrollViewContentContainer}
         style={this.props.styles.scrollView}
       >
         <View>
           <Text style={this.props.styles.warningText}>
             {`The chat "${threadInfo.uiName}" will be permanently deleted. `}
             There is no way to reverse this.
           </Text>
         </View>
         <Button
           onPress={this.submitDeletion}
           style={this.props.styles.deleteButton}
         >
           {buttonContent}
         </Button>
       </ScrollView>
     );
   }
 
   passwordInputRef = (
     passwordInput: ?React.ElementRef<typeof BaseTextInput>,
   ) => {
     this.passwordInput = passwordInput;
   };
 
   focusPasswordInput = () => {
     invariant(this.passwordInput, 'passwordInput should be set');
     this.passwordInput.focus();
   };
 
   dispatchDeleteThreadAction = () => {
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       deleteThreadActionTypes,
       this.deleteThread(),
     );
   };
 
   submitDeletion = () => {
     if (!this.props.shouldUseDeleteConfirmationAlert) {
       this.dispatchDeleteThreadAction();
       return;
     }
     Alert.alert(
       'Warning',
       `${getThreadsToDeleteText(
         this.props.threadInfo,
       )} will also be permanently deleted.`,
       [
         { text: 'Cancel', style: 'cancel' },
         { text: 'Continue', onPress: this.dispatchDeleteThreadAction },
       ],
       { cancelable: false },
     );
   };
 
   async deleteThread(): Promise<LeaveThreadPayload> {
     const { threadInfo, navDispatch } = this.props;
     navDispatch({
       type: clearThreadsActionType,
       payload: { threadIDs: [threadInfo.id] },
     });
     try {
       const result = await this.props.deleteThread({ threadID: threadInfo.id });
       const invalidated = identifyInvalidatedThreads(
         result.updatesResult.newUpdates,
       );
       navDispatch({
         type: clearThreadsActionType,
         payload: { threadIDs: [...invalidated] },
       });
       return result;
     } catch (e) {
       if (e.message === 'invalid_credentials') {
         Alert.alert(
           'Permission not granted',
           'You do not have permission to delete this thread',
           [{ text: 'OK' }],
           { cancelable: false },
         );
       } else {
         Alert.alert('Unknown error', 'Uhh... try again?', [{ text: 'OK' }], {
           cancelable: false,
         });
       }
       throw e;
     }
   }
 }
 
 const loadingStatusSelector = createLoadingStatusSelector(
   deleteThreadActionTypes,
 );
 
 const ConnectedDeleteThread: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedDeleteThread(props: BaseProps) {
     const threadID = props.route.params.threadInfo.id;
     const reduxThreadInfo = useSelector(
       state => threadInfoSelector(state)[threadID],
     );
     const reduxContainedThreadInfos = useSelector(
       state => containedThreadInfos(state)[threadID],
     );
 
     const { setParams } = props.navigation;
     React.useEffect(() => {
       if (reduxThreadInfo) {
         setParams({ threadInfo: reduxThreadInfo });
       }
     }, [reduxThreadInfo, setParams]);
     const threadInfo = reduxThreadInfo ?? props.route.params.threadInfo;
     const resolvedThreadInfo = useResolvedThreadInfo(threadInfo);
 
     const loadingStatus = useSelector(loadingStatusSelector);
 
     const colors = useColors();
     const styles = useStyles(unboundStyles);
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callDeleteThread = useDeleteThread();
 
     const navContext = React.useContext(NavContext);
     invariant(navContext, 'NavContext should be set in DeleteThread');
     const navDispatch = navContext.dispatch;
 
     const shouldUseDeleteConfirmationAlert =
       reduxContainedThreadInfos && reduxContainedThreadInfos.length > 0;
 
     return (
       <DeleteThread
         {...props}
         threadInfo={resolvedThreadInfo}
         shouldUseDeleteConfirmationAlert={shouldUseDeleteConfirmationAlert}
         loadingStatus={loadingStatus}
         colors={colors}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         deleteThread={callDeleteThread}
         navDispatch={navDispatch}
       />
     );
   });
 
 export default ConnectedDeleteThread;
diff --git a/native/chat/settings/thread-settings-description.react.js b/native/chat/settings/thread-settings-description.react.js
index 71d357a5d..e50ddb840 100644
--- a/native/chat/settings/thread-settings-description.react.js
+++ b/native/chat/settings/thread-settings-description.react.js
@@ -1,324 +1,324 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   Text,
   ActivityIndicator,
   TextInput as BaseTextInput,
   View,
 } from 'react-native';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from 'lib/actions/thread-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { threadHasPermission } from 'lib/shared/thread-utils.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import {
   type ChangeThreadSettingsPayload,
   type UpdateThreadRequest,
   type ThreadInfo,
 } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import SaveSettingButton from './save-setting-button.react.js';
 import {
   ThreadSettingsCategoryHeader,
   ThreadSettingsCategoryFooter,
 } from './thread-settings-category.react.js';
 import Button from '../../components/button.react.js';
 import EditSettingButton from '../../components/edit-setting-button.react.js';
 import SWMansionIcon from '../../components/swmansion-icon.react.js';
 import TextInput from '../../components/text-input.react.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { type Colors, useStyles, useColors } from '../../themes/colors.js';
 import type {
   LayoutEvent,
   ContentSizeChangeEvent,
 } from '../../types/react-native.js';
 import Alert from '../../utils/alert.js';
 
 const unboundStyles = {
   addDescriptionButton: {
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 10,
   },
   addDescriptionText: {
     color: 'panelForegroundTertiaryLabel',
     flex: 1,
     fontSize: 16,
   },
   editIcon: {
     color: 'panelForegroundTertiaryLabel',
     paddingLeft: 10,
     textAlign: 'right',
   },
   outlineCategory: {
     backgroundColor: 'panelForeground',
     borderColor: 'panelForegroundBorder',
     borderRadius: 1,
     borderStyle: 'dashed',
     borderWidth: 1,
     marginLeft: -1,
     marginRight: -1,
   },
   row: {
     backgroundColor: 'panelForeground',
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 4,
   },
   text: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontFamily: 'Arial',
     fontSize: 16,
     margin: 0,
     padding: 0,
     borderBottomColor: 'transparent',
   },
 };
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
   +descriptionEditValue: ?string,
   +setDescriptionEditValue: (value: ?string, callback?: () => void) => void,
   +descriptionTextHeight: ?number,
   +setDescriptionTextHeight: (number: number) => void,
   +canChangeSettings: boolean,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +loadingStatus: LoadingStatus,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +changeThreadSettings: (
     update: UpdateThreadRequest,
   ) => Promise<ChangeThreadSettingsPayload>,
 };
 class ThreadSettingsDescription extends React.PureComponent<Props> {
   textInput: ?React.ElementRef<typeof BaseTextInput>;
 
   render(): React.Node {
     if (
       this.props.descriptionEditValue !== null &&
       this.props.descriptionEditValue !== undefined
     ) {
       const textInputStyle: { height?: number } = {};
       if (
         this.props.descriptionTextHeight !== undefined &&
         this.props.descriptionTextHeight !== null
       ) {
         textInputStyle.height = this.props.descriptionTextHeight;
       }
       return (
         <View>
           <ThreadSettingsCategoryHeader type="full" title="Description" />
           <View style={this.props.styles.row}>
             <TextInput
               style={[this.props.styles.text, textInputStyle]}
               value={this.props.descriptionEditValue}
               onChangeText={this.props.setDescriptionEditValue}
               multiline={true}
               autoFocus={true}
               selectTextOnFocus={true}
               onBlur={this.onSubmit}
               editable={this.props.loadingStatus !== 'loading'}
               onContentSizeChange={this.onTextInputContentSizeChange}
               ref={this.textInputRef}
               selectionColor={`#${this.props.threadInfo.color}`}
             />
             {this.renderButton()}
           </View>
           <ThreadSettingsCategoryFooter type="full" />
         </View>
       );
     }
 
     if (this.props.threadInfo.description) {
       return (
         <View>
           <ThreadSettingsCategoryHeader type="full" title="Description" />
           <View style={this.props.styles.row}>
             <Text style={this.props.styles.text} onLayout={this.onLayoutText}>
               {this.props.threadInfo.description}
             </Text>
             {this.renderButton()}
           </View>
           <ThreadSettingsCategoryFooter type="full" />
         </View>
       );
     }
 
     const canEditThreadDescription = threadHasPermission(
       this.props.threadInfo,
       threadPermissions.EDIT_THREAD_DESCRIPTION,
     );
     const { panelIosHighlightUnderlay } = this.props.colors;
     if (canEditThreadDescription) {
       return (
         <View>
           <ThreadSettingsCategoryHeader type="outline" title="Description" />
           <View style={this.props.styles.outlineCategory}>
             <Button
               onPress={this.onPressEdit}
               style={this.props.styles.addDescriptionButton}
               iosFormat="highlight"
               iosHighlightUnderlayColor={panelIosHighlightUnderlay}
               iosActiveOpacity={0.85}
             >
               <Text style={this.props.styles.addDescriptionText}>
                 Add a description...
               </Text>
               <SWMansionIcon
                 name="edit-1"
                 size={20}
                 style={this.props.styles.editIcon}
               />
             </Button>
           </View>
           <ThreadSettingsCategoryFooter type="outline" />
         </View>
       );
     }
 
     return null;
   }
 
   renderButton(): React.Node {
     if (this.props.loadingStatus === 'loading') {
       return (
         <ActivityIndicator
           size="small"
           color={this.props.colors.panelForegroundSecondaryLabel}
         />
       );
     } else if (
       this.props.descriptionEditValue === null ||
       this.props.descriptionEditValue === undefined
     ) {
       return (
         <EditSettingButton
           onPress={this.onPressEdit}
           canChangeSettings={this.props.canChangeSettings}
         />
       );
     }
     return <SaveSettingButton onPress={this.onSubmit} />;
   }
 
   textInputRef = (textInput: ?React.ElementRef<typeof BaseTextInput>) => {
     this.textInput = textInput;
   };
 
   onLayoutText = (event: LayoutEvent) => {
     this.props.setDescriptionTextHeight(event.nativeEvent.layout.height);
   };
 
   onTextInputContentSizeChange = (event: ContentSizeChangeEvent) => {
     this.props.setDescriptionTextHeight(event.nativeEvent.contentSize.height);
   };
 
   onPressEdit = () => {
     this.props.setDescriptionEditValue(this.props.threadInfo.description);
   };
 
   onSubmit = () => {
     invariant(
       this.props.descriptionEditValue !== null &&
         this.props.descriptionEditValue !== undefined,
       'should be set',
     );
     const description = this.props.descriptionEditValue.trim();
 
     if (description === this.props.threadInfo.description) {
       this.props.setDescriptionEditValue(null);
       return;
     }
 
     const editDescriptionPromise = this.editDescription(description);
     const action = changeThreadSettingsActionTypes.started;
     const threadID = this.props.threadInfo.id;
 
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       changeThreadSettingsActionTypes,
       editDescriptionPromise,
       {
         customKeyName: `${action}:${threadID}:description`,
       },
     );
-    editDescriptionPromise.then(() => {
+    void editDescriptionPromise.then(() => {
       this.props.setDescriptionEditValue(null);
     });
   };
 
   async editDescription(
     newDescription: string,
   ): Promise<ChangeThreadSettingsPayload> {
     try {
       return await this.props.changeThreadSettings({
         threadID: this.props.threadInfo.id,
         changes: { description: newDescription },
       });
     } catch (e) {
       Alert.alert(
         'Unknown error',
         'Uhh... try again?',
         [{ text: 'OK', onPress: this.onErrorAcknowledged }],
         { cancelable: false },
       );
       throw e;
     }
   }
 
   onErrorAcknowledged = () => {
     this.props.setDescriptionEditValue(
       this.props.threadInfo.description,
       () => {
         invariant(this.textInput, 'textInput should be set');
         this.textInput.focus();
       },
     );
   };
 }
 
 const ConnectedThreadSettingsDescription: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedThreadSettingsDescription(
     props: BaseProps,
   ) {
     const threadID = props.threadInfo.id;
     const loadingStatus = useSelector(
       createLoadingStatusSelector(
         changeThreadSettingsActionTypes,
         `${changeThreadSettingsActionTypes.started}:${threadID}:description`,
       ),
     );
     const colors = useColors();
     const styles = useStyles(unboundStyles);
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callChangeThreadSettings = useChangeThreadSettings();
     return (
       <ThreadSettingsDescription
         {...props}
         loadingStatus={loadingStatus}
         colors={colors}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         changeThreadSettings={callChangeThreadSettings}
       />
     );
   });
 
 export default ConnectedThreadSettingsDescription;
diff --git a/native/chat/settings/thread-settings-edit-relationship.react.js b/native/chat/settings/thread-settings-edit-relationship.react.js
index 8dbce795c..6ed8fd770 100644
--- a/native/chat/settings/thread-settings-edit-relationship.react.js
+++ b/native/chat/settings/thread-settings-edit-relationship.react.js
@@ -1,129 +1,129 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import {
   updateRelationships as serverUpdateRelationships,
   updateRelationshipsActionTypes,
 } from 'lib/actions/relationship-actions.js';
 import { useENSNames } from 'lib/hooks/ens-cache.js';
 import {
   getRelationshipActionText,
   getRelationshipDispatchAction,
 } from 'lib/shared/relationship-utils.js';
 import { getSingleOtherUser } from 'lib/shared/thread-utils.js';
 import {
   type RelationshipAction,
   type RelationshipButton,
 } from 'lib/types/relationship-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 
 import Button from '../../components/button.react.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { useStyles, useColors } from '../../themes/colors.js';
 import type { ViewStyle } from '../../types/styles.js';
 import Alert from '../../utils/alert.js';
 
 type Props = {
   +threadInfo: ThreadInfo,
   +buttonStyle: ViewStyle,
   +relationshipButton: RelationshipButton,
 };
 
 const ThreadSettingsEditRelationship: React.ComponentType<Props> =
   React.memo<Props>(function ThreadSettingsEditRelationship(props: Props) {
     const otherUserInfoFromRedux = useSelector(state => {
       const currentUserID = state.currentUserInfo?.id;
       const otherUserID = getSingleOtherUser(props.threadInfo, currentUserID);
       invariant(otherUserID, 'Other user should be specified');
 
       const { userInfos } = state.userStore;
       return userInfos[otherUserID];
     });
     invariant(otherUserInfoFromRedux, 'Other user info should be specified');
 
     const [otherUserInfo] = useENSNames([otherUserInfoFromRedux]);
 
     const callUpdateRelationships = useServerCall(serverUpdateRelationships);
     const updateRelationship = React.useCallback(
       async (action: RelationshipAction) => {
         try {
           return await callUpdateRelationships({
             action,
             userIDs: [otherUserInfo.id],
           });
         } catch (e) {
           Alert.alert('Unknown error', 'Uhh... try again?', [{ text: 'OK' }], {
             cancelable: true,
           });
           throw e;
         }
       },
       [callUpdateRelationships, otherUserInfo],
     );
 
     const { relationshipButton } = props;
     const relationshipAction = React.useMemo(
       () => getRelationshipDispatchAction(relationshipButton),
       [relationshipButton],
     );
 
     const dispatchActionPromise = useDispatchActionPromise();
     const onButtonPress = React.useCallback(() => {
-      dispatchActionPromise(
+      void dispatchActionPromise(
         updateRelationshipsActionTypes,
         updateRelationship(relationshipAction),
       );
     }, [dispatchActionPromise, relationshipAction, updateRelationship]);
 
     const colors = useColors();
     const { panelIosHighlightUnderlay } = colors;
 
     const styles = useStyles(unboundStyles);
     const otherUserInfoUsername = otherUserInfo.username;
     invariant(otherUserInfoUsername, 'Other user username should be specified');
 
     const relationshipButtonText = React.useMemo(
       () =>
         getRelationshipActionText(relationshipButton, otherUserInfoUsername),
       [otherUserInfoUsername, relationshipButton],
     );
 
     return (
       <View style={styles.container}>
         <Button
           onPress={onButtonPress}
           style={[styles.button, props.buttonStyle]}
           iosFormat="highlight"
           iosHighlightUnderlayColor={panelIosHighlightUnderlay}
         >
           <Text style={styles.text}>{relationshipButtonText}</Text>
         </Button>
       </View>
     );
   });
 
 const unboundStyles = {
   button: {
     flexDirection: 'row',
     paddingHorizontal: 12,
     paddingVertical: 10,
   },
   container: {
     backgroundColor: 'panelForeground',
     paddingHorizontal: 12,
   },
   text: {
     color: 'redText',
     flex: 1,
     fontSize: 16,
   },
 };
 
 export default ThreadSettingsEditRelationship;
diff --git a/native/chat/settings/thread-settings-home-notifs.react.js b/native/chat/settings/thread-settings-home-notifs.react.js
index 0bf750649..15bbebae6 100644
--- a/native/chat/settings/thread-settings-home-notifs.react.js
+++ b/native/chat/settings/thread-settings-home-notifs.react.js
@@ -1,116 +1,116 @@
 // @flow
 
 import * as React from 'react';
 import { View, Switch } from 'react-native';
 
 import {
   updateSubscriptionActionTypes,
   useUpdateSubscription,
 } from 'lib/actions/user-actions.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 } from 'lib/utils/action-utils.js';
 
 import SingleLine from '../../components/single-line.react.js';
 import { useStyles } from '../../themes/colors.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,
   },
 };
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +updateSubscription: (
     subscriptionUpdate: SubscriptionUpdateRequest,
   ) => Promise<SubscriptionUpdateResult>,
 };
 type State = {
   +currentValue: boolean,
 };
 class ThreadSettingsHomeNotifs extends React.PureComponent<Props, State> {
   constructor(props: Props) {
     super(props);
     this.state = {
       currentValue: !props.threadInfo.currentUser.subscription.home,
     };
   }
 
   render(): React.Node {
     const componentLabel = 'Background';
     return (
       <View style={this.props.styles.row}>
         <SingleLine style={this.props.styles.label} adjustsFontSizeToFit={true}>
           {componentLabel}
         </SingleLine>
         <View style={this.props.styles.currentValue}>
           <Switch
             value={this.state.currentValue}
             onValueChange={this.onValueChange}
           />
         </View>
       </View>
     );
   }
 
   onValueChange = (value: boolean) => {
     this.setState({ currentValue: value });
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       updateSubscriptionActionTypes,
       this.props.updateSubscription({
         threadID: this.props.threadInfo.id,
         updatedFields: {
           home: !value,
         },
       }),
     );
   };
 }
 
 const ConnectedThreadSettingsHomeNotifs: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedThreadSettingsHomeNotifs(
     props: BaseProps,
   ) {
     const styles = useStyles(unboundStyles);
     const dispatchActionPromise = useDispatchActionPromise();
     const callUpdateSubscription = useUpdateSubscription();
     return (
       <ThreadSettingsHomeNotifs
         {...props}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         updateSubscription={callUpdateSubscription}
       />
     );
   });
 
 export default ConnectedThreadSettingsHomeNotifs;
diff --git a/native/chat/settings/thread-settings-leave-thread.react.js b/native/chat/settings/thread-settings-leave-thread.react.js
index e0600896c..3e2fc9bad 100644
--- a/native/chat/settings/thread-settings-leave-thread.react.js
+++ b/native/chat/settings/thread-settings-leave-thread.react.js
@@ -1,184 +1,184 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, ActivityIndicator, View } from 'react-native';
 
 import {
   leaveThreadActionTypes,
   useLeaveThread,
 } from 'lib/actions/thread-actions.js';
 import type { LeaveThreadInput } from 'lib/actions/thread-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { otherUsersButNoOtherAdmins } from 'lib/selectors/thread-selectors.js';
 import { identifyInvalidatedThreads } from 'lib/shared/thread-utils.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { LeaveThreadPayload, ThreadInfo } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import Button from '../../components/button.react.js';
 import { clearThreadsActionType } from '../../navigation/action-types.js';
 import {
   NavContext,
   type NavContextType,
 } from '../../navigation/navigation-context.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { type Colors, useColors, useStyles } from '../../themes/colors.js';
 import type { ViewStyle } from '../../types/styles.js';
 import Alert from '../../utils/alert.js';
 
 const unboundStyles = {
   button: {
     flexDirection: 'row',
     paddingHorizontal: 12,
     paddingVertical: 10,
   },
   container: {
     backgroundColor: 'panelForeground',
     paddingHorizontal: 12,
   },
   text: {
     color: 'redText',
     flex: 1,
     fontSize: 16,
   },
 };
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
   +buttonStyle: ViewStyle,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +loadingStatus: LoadingStatus,
   +otherUsersButNoOtherAdmins: boolean,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +leaveThread: (input: LeaveThreadInput) => Promise<LeaveThreadPayload>,
   // withNavContext
   +navContext: ?NavContextType,
 };
 class ThreadSettingsLeaveThread extends React.PureComponent<Props> {
   render(): React.Node {
     const { panelIosHighlightUnderlay, panelForegroundSecondaryLabel } =
       this.props.colors;
     const loadingIndicator =
       this.props.loadingStatus === 'loading' ? (
         <ActivityIndicator size="small" color={panelForegroundSecondaryLabel} />
       ) : null;
     return (
       <View style={this.props.styles.container}>
         <Button
           onPress={this.onPress}
           style={[this.props.styles.button, this.props.buttonStyle]}
           iosFormat="highlight"
           iosHighlightUnderlayColor={panelIosHighlightUnderlay}
         >
           <Text style={this.props.styles.text}>Leave chat...</Text>
           {loadingIndicator}
         </Button>
       </View>
     );
   }
 
   onPress = () => {
     if (this.props.otherUsersButNoOtherAdmins) {
       Alert.alert(
         'Need another admin',
         'Make somebody else an admin before you leave!',
         undefined,
         { cancelable: true },
       );
       return;
     }
 
     Alert.alert(
       'Confirm action',
       'Are you sure you want to leave this chat?',
       [
         { text: 'Cancel', style: 'cancel' },
         { text: 'OK', onPress: this.onConfirmLeaveThread },
       ],
       { cancelable: true },
     );
   };
 
   onConfirmLeaveThread = () => {
     const threadID = this.props.threadInfo.id;
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       leaveThreadActionTypes,
       this.leaveThread(),
       {
         customKeyName: `${leaveThreadActionTypes.started}:${threadID}`,
       },
     );
   };
 
   async leaveThread(): Promise<LeaveThreadPayload> {
     const threadID = this.props.threadInfo.id;
     const { navContext } = this.props;
     invariant(navContext, 'navContext should exist in leaveThread');
     navContext.dispatch({
       type: clearThreadsActionType,
       payload: { threadIDs: [threadID] },
     });
     try {
       const result = await this.props.leaveThread({ threadID });
       const invalidated = identifyInvalidatedThreads(
         result.updatesResult.newUpdates,
       );
       navContext.dispatch({
         type: clearThreadsActionType,
         payload: { threadIDs: [...invalidated] },
       });
       return result;
     } catch (e) {
       Alert.alert('Unknown error', 'Uhh... try again?', undefined, {
         cancelable: true,
       });
       throw e;
     }
   }
 }
 
 const ConnectedThreadSettingsLeaveThread: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedThreadSettingsLeaveThread(
     props: BaseProps,
   ) {
     const threadID = props.threadInfo.id;
     const loadingStatus = useSelector(
       createLoadingStatusSelector(
         leaveThreadActionTypes,
         `${leaveThreadActionTypes.started}:${threadID}`,
       ),
     );
     const otherUsersButNoOtherAdminsValue = useSelector(
       otherUsersButNoOtherAdmins(props.threadInfo.id),
     );
     const colors = useColors();
     const styles = useStyles(unboundStyles);
     const dispatchActionPromise = useDispatchActionPromise();
     const callLeaveThread = useLeaveThread();
     const navContext = React.useContext(NavContext);
     return (
       <ThreadSettingsLeaveThread
         {...props}
         loadingStatus={loadingStatus}
         otherUsersButNoOtherAdmins={otherUsersButNoOtherAdminsValue}
         colors={colors}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         leaveThread={callLeaveThread}
         navContext={navContext}
       />
     );
   });
 
 export default ConnectedThreadSettingsLeaveThread;
diff --git a/native/chat/settings/thread-settings-media-gallery.react.js b/native/chat/settings/thread-settings-media-gallery.react.js
index 9b3aec71e..abded331f 100644
--- a/native/chat/settings/thread-settings-media-gallery.react.js
+++ b/native/chat/settings/thread-settings-media-gallery.react.js
@@ -1,225 +1,225 @@
 // @flow
 
 import { useNavigation, useRoute } from '@react-navigation/native';
 import * as React from 'react';
 import { View, useWindowDimensions } from 'react-native';
 import type { ViewStyleProp } from 'react-native/Libraries/StyleSheet/StyleSheet';
 import { FlatList } from 'react-native-gesture-handler';
 
 import { useFetchThreadMedia } from 'lib/actions/thread-actions.js';
 import type { MediaInfo, Media } from 'lib/types/media-types';
 
 import GestureTouchableOpacity from '../../components/gesture-touchable-opacity.react.js';
 import Multimedia from '../../media/multimedia.react.js';
 import {
   ImageModalRouteName,
   VideoPlaybackModalRouteName,
 } from '../../navigation/route-names.js';
 import { useStyles } from '../../themes/colors.js';
 import type {
   LayoutCoordinates,
   VerticalBounds,
 } from '../../types/layout-types.js';
 
 const galleryItemGap = 8;
 const numColumns = 3;
 
 type ThreadSettingsMediaGalleryProps = {
   +threadID: string,
   +limit: number,
   +verticalBounds: ?VerticalBounds,
   +offset?: number,
   +activeTab?: string,
 };
 
 function ThreadSettingsMediaGallery(
   props: ThreadSettingsMediaGalleryProps,
 ): React.Node {
   const styles = useStyles(unboundStyles);
   const { width } = useWindowDimensions();
 
   // Explanation of galleryItemWidth:
   // The FlatList has a horizontal padding of 16px on each side,
   // and so the width of the actual FlatList is `width - 32px`.
   // With three columns, there will be two gaps in between the items,
   // so the width of each item (with the gaps) will be
   // (width - 32px - (numColumns-1) * galleryItemGap) / numColumns.
   // E.g. 16px, media, galleryItemGap, media, galleryItemGap, media, 16px
   const galleryItemWidth =
     (width - 32 - (numColumns - 1) * galleryItemGap) / numColumns;
   const { threadID, limit, verticalBounds, offset, activeTab } = props;
   const [mediaInfos, setMediaInfos] = React.useState<$ReadOnlyArray<Media>>([]);
   const callFetchThreadMedia = useFetchThreadMedia();
 
   React.useEffect(() => {
     const fetchData = async () => {
       const result = await callFetchThreadMedia({
         threadID,
         limit,
         offset: 0,
       });
       setMediaInfos(result.media);
     };
-    fetchData();
+    void fetchData();
   }, [callFetchThreadMedia, threadID, limit]);
 
   const memoizedStyles = React.useMemo(() => {
     return {
       mediaContainer: {
         marginTop: galleryItemGap,
         width: galleryItemWidth,
         ...styles.mediaContainer,
       },
       mediaContainerWithMargin: {
         marginTop: galleryItemGap,
         marginLeft: galleryItemGap,
         width: galleryItemWidth,
         ...styles.mediaContainer,
       },
       media: {
         width: galleryItemWidth,
         ...styles.media,
       },
     };
   }, [galleryItemWidth, styles.media, styles.mediaContainer]);
 
   const filteredMediaInfos = React.useMemo(() => {
     if (activeTab === 'ALL') {
       return mediaInfos;
     } else if (activeTab === 'IMAGES') {
       return mediaInfos.filter(
         mediaInfo =>
           mediaInfo.type === 'photo' || mediaInfo.type === 'encrypted_photo',
       );
     } else if (activeTab === 'VIDEOS') {
       return mediaInfos.filter(
         mediaInfo =>
           mediaInfo.type === 'video' || mediaInfo.type === 'encrypted_video',
       );
     }
     return mediaInfos;
   }, [activeTab, mediaInfos]);
 
   const renderItem = React.useCallback(
     ({ item, index }: { +item: Media, +index: number, ... }) => (
       <MediaGalleryItem
         item={item}
         index={index}
         memoizedStyles={memoizedStyles}
         threadID={threadID}
         verticalBounds={verticalBounds}
       />
     ),
     [threadID, verticalBounds, memoizedStyles],
   );
 
   const onEndReached = React.useCallback(async () => {
     // As the FlatList fetches more media, we set the offset to be the length
     // of mediaInfos. This will ensure that the next set of media is retrieved
     // from the starting point.
     const result = await callFetchThreadMedia({
       threadID,
       limit,
       offset: mediaInfos.length,
     });
     setMediaInfos([...mediaInfos, ...result.media]);
   }, [callFetchThreadMedia, mediaInfos, threadID, limit]);
 
   return (
     <View style={styles.flatListContainer}>
       <FlatList
         data={filteredMediaInfos}
         numColumns={numColumns}
         renderItem={renderItem}
         onEndReached={offset !== undefined ? onEndReached : null}
         onEndReachedThreshold={1}
       />
     </View>
   );
 }
 
 type MediaGalleryItemProps = {
   +item: Media,
   +index: number,
   +memoizedStyles: {
     +mediaContainer: ViewStyleProp,
     +mediaContainerWithMargin: ViewStyleProp,
     +media: ViewStyleProp,
   },
   +threadID: string,
   +verticalBounds: ?VerticalBounds,
 };
 
 function MediaGalleryItem(props: MediaGalleryItemProps): React.Node {
   const navigation = useNavigation();
   const route = useRoute();
   const ref = React.useRef<?React.ElementRef<typeof View>>(null);
   const onLayout = React.useCallback(() => {}, []);
   const { threadID, verticalBounds, memoizedStyles, item, index } = props;
 
   const mediaInfo: MediaInfo = React.useMemo(
     () => ({
       ...(item: Media),
       index,
     }),
     [item, index],
   );
 
   const navigateToMedia = React.useCallback(() => {
     ref.current?.measure((x, y, width, height, pageX, pageY) => {
       const initialCoordinates: LayoutCoordinates = {
         x: pageX,
         y: pageY,
         width,
         height,
       };
 
       navigation.navigate<'VideoPlaybackModal' | 'ImageModal'>({
         name:
           mediaInfo.type === 'video' || mediaInfo.type === 'encrypted_video'
             ? VideoPlaybackModalRouteName
             : ImageModalRouteName,
         key: `multimedia|${threadID}|${mediaInfo.id}`,
         params: {
           presentedFrom: route.key,
           mediaInfo,
           item,
           initialCoordinates,
           verticalBounds,
         },
       });
     });
   }, [navigation, route, threadID, mediaInfo, item, verticalBounds]);
 
   const containerStyle =
     index % numColumns === 0
       ? memoizedStyles.mediaContainer
       : memoizedStyles.mediaContainerWithMargin;
 
   return (
     <View key={item.id} style={containerStyle} onLayout={onLayout} ref={ref}>
       <GestureTouchableOpacity
         onPress={navigateToMedia}
         style={memoizedStyles.media}
       >
         <Multimedia mediaInfo={mediaInfo} spinnerColor="black" />
       </GestureTouchableOpacity>
     </View>
   );
 }
 
 const unboundStyles = {
   flatListContainer: {
     paddingHorizontal: 16,
   },
   mediaContainer: {
     height: 180,
     justifyContent: 'center',
     alignItems: 'center',
   },
   media: {
     height: 180,
   },
 };
 
 export default ThreadSettingsMediaGallery;
diff --git a/native/chat/settings/thread-settings-name.react.js b/native/chat/settings/thread-settings-name.react.js
index 10dd6ad57..32ea8bfca 100644
--- a/native/chat/settings/thread-settings-name.react.js
+++ b/native/chat/settings/thread-settings-name.react.js
@@ -1,246 +1,246 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   Text,
   ActivityIndicator,
   TextInput as BaseTextInput,
   View,
 } from 'react-native';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from 'lib/actions/thread-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type {
   ChangeThreadSettingsPayload,
   UpdateThreadRequest,
   ResolvedThreadInfo,
 } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { firstLine } from 'lib/utils/string-utils.js';
 import { chatNameMaxLength } from 'lib/utils/validation-utils.js';
 
 import SaveSettingButton from './save-setting-button.react.js';
 import EditSettingButton from '../../components/edit-setting-button.react.js';
 import SingleLine from '../../components/single-line.react.js';
 import TextInput from '../../components/text-input.react.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { type Colors, useStyles, useColors } from '../../themes/colors.js';
 import Alert from '../../utils/alert.js';
 
 const unboundStyles = {
   currentValue: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontFamily: 'Arial',
     fontSize: 16,
     margin: 0,
     paddingLeft: 4,
     paddingRight: 0,
     paddingVertical: 0,
     borderBottomColor: 'transparent',
   },
   label: {
     color: 'panelForegroundTertiaryLabel',
     fontSize: 16,
     width: 96,
   },
   row: {
     backgroundColor: 'panelForeground',
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 8,
   },
 };
 
 type BaseProps = {
   +threadInfo: ResolvedThreadInfo,
   +nameEditValue: ?string,
   +setNameEditValue: (value: ?string, callback?: () => void) => void,
   +canChangeSettings: boolean,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +loadingStatus: LoadingStatus,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +changeThreadSettings: (
     update: UpdateThreadRequest,
   ) => Promise<ChangeThreadSettingsPayload>,
 };
 class ThreadSettingsName extends React.PureComponent<Props> {
   textInput: ?React.ElementRef<typeof BaseTextInput>;
 
   render(): React.Node {
     return (
       <View style={this.props.styles.row}>
         <Text style={this.props.styles.label}>Name</Text>
         {this.renderContent()}
       </View>
     );
   }
 
   renderButton(): React.Node {
     if (this.props.loadingStatus === 'loading') {
       return (
         <ActivityIndicator
           size="small"
           color={this.props.colors.panelForegroundSecondaryLabel}
         />
       );
     } else if (
       this.props.nameEditValue === null ||
       this.props.nameEditValue === undefined
     ) {
       return (
         <EditSettingButton
           onPress={this.onPressEdit}
           canChangeSettings={this.props.canChangeSettings}
         />
       );
     }
     return <SaveSettingButton onPress={this.onSubmit} />;
   }
 
   renderContent(): React.Node {
     if (
       this.props.nameEditValue === null ||
       this.props.nameEditValue === undefined
     ) {
       return (
         <React.Fragment>
           <SingleLine style={this.props.styles.currentValue}>
             {this.props.threadInfo.uiName}
           </SingleLine>
           {this.renderButton()}
         </React.Fragment>
       );
     }
 
     return (
       <React.Fragment>
         <TextInput
           style={this.props.styles.currentValue}
           value={this.props.nameEditValue}
           onChangeText={this.props.setNameEditValue}
           autoFocus={true}
           selectTextOnFocus={true}
           onBlur={this.onSubmit}
           editable={this.props.loadingStatus !== 'loading'}
           ref={this.textInputRef}
           selectionColor={`#${this.props.threadInfo.color}`}
           maxLength={chatNameMaxLength}
         />
         {this.renderButton()}
       </React.Fragment>
     );
   }
 
   textInputRef = (textInput: ?React.ElementRef<typeof BaseTextInput>) => {
     this.textInput = textInput;
   };
 
   threadEditName(): string {
     return firstLine(
       this.props.threadInfo.name ? this.props.threadInfo.name : '',
     );
   }
 
   onPressEdit = () => {
     this.props.setNameEditValue(this.threadEditName());
   };
 
   onSubmit = () => {
     invariant(
       this.props.nameEditValue !== null &&
         this.props.nameEditValue !== undefined,
       'should be set',
     );
     const name = firstLine(this.props.nameEditValue);
 
     if (name === this.threadEditName()) {
       this.props.setNameEditValue(null);
       return;
     }
 
     const editNamePromise = this.editName(name);
     const action = changeThreadSettingsActionTypes.started;
     const threadID = this.props.threadInfo.id;
 
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       changeThreadSettingsActionTypes,
       editNamePromise,
       {
         customKeyName: `${action}:${threadID}:name`,
       },
     );
-    editNamePromise.then(() => {
+    void editNamePromise.then(() => {
       this.props.setNameEditValue(null);
     });
   };
 
   async editName(newName: string): Promise<ChangeThreadSettingsPayload> {
     try {
       return await this.props.changeThreadSettings({
         threadID: this.props.threadInfo.id,
         changes: { name: newName },
       });
     } catch (e) {
       Alert.alert(
         'Unknown error',
         'Uhh... try again?',
         [{ text: 'OK', onPress: this.onErrorAcknowledged }],
         { cancelable: false },
       );
       throw e;
     }
   }
 
   onErrorAcknowledged = () => {
     this.props.setNameEditValue(this.threadEditName(), () => {
       invariant(this.textInput, 'textInput should be set');
       this.textInput.focus();
     });
   };
 }
 
 const ConnectedThreadSettingsName: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedThreadSettingsName(props: BaseProps) {
     const styles = useStyles(unboundStyles);
     const colors = useColors();
 
     const threadID = props.threadInfo.id;
     const loadingStatus = useSelector(
       createLoadingStatusSelector(
         changeThreadSettingsActionTypes,
         `${changeThreadSettingsActionTypes.started}:${threadID}:name`,
       ),
     );
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callChangeThreadSettings = useChangeThreadSettings();
 
     return (
       <ThreadSettingsName
         {...props}
         styles={styles}
         colors={colors}
         loadingStatus={loadingStatus}
         dispatchActionPromise={dispatchActionPromise}
         changeThreadSettings={callChangeThreadSettings}
       />
     );
   });
 
 export default ConnectedThreadSettingsName;
diff --git a/native/chat/settings/thread-settings-push-notifs.react.js b/native/chat/settings/thread-settings-push-notifs.react.js
index 404fb6531..4112dcffc 100644
--- a/native/chat/settings/thread-settings-push-notifs.react.js
+++ b/native/chat/settings/thread-settings-push-notifs.react.js
@@ -1,196 +1,196 @@
 // @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 { 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 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 });
-    this.props.dispatchActionPromise(
+    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/native/chat/toggle-pin-modal.react.js b/native/chat/toggle-pin-modal.react.js
index adf2869c1..98eeab13a 100644
--- a/native/chat/toggle-pin-modal.react.js
+++ b/native/chat/toggle-pin-modal.react.js
@@ -1,164 +1,164 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import {
   useToggleMessagePin,
   toggleMessagePinActionTypes,
 } from 'lib/actions/message-actions.js';
 import type { RawMessageInfo } from 'lib/types/message-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import MessageResult from './message-result.react.js';
 import Button from '../components/button.react.js';
 import Modal from '../components/modal.react.js';
 import type { AppNavigationProp } from '../navigation/app-navigator.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useStyles } from '../themes/colors.js';
 import type { ChatMessageInfoItemWithHeight } from '../types/chat-types';
 
 export type TogglePinModalParams = {
   +item: ChatMessageInfoItemWithHeight,
   +threadInfo: ThreadInfo,
 };
 
 type TogglePinModalProps = {
   +navigation: AppNavigationProp<'TogglePinModal'>,
   +route: NavigationRoute<'TogglePinModal'>,
 };
 
 function TogglePinModal(props: TogglePinModalProps): React.Node {
   const { navigation, route } = props;
   const { item, threadInfo } = route.params;
   const { messageInfo, isPinned } = item;
   const styles = useStyles(unboundStyles);
 
   const callToggleMessagePin = useToggleMessagePin();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const modalInfo = React.useMemo(() => {
     if (isPinned) {
       return {
         name: 'Remove Pinned Message',
         action: 'unpin',
         confirmationText:
           'Are you sure you want to remove this pinned message?',
         buttonText: 'Remove Pinned Message',
         buttonStyle: styles.removePinButton,
       };
     }
 
     return {
       name: 'Pin Message',
       action: 'pin',
       confirmationText:
         'You may pin this message to the channel you are ' +
         'currently viewing. To unpin a message, select the pinned messages ' +
         'icon in the channel.',
       buttonText: 'Pin Message',
       buttonStyle: styles.pinButton,
     };
   }, [isPinned, styles.pinButton, styles.removePinButton]);
 
   const createToggleMessagePinPromise = React.useCallback(async () => {
     invariant(messageInfo.id, 'messageInfo.id should be defined');
     const result = await callToggleMessagePin({
       messageID: messageInfo.id,
       action: modalInfo.action,
     });
     return ({
       newMessageInfos: result.newMessageInfos,
       threadID: result.threadID,
     }: { +newMessageInfos: $ReadOnlyArray<RawMessageInfo>, +threadID: string });
   }, [callToggleMessagePin, messageInfo.id, modalInfo.action]);
 
   const onPress = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       toggleMessagePinActionTypes,
       createToggleMessagePinPromise(),
     );
 
     navigation.goBack();
   }, [createToggleMessagePinPromise, dispatchActionPromise, navigation]);
 
   const onCancel = React.useCallback(() => {
     navigation.goBack();
   }, [navigation]);
 
   return (
     <Modal modalStyle={styles.modal}>
       <Text style={styles.modalHeader}>{modalInfo.name}</Text>
       <Text style={styles.modalConfirmationText}>
         {modalInfo.confirmationText}
       </Text>
       <MessageResult
         item={item}
         threadInfo={threadInfo}
         navigation={navigation}
         route={route}
         messageVerticalBounds={null}
         scrollable={true}
       />
       <View style={styles.buttonsContainer}>
         <Button style={modalInfo.buttonStyle} onPress={onPress}>
           <Text style={styles.textColor}>{modalInfo.buttonText}</Text>
         </Button>
         <Button style={styles.cancelButton} onPress={onCancel}>
           <Text style={styles.textColor}>Cancel</Text>
         </Button>
       </View>
     </Modal>
   );
 }
 
 const unboundStyles = {
   modal: {
     backgroundColor: 'modalForeground',
     borderColor: 'modalForegroundBorder',
   },
   modalHeader: {
     fontSize: 18,
     color: 'modalForegroundLabel',
   },
   modalConfirmationText: {
     fontSize: 12,
     color: 'modalBackgroundLabel',
     marginTop: 4,
   },
   buttonsContainer: {
     flexDirection: 'column',
     flex: 1,
     justifyContent: 'flex-end',
     marginBottom: 0,
     height: 72,
     paddingHorizontal: 16,
   },
   removePinButton: {
     borderRadius: 5,
     height: 48,
     justifyContent: 'center',
     alignItems: 'center',
     backgroundColor: 'vibrantRedButton',
   },
   pinButton: {
     borderRadius: 5,
     height: 48,
     justifyContent: 'center',
     alignItems: 'center',
     backgroundColor: 'purpleButton',
   },
   cancelButton: {
     borderRadius: 5,
     height: 48,
     justifyContent: 'center',
     alignItems: 'center',
   },
   textColor: {
     color: 'modalButtonLabel',
   },
 };
 
 export default TogglePinModal;
diff --git a/native/community-creation/community-configuration.react.js b/native/community-creation/community-configuration.react.js
index 7913c888e..dcd53e4ad 100644
--- a/native/community-creation/community-configuration.react.js
+++ b/native/community-creation/community-configuration.react.js
@@ -1,214 +1,214 @@
 // @flow
 
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import {
   useNewThread,
   newThreadActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import type { NewThreadResult } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import CommunityCreationKeyserverLabel from './community-creation-keyserver-label.react.js';
 import type { CommunityCreationNavigationProp } from './community-creation-navigator.react.js';
 import RegistrationButtonContainer from '../account/registration/registration-button-container.react.js';
 import RegistrationButton from '../account/registration/registration-button.react.js';
 import RegistrationContainer from '../account/registration/registration-container.react.js';
 import RegistrationContentContainer from '../account/registration/registration-content-container.react.js';
 import {
   ThreadSettingsCategoryFooter,
   ThreadSettingsCategoryHeader,
 } from '../chat/settings/thread-settings-category.react.js';
 import EnumSettingsOption from '../components/enum-settings-option.react.js';
 import TextInput from '../components/text-input.react.js';
 import { useCalendarQuery } from '../navigation/nav-selectors.js';
 import {
   CommunityCreationMembersRouteName,
   type NavigationRoute,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useColors, useStyles } from '../themes/colors.js';
 
 type Props = {
   +navigation: CommunityCreationNavigationProp<'CommunityConfiguration'>,
   +route: NavigationRoute<'CommunityConfiguration'>,
 };
 
 const createNewCommunityLoadingStatusSelector =
   createLoadingStatusSelector(newThreadActionTypes);
 
 // eslint-disable-next-line no-unused-vars
 function CommunityConfiguration(props: Props): React.Node {
   const styles = useStyles(unboundStyles);
   const colors = useColors();
 
   const { navigate } = props.navigation;
 
   const dispatchActionPromise = useDispatchActionPromise();
 
   const callNewThread = useNewThread();
   const calendarQueryFunc = useCalendarQuery();
 
   const createNewCommunityLoadingStatus: LoadingStatus = useSelector(
     createNewCommunityLoadingStatusSelector,
   );
 
   const [pendingCommunityName, setPendingCommunityName] = React.useState('');
   const [announcementSetting, setAnnouncementSetting] = React.useState(false);
   const [errorMessage, setErrorMessage] = React.useState<?string>();
 
   const onChangePendingCommunityName = React.useCallback((newValue: string) => {
     setErrorMessage();
     setPendingCommunityName(newValue);
   }, []);
 
   const callCreateNewCommunity = React.useCallback(async () => {
     const calendarQuery = calendarQueryFunc();
     try {
       const newThreadResult: NewThreadResult = await callNewThread({
         name: pendingCommunityName,
         type: announcementSetting
           ? threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT
           : threadTypes.COMMUNITY_ROOT,
         calendarQuery,
       });
       return newThreadResult;
     } catch (e) {
       setErrorMessage('Community creation failed. Please try again.');
       throw e;
     }
   }, [
     announcementSetting,
     calendarQueryFunc,
     callNewThread,
     pendingCommunityName,
   ]);
 
   const createNewCommunity = React.useCallback(async () => {
     setErrorMessage();
     const newThreadResultPromise = callCreateNewCommunity();
-    dispatchActionPromise(newThreadActionTypes, newThreadResultPromise);
+    void dispatchActionPromise(newThreadActionTypes, newThreadResultPromise);
     const newThreadResult = await newThreadResultPromise;
 
     navigate<'CommunityCreationMembers'>({
       name: CommunityCreationMembersRouteName,
       params: {
         announcement: announcementSetting,
         threadID: newThreadResult.newThreadID,
       },
     });
   }, [
     announcementSetting,
     callCreateNewCommunity,
     dispatchActionPromise,
     navigate,
   ]);
 
   const onCheckBoxPress = React.useCallback(() => {
     setErrorMessage();
     setAnnouncementSetting(!announcementSetting);
   }, [announcementSetting]);
 
   const enumSettingsOptionDescription =
     'Make it so only admins can post to ' +
     'the root channel of the community.';
 
   return (
     <RegistrationContainer>
       <RegistrationContentContainer style={styles.containerPaddingOverride}>
         <CommunityCreationKeyserverLabel />
         <ThreadSettingsCategoryHeader type="full" title="COMMUNITY INFO" />
         <View style={styles.communityNameRow}>
           <Text style={styles.communityNameLabel}>Name</Text>
           <TextInput
             style={styles.communityNamePendingValue}
             placeholder="Community Name"
             placeholderTextColor={colors.panelSecondaryForegroundBorder}
             value={pendingCommunityName}
             onChangeText={onChangePendingCommunityName}
             editable={true}
           />
         </View>
         <ThreadSettingsCategoryFooter type="full" />
 
         <View style={styles.communityNameNoticeContainer}>
           <Text style={styles.communityNameNoticeText}>
             You may edit your community&rsquo;s image and name later.
           </Text>
         </View>
 
         <ThreadSettingsCategoryHeader type="full" title="OPTIONAL SETTINGS" />
         <EnumSettingsOption
           icon="megaphone"
           name="Announcement root"
           description={enumSettingsOptionDescription}
           enumValue={announcementSetting}
           onEnumValuePress={onCheckBoxPress}
         />
         <ThreadSettingsCategoryFooter type="full" />
         <RegistrationButtonContainer>
           <RegistrationButton
             onPress={createNewCommunity}
             label="Create community"
             variant={
               createNewCommunityLoadingStatus === 'loading'
                 ? 'loading'
                 : 'enabled'
             }
           />
         </RegistrationButtonContainer>
         <View style={styles.errorMessageContainer}>
           <Text style={styles.errorMessageText}>{errorMessage}</Text>
         </View>
       </RegistrationContentContainer>
     </RegistrationContainer>
   );
 }
 
 const unboundStyles = {
   containerPaddingOverride: {
     padding: 0,
   },
   communityNameRow: {
     backgroundColor: 'panelForeground',
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 8,
   },
   communityNameLabel: {
     color: 'panelForegroundTertiaryLabel',
     fontSize: 16,
     width: 96,
   },
   communityNamePendingValue: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontFamily: 'Arial',
     fontSize: 16,
     margin: 0,
     paddingLeft: 4,
     paddingRight: 0,
     paddingVertical: 0,
     borderBottomColor: 'transparent',
   },
   communityNameNoticeContainer: {
     display: 'flex',
     flexDirection: 'row',
     justifyContent: 'center',
   },
   communityNameNoticeText: {
     color: 'panelForegroundTertiaryLabel',
   },
   errorMessageContainer: {
     alignItems: 'center',
   },
   errorMessageText: {
     color: 'redText',
   },
 };
 
 export default CommunityConfiguration;
diff --git a/native/community-creation/community-creation-members.react.js b/native/community-creation/community-creation-members.react.js
index 041877a45..80dfd7385 100644
--- a/native/community-creation/community-creation-members.react.js
+++ b/native/community-creation/community-creation-members.react.js
@@ -1,202 +1,202 @@
 // @flow
 
 import * as React from 'react';
 import { ActivityIndicator } from 'react-native';
 
 import {
   useChangeThreadSettings,
   changeThreadSettingsActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import {
   userInfoSelectorForPotentialMembers,
   userSearchIndexForPotentialMembers,
 } from 'lib/selectors/user-selectors.js';
 import { getPotentialMemberItems } from 'lib/shared/search-utils.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import type { AccountUserInfo } from 'lib/types/user-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import CommunityCreationContentContainer from './community-creation-content-container.react.js';
 import CommunityCreationKeyserverLabel from './community-creation-keyserver-label.react.js';
 import type { CommunityCreationNavigationProp } from './community-creation-navigator.react.js';
 import RegistrationContainer from '../account/registration/registration-container.react.js';
 import { useNavigateToThread } from '../chat/message-list-types.js';
 import LinkButton from '../components/link-button.react.js';
 import {
   createTagInput,
   type BaseTagInput,
 } from '../components/tag-input.react.js';
 import UserList from '../components/user-list.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 export type CommunityCreationMembersScreenParams = {
   +announcement: boolean,
   +threadID: string,
 };
 
 const TagInput = createTagInput<AccountUserInfo>();
 const tagInputProps = {
   placeholder: 'username',
   autoFocus: true,
   returnKeyType: 'go',
 };
 const tagDataLabelExtractor = (userInfo: AccountUserInfo) => userInfo.username;
 
 type Props = {
   +navigation: CommunityCreationNavigationProp<'CommunityCreationMembers'>,
   +route: NavigationRoute<'CommunityCreationMembers'>,
 };
 
 const changeThreadSettingsLoadingStatusSelector = createLoadingStatusSelector(
   changeThreadSettingsActionTypes,
 );
 
 function CommunityCreationMembers(props: Props): React.Node {
   const { announcement, threadID } = props.route.params;
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useChangeThreadSettings();
   const changeThreadSettingsLoadingStatus: LoadingStatus = useSelector(
     changeThreadSettingsLoadingStatusSelector,
   );
 
   const { navigation } = props;
   const { setOptions } = navigation;
 
   const otherUserInfos = useSelector(userInfoSelectorForPotentialMembers);
   const userSearchIndex = useSelector(userSearchIndexForPotentialMembers);
 
   const [usernameInputText, setUsernameInputText] = React.useState<string>('');
   const [selectedUsers, setSelectedUsers] = React.useState<
     $ReadOnlyArray<AccountUserInfo>,
   >([]);
 
   const selectedUserIDs = React.useMemo(
     () => selectedUsers.map(userInfo => userInfo.id),
     [selectedUsers],
   );
 
   const navigateToThread = useNavigateToThread();
   const threadInfos = useSelector(threadInfoSelector);
   const communityThreadInfo = threadInfos[threadID];
 
   const addSelectedUsersToCommunity = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       changeThreadSettingsActionTypes,
       (async () => {
         const result = await callChangeThreadSettings({
           threadID,
           changes: { newMemberIDs: selectedUserIDs },
         });
         navigateToThread({ threadInfo: communityThreadInfo });
         return result;
       })(),
     );
   }, [
     callChangeThreadSettings,
     communityThreadInfo,
     dispatchActionPromise,
     navigateToThread,
     selectedUserIDs,
     threadID,
   ]);
 
   const exitCommunityCreationFlow = React.useCallback(() => {
     navigateToThread({ threadInfo: communityThreadInfo });
   }, [communityThreadInfo, navigateToThread]);
 
   const activityIndicatorStyle = React.useMemo(
     () => ({ paddingRight: 20 }),
     [],
   );
 
   React.useEffect(() => {
     setOptions({
       // eslint-disable-next-line react/display-name
       headerRight: () => {
         if (changeThreadSettingsLoadingStatus === 'loading') {
           return (
             <ActivityIndicator size="small" style={activityIndicatorStyle} />
           );
         }
         return (
           <LinkButton
             text={selectedUserIDs.length === 0 ? 'Skip' : 'Done'}
             onPress={
               selectedUserIDs.length === 0
                 ? exitCommunityCreationFlow
                 : addSelectedUsersToCommunity
             }
           />
         );
       },
     });
   }, [
     activityIndicatorStyle,
     addSelectedUsersToCommunity,
     changeThreadSettingsLoadingStatus,
     exitCommunityCreationFlow,
     selectedUserIDs.length,
     setOptions,
   ]);
 
   const userSearchResults = React.useMemo(
     () =>
       getPotentialMemberItems({
         text: usernameInputText,
         userInfos: otherUserInfos,
         searchIndex: userSearchIndex,
         excludeUserIDs: selectedUserIDs,
         threadType: announcement
           ? threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT
           : threadTypes.COMMUNITY_ROOT,
       }),
     [
       announcement,
       otherUserInfos,
       selectedUserIDs,
       userSearchIndex,
       usernameInputText,
     ],
   );
 
   const onSelectUser = React.useCallback(
     ({ id }: AccountUserInfo) => {
       if (selectedUserIDs.some(existingUserID => id === existingUserID)) {
         return;
       }
       setSelectedUsers(oldUserInfoInputArray => [
         ...oldUserInfoInputArray,
         otherUserInfos[id],
       ]);
       setUsernameInputText('');
     },
     [otherUserInfos, selectedUserIDs],
   );
 
   const tagInputRef = React.useRef<?BaseTagInput<AccountUserInfo>>();
 
   return (
     <RegistrationContainer>
       <CommunityCreationContentContainer>
         <CommunityCreationKeyserverLabel />
         <TagInput
           value={selectedUsers}
           onChange={setSelectedUsers}
           text={usernameInputText}
           onChangeText={setUsernameInputText}
           labelExtractor={tagDataLabelExtractor}
           inputProps={tagInputProps}
           ref={tagInputRef}
         />
         <UserList userInfos={userSearchResults} onSelect={onSelectUser} />
       </CommunityCreationContentContainer>
     </RegistrationContainer>
   );
 }
 
 export default CommunityCreationMembers;
diff --git a/native/components/feature-flags-provider.react.js b/native/components/feature-flags-provider.react.js
index e419d87a9..a06ead4ed 100644
--- a/native/components/feature-flags-provider.react.js
+++ b/native/components/feature-flags-provider.react.js
@@ -1,119 +1,119 @@
 // @flow
 
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import * as React from 'react';
 import { Platform } from 'react-native';
 
 import { useIsCurrentUserStaff } from 'lib/shared/staff-utils.js';
 import { fetchFeatureFlags } from 'lib/utils/feature-flags-utils.js';
 import sleep from 'lib/utils/sleep.js';
 
 import { codeVersion } from '../redux/persist.js';
 
 type FeatureFlagsConfiguration = {
   +[feature: string]: boolean,
 };
 
 type FeatureFlagsContextType = {
   +configuration: FeatureFlagsConfiguration,
   +loadedFromService: boolean,
 };
 
 const defaultContext = {
   configuration: {},
   loadedFromService: false,
 };
 
 const FeatureFlagsContext: React.Context<FeatureFlagsContextType> =
   React.createContext<FeatureFlagsContextType>(defaultContext);
 
 const featureFlagsStorageKey = 'FeatureFlags';
 
 type Props = {
   +children: React.Node,
 };
 function FeatureFlagsProvider(props: Props): React.Node {
   const { children } = props;
   const isStaff = useIsCurrentUserStaff();
 
   const [featuresConfig, setFeaturesConfig] = React.useState(defaultContext);
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       if (featuresConfig.loadedFromService) {
         return;
       }
 
       const persistedFeaturesConfig = await AsyncStorage.getItem(
         featureFlagsStorageKey,
       );
       if (!persistedFeaturesConfig) {
         return;
       }
 
       setFeaturesConfig(config =>
         config.loadedFromService
           ? config
           : {
               configuration: JSON.parse(persistedFeaturesConfig),
               loadedFromService: false,
             },
       );
     })();
   }, [featuresConfig.loadedFromService]);
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       try {
         const config = await tryMultipleTimes(
           () => fetchFeatureFlags(Platform.OS, isStaff, codeVersion),
           3,
           5000,
         );
 
         const configuration: { [string]: true } = {};
         for (const feature of config.enabledFeatures) {
           configuration[feature] = true;
         }
         setFeaturesConfig({
           configuration,
           loadedFromService: true,
         });
         await AsyncStorage.setItem(
           featureFlagsStorageKey,
           JSON.stringify(configuration),
         );
       } catch (e) {
         console.error('Feature flag retrieval failed:', e);
       }
     })();
   }, [isStaff]);
 
   return (
     <FeatureFlagsContext.Provider value={featuresConfig}>
       {children}
     </FeatureFlagsContext.Provider>
   );
 }
 
 async function tryMultipleTimes<T>(
   f: () => Promise<T>,
   numberOfTries: number,
   delay: number,
 ): Promise<T> {
   let lastError;
   while (numberOfTries > 0) {
     try {
       return await f();
     } catch (e) {
       --numberOfTries;
       lastError = e;
       if (numberOfTries > 0) {
         await sleep(delay);
       }
     }
   }
   throw lastError;
 }
 
 export { FeatureFlagsContext, FeatureFlagsProvider, featureFlagsStorageKey };
diff --git a/native/components/version-supported.react.js b/native/components/version-supported.react.js
index 54b321bf7..10d12aa40 100644
--- a/native/components/version-supported.react.js
+++ b/native/components/version-supported.react.js
@@ -1,65 +1,68 @@
 // @flow
 
 import * as React from 'react';
 
 import { useLogOut, logOutActionTypes } from 'lib/actions/user-actions.js';
 import { preRequestUserStateForSingleKeyserverSelector } from 'lib/selectors/account-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import { commRustModule } from '../native-modules.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { AppOutOfDateAlertDetails } from '../utils/alert-messages.js';
 import Alert from '../utils/alert.js';
 
 function VersionSupportedChecker(): React.Node {
   const hasRun = React.useRef(false);
 
   const loggedIn = useSelector(isLoggedIn);
   const preRequestUserState = useSelector(
     preRequestUserStateForSingleKeyserverSelector(ashoatKeyserverID),
   );
   const dispatchActionPromise = useDispatchActionPromise();
   const callLogOut = useLogOut();
 
   const onUsernameAlertAcknowledged = React.useCallback(() => {
     if (loggedIn) {
-      dispatchActionPromise(logOutActionTypes, callLogOut(preRequestUserState));
+      void dispatchActionPromise(
+        logOutActionTypes,
+        callLogOut(preRequestUserState),
+      );
     }
   }, [callLogOut, dispatchActionPromise, loggedIn, preRequestUserState]);
 
   const checkVersionSupport = React.useCallback(async () => {
     try {
       const isVersionSupported = await commRustModule.versionSupported();
       if (isVersionSupported) {
         return;
       }
       Alert.alert(
         AppOutOfDateAlertDetails.title,
         AppOutOfDateAlertDetails.message,
         [
           {
             text: 'OK',
             onPress: onUsernameAlertAcknowledged,
           },
         ],
         { cancelable: false },
       );
     } catch (error) {
       console.log('Error checking version:', error);
     }
   }, [onUsernameAlertAcknowledged]);
 
   React.useEffect(() => {
     if (hasRun.current) {
       return;
     }
     hasRun.current = true;
-    checkVersionSupport();
+    void checkVersionSupport();
   }, [checkVersionSupport]);
 
   return null;
 }
 
 export default VersionSupportedChecker;
diff --git a/native/crash.react.js b/native/crash.react.js
index 13a9e3011..25e79d438 100644
--- a/native/crash.react.js
+++ b/native/crash.react.js
@@ -1,298 +1,304 @@
 // @flow
 
 import Icon from '@expo/vector-icons/FontAwesome.js';
 import Clipboard from '@react-native-clipboard/clipboard';
 import invariant from 'invariant';
 import _shuffle from 'lodash/fp/shuffle.js';
 import * as React from 'react';
 import {
   View,
   Text,
   Platform,
   StyleSheet,
   ScrollView,
   ActivityIndicator,
 } from 'react-native';
 
 import {
   sendReportActionTypes,
   sendReport,
 } from 'lib/actions/report-actions.js';
 import { logOutActionTypes, useLogOut } from 'lib/actions/user-actions.js';
 import { preRequestUserStateSelector } from 'lib/selectors/account-selectors.js';
 import type { LogOutResult } from 'lib/types/account-types.js';
 import { type ErrorData, reportTypes } from 'lib/types/report-types.js';
 import type { PreRequestUserState } from 'lib/types/session-types.js';
 import { actionLogger } from 'lib/utils/action-logger.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import {
   generateReportID,
   useIsReportEnabled,
 } from 'lib/utils/report-utils.js';
 import {
   sanitizeReduxReport,
   type ReduxCrashReport,
 } from 'lib/utils/sanitization.js';
 import sleep from 'lib/utils/sleep.js';
 
 import Button from './components/button.react.js';
 import ConnectedStatusBar from './connected-status-bar.react.js';
 import { commCoreModule } from './native-modules.js';
 import { persistConfig, codeVersion } from './redux/persist.js';
 import { useSelector } from './redux/redux-utils.js';
 import { wipeAndExit } from './utils/crash-utils.js';
 
 const errorTitles = ['Oh no!!', 'Womp womp womp...'];
 
 type BaseProps = {
   +errorData: $ReadOnlyArray<ErrorData>,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +preRequestUserState: PreRequestUserState,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +logOut: (preRequestUserState: PreRequestUserState) => Promise<LogOutResult>,
   +crashReportingEnabled: boolean,
 };
 type State = {
   +errorReportID: ?string,
   +doneWaiting: boolean,
 };
 class Crash extends React.PureComponent<Props, State> {
   errorTitle: string = _shuffle(errorTitles)[0];
 
   constructor(props: Props) {
     super(props);
     this.state = {
       errorReportID: null,
       doneWaiting: !props.crashReportingEnabled,
     };
   }
 
   componentDidMount() {
     if (this.state.doneWaiting) {
       return;
     }
-    this.props.dispatchActionPromise(sendReportActionTypes, this.sendReport());
-    this.timeOut();
+    void this.props.dispatchActionPromise(
+      sendReportActionTypes,
+      this.sendReport(),
+    );
+    void this.timeOut();
   }
 
   async timeOut() {
     // If it takes more than 10s, give up and let the user exit
     await sleep(10000);
     this.setState({ doneWaiting: true });
   }
 
   render(): React.Node {
     const errorText = [...this.props.errorData]
       .reverse()
       .map(errorData => errorData.error.message)
       .join('\n');
 
     let crashID;
     if (!this.state.doneWaiting) {
       crashID = <ActivityIndicator size="small" color="black" />;
     } else if (this.state.doneWaiting && this.state.errorReportID) {
       crashID = (
         <View style={styles.crashID}>
           <Text style={styles.crashIDText}>Crash report ID:</Text>
           <View style={styles.errorReportID}>
             <Text style={styles.errorReportIDText}>
               {this.state.errorReportID}
             </Text>
             <Button onPress={this.onCopyCrashReportID}>
               <Text style={styles.copyCrashReportIDButtonText}>(Copy)</Text>
             </Button>
           </View>
         </View>
       );
     } else {
       crashID = (
         <Text style={styles.text}>
           Crash reporting can be enabled in the Profile tab.
         </Text>
       );
     }
 
     const buttonStyle = { opacity: Number(this.state.doneWaiting) };
 
     return (
       <View style={styles.container}>
         <ConnectedStatusBar barStyle="dark-content" />
         <Icon name="bug" size={32} color="red" />
         <Text style={styles.header}>{this.errorTitle}</Text>
         <Text style={styles.text}>I&rsquo;m sorry, but the app crashed.</Text>
         {crashID}
         <Text style={styles.text}>
           Here&rsquo;s some text that&rsquo;s probably not helpful:
         </Text>
         <ScrollView style={styles.scrollView}>
           <Text style={styles.errorText}>{errorText}</Text>
         </ScrollView>
         <View style={[styles.buttons, buttonStyle]}>
           <Button onPress={this.onPressKill} style={styles.button}>
             <Text style={styles.buttonText}>Kill the app</Text>
           </Button>
           <Button onPress={this.onPressWipe} style={styles.button}>
             <Text style={styles.buttonText}>Wipe state and kill app</Text>
           </Button>
         </View>
       </View>
     );
   }
 
   async sendReport() {
     // There's a type error here because ActionLogger doesn't understand the
     // exact shape of the Redux state / actions it is passed. We could solve it
     // by adding some type params to ActionLogger
     const rawReduxReport: ReduxCrashReport = ({
       preloadedState: actionLogger.preloadedState,
       currentState: actionLogger.currentState,
       actions: actionLogger.actions,
     }: any);
     const sanitizedReduxReport = sanitizeReduxReport(rawReduxReport);
     const result = await sendReport({
       type: reportTypes.ERROR,
       platformDetails: {
         platform: Platform.OS,
         codeVersion,
         stateVersion: persistConfig.version,
       },
       errors: this.props.errorData.map(data => ({
         errorMessage: data.error.message,
         stack: data.error.stack,
         componentStack: data.info && data.info.componentStack,
       })),
       ...sanitizedReduxReport,
       id: generateReportID(),
     });
     this.setState({
       errorReportID: result.id,
       doneWaiting: true,
     });
   }
 
   onPressKill = () => {
     if (!this.state.doneWaiting) {
       return;
     }
     commCoreModule.terminate();
   };
 
   onPressWipe = () => {
     if (!this.state.doneWaiting) {
       return;
     }
-    this.props.dispatchActionPromise(logOutActionTypes, this.logOutAndExit());
+    void this.props.dispatchActionPromise(
+      logOutActionTypes,
+      this.logOutAndExit(),
+    );
   };
 
   async logOutAndExit() {
     try {
       await this.props.logOut(this.props.preRequestUserState);
     } catch (e) {}
     await wipeAndExit();
   }
 
   onCopyCrashReportID = () => {
     invariant(this.state.errorReportID, 'should be set');
     Clipboard.setString(this.state.errorReportID);
   };
 }
 
 const styles = StyleSheet.create({
   button: {
     backgroundColor: '#FF0000',
     borderRadius: 5,
     marginHorizontal: 10,
     paddingHorizontal: 10,
     paddingVertical: 5,
   },
   buttonText: {
     color: 'white',
     fontSize: 16,
   },
   buttons: {
     flexDirection: 'row',
   },
   container: {
     alignItems: 'center',
     backgroundColor: 'white',
     flex: 1,
     justifyContent: 'center',
   },
   copyCrashReportIDButtonText: {
     color: '#036AFF',
   },
   crashID: {
     alignItems: 'center',
     paddingBottom: 12,
     paddingTop: 2,
   },
   crashIDText: {
     color: 'black',
   },
   errorReportID: {
     flexDirection: 'row',
     height: 20,
   },
   errorReportIDText: {
     color: 'black',
     fontFamily: (Platform.select({
       ios: 'Menlo',
       default: 'monospace',
     }): string),
     fontSize: 12,
     paddingRight: 8,
     paddingTop: 3,
   },
   errorText: {
     color: 'black',
     fontFamily: (Platform.select({
       ios: 'Menlo',
       default: 'monospace',
     }): string),
   },
   header: {
     color: 'black',
     fontSize: 24,
     paddingBottom: 24,
   },
   scrollView: {
     flex: 1,
     marginBottom: 24,
     marginTop: 12,
     maxHeight: 200,
     paddingHorizontal: 50,
   },
   text: {
     color: 'black',
     paddingBottom: 12,
   },
 });
 
 const ConnectedCrash: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedCrash(props: BaseProps) {
     const preRequestUserState = useSelector(preRequestUserStateSelector);
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callLogOut = useLogOut();
     const crashReportingEnabled = useIsReportEnabled('crashReports');
     return (
       <Crash
         {...props}
         preRequestUserState={preRequestUserState}
         dispatchActionPromise={dispatchActionPromise}
         logOut={callLogOut}
         crashReportingEnabled={crashReportingEnabled}
       />
     );
   },
 );
 
 export default ConnectedCrash;
diff --git a/native/data/sqlite-data-handler.js b/native/data/sqlite-data-handler.js
index 81b8236bc..ab87f2680 100644
--- a/native/data/sqlite-data-handler.js
+++ b/native/data/sqlite-data-handler.js
@@ -1,235 +1,235 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
 import { reportStoreOpsHandlers } from 'lib/ops/report-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import { userStoreOpsHandlers } from 'lib/ops/user-store-ops.js';
 import {
   cookieSelector,
   urlPrefixSelector,
 } from 'lib/selectors/keyserver-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { useInitialNotificationsEncryptedMessage } from 'lib/shared/crypto-utils.js';
 import {
   logInActionSources,
   type LogInActionSource,
 } from 'lib/types/account-types.js';
 import { fetchNewCookieFromNativeCredentials } from 'lib/utils/action-utils.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import { filesystemMediaCache } from '../media/media-cache.js';
 import { commCoreModule } from '../native-modules.js';
 import { setStoreLoadedActionType } from '../redux/action-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { StaffContext } from '../staff/staff-context.js';
 import Alert from '../utils/alert.js';
 import { nativeNotificationsSessionCreator } from '../utils/crypto-utils.js';
 import { isTaskCancelledError } from '../utils/error-handling.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 async function clearSensitiveData() {
   await commCoreModule.clearSensitiveData();
   try {
     await filesystemMediaCache.clearCache();
   } catch {
     throw new Error('clear_media_cache_failed');
   }
 }
 
 function SQLiteDataHandler(): React.Node {
   const storeLoaded = useSelector(state => state.storeLoaded);
 
   const dispatch = useDispatch();
   const rehydrateConcluded = useSelector(
     state => !!(state._persist && state._persist.rehydrated),
   );
   const cookie = useSelector(cookieSelector(ashoatKeyserverID));
   const urlPrefix = useSelector(urlPrefixSelector(ashoatKeyserverID));
   invariant(urlPrefix, "missing urlPrefix for ashoat's keyserver");
   const staffCanSee = useStaffCanSee();
   const { staffUserHasBeenLoggedIn } = React.useContext(StaffContext);
   const loggedIn = useSelector(isLoggedIn);
   const currentLoggedInUserID = useSelector(state =>
     state.currentUserInfo?.anonymous ? undefined : state.currentUserInfo?.id,
   );
   const mediaCacheContext = React.useContext(MediaCacheContext);
   const getInitialNotificationsEncryptedMessage =
     useInitialNotificationsEncryptedMessage(nativeNotificationsSessionCreator);
 
   const callFetchNewCookieFromNativeCredentials = React.useCallback(
     async (source: LogInActionSource) => {
       try {
         await fetchNewCookieFromNativeCredentials(
           dispatch,
           cookie,
           urlPrefix,
           source,
           ashoatKeyserverID,
           getInitialNotificationsEncryptedMessage,
         );
         dispatch({ type: setStoreLoadedActionType });
       } catch (fetchCookieException) {
         if (staffCanSee) {
           Alert.alert(
             `Error fetching new cookie from native credentials: ${
               getMessageForException(fetchCookieException) ??
               '{no exception message}'
             }. Please kill the app.`,
           );
         } else {
           commCoreModule.terminate();
         }
       }
     },
     [
       cookie,
       dispatch,
       staffCanSee,
       urlPrefix,
       getInitialNotificationsEncryptedMessage,
     ],
   );
 
   const callClearSensitiveData = React.useCallback(
     async (triggeredBy: string) => {
       await clearSensitiveData();
       console.log(`SQLite database deletion was triggered by ${triggeredBy}`);
     },
     [],
   );
 
   const handleSensitiveData = React.useCallback(async () => {
     try {
       const databaseCurrentUserInfoID = await commCoreModule.getCurrentUserID();
       if (
         databaseCurrentUserInfoID &&
         databaseCurrentUserInfoID !== currentLoggedInUserID
       ) {
         await callClearSensitiveData('change in logged-in user credentials');
       }
       if (currentLoggedInUserID) {
         await commCoreModule.setCurrentUserID(currentLoggedInUserID);
       }
     } catch (e) {
       if (isTaskCancelledError(e)) {
         return;
       }
       if (__DEV__) {
         throw e;
       }
       console.log(e);
       if (e.message !== 'clear_media_cache_failed') {
         commCoreModule.terminate();
       }
     }
   }, [callClearSensitiveData, currentLoggedInUserID]);
 
   React.useEffect(() => {
     if (!rehydrateConcluded) {
       return;
     }
 
     const databaseNeedsDeletion = commCoreModule.checkIfDatabaseNeedsDeletion();
     if (databaseNeedsDeletion) {
-      (async () => {
+      void (async () => {
         try {
           await callClearSensitiveData('detecting corrupted database');
         } catch (e) {
           if (__DEV__) {
             throw e;
           }
           console.log(e);
           if (e.message !== 'clear_media_cache_failed') {
             commCoreModule.terminate();
           }
         }
         await callFetchNewCookieFromNativeCredentials(
           logInActionSources.corruptedDatabaseDeletion,
         );
       })();
       return;
     }
 
     const sensitiveDataHandled = handleSensitiveData();
     if (storeLoaded) {
       return;
     }
     if (!loggedIn) {
       dispatch({ type: setStoreLoadedActionType });
       return;
     }
-    (async () => {
+    void (async () => {
       await Promise.all([
         sensitiveDataHandled,
         mediaCacheContext?.evictCache(),
       ]);
       try {
         const {
           threads,
           messages,
           drafts,
           messageStoreThreads,
           reports,
           users,
         } = await commCoreModule.getClientDBStore();
         const threadInfosFromDB =
           threadStoreOpsHandlers.translateClientDBData(threads);
         const reportsFromDb =
           reportStoreOpsHandlers.translateClientDBData(reports);
         const usersFromDb = userStoreOpsHandlers.translateClientDBData(users);
 
         dispatch({
           type: setClientDBStoreActionType,
           payload: {
             drafts,
             messages,
             threadStore: { threadInfos: threadInfosFromDB },
             currentUserID: currentLoggedInUserID,
             messageStoreThreads,
             reports: reportsFromDb,
             users: usersFromDb,
           },
         });
       } catch (setStoreException) {
         if (isTaskCancelledError(setStoreException)) {
           dispatch({ type: setStoreLoadedActionType });
           return;
         }
         if (staffCanSee) {
           Alert.alert(
             'Error setting threadStore or messageStore',
             getMessageForException(setStoreException) ??
               '{no exception message}',
           );
         }
         await callFetchNewCookieFromNativeCredentials(
           logInActionSources.sqliteLoadFailure,
         );
       }
     })();
   }, [
     currentLoggedInUserID,
     handleSensitiveData,
     loggedIn,
     cookie,
     dispatch,
     rehydrateConcluded,
     staffCanSee,
     storeLoaded,
     urlPrefix,
     staffUserHasBeenLoggedIn,
     callFetchNewCookieFromNativeCredentials,
     callClearSensitiveData,
     mediaCacheContext,
   ]);
 
   return null;
 }
 
 export { SQLiteDataHandler, clearSensitiveData };
diff --git a/native/input/input-state-container.react.js b/native/input/input-state-container.react.js
index 6912baace..6455cd054 100644
--- a/native/input/input-state-container.react.js
+++ b/native/input/input-state-container.react.js
@@ -1,1752 +1,1752 @@
 // @flow
 
 import * as FileSystem from 'expo-file-system';
 import invariant from 'invariant';
 import * as React from 'react';
 import { Platform } from 'react-native';
 import { createSelector } from 'reselect';
 
 import {
   createLocalMessageActionType,
   sendMultimediaMessageActionTypes,
   useSendMultimediaMessage,
   sendTextMessageActionTypes,
   useSendTextMessage,
 } from 'lib/actions/message-actions.js';
 import type {
   SendMultimediaMessageInput,
   SendTextMessageInput,
 } from 'lib/actions/message-actions.js';
 import { queueReportsActionType } from 'lib/actions/report-actions.js';
 import { useNewThread } from 'lib/actions/thread-actions.js';
 import {
   uploadMultimedia,
   updateMultimediaMessageMediaActionType,
   useBlobServiceUpload,
   type MultimediaUploadCallbacks,
   type MultimediaUploadExtras,
   type BlobServiceUploadAction,
   type BlobServiceUploadResult,
 } from 'lib/actions/upload-actions.js';
 import commStaffCommunity from 'lib/facts/comm-staff-community.js';
 import { pathFromURI, replaceExtension } from 'lib/media/file-utils.js';
 import {
   isLocalUploadID,
   getNextLocalUploadID,
 } from 'lib/media/media-utils.js';
 import { videoDurationLimit } from 'lib/media/video-utils.js';
 import {
   createLoadingStatusSelector,
   combineLoadingStatuses,
 } from 'lib/selectors/loading-selectors.js';
 import {
   createMediaMessageInfo,
   useNextLocalID,
   useMessageCreationSideEffectsFunc,
 } from 'lib/shared/message-utils.js';
 import type { CreationSideEffectsFunc } from 'lib/shared/messages/message-spec.js';
 import {
   createRealThreadFromPendingThread,
   threadIsPending,
   threadIsPendingSidebar,
   patchThreadInfoToIncludeMentionedMembersOfParent,
   threadInfoInsideCommunity,
 } from 'lib/shared/thread-utils.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import type {
   UploadMultimediaResult,
   Media,
   NativeMediaSelection,
   MediaMissionResult,
   MediaMission,
   MediaMissionStep,
 } from 'lib/types/media-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
   type RawMessageInfo,
   type RawMultimediaMessageInfo,
   type SendMessageResult,
   type SendMessagePayload,
 } from 'lib/types/message-types.js';
 import type { RawImagesMessageInfo } from 'lib/types/messages/images.js';
 import type { RawMediaMessageInfo } from 'lib/types/messages/media.js';
 import { getMediaMessageServerDBContentsFromMedia } from 'lib/types/messages/media.js';
 import type { RawTextMessageInfo } from 'lib/types/messages/text.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import {
   type ClientMediaMissionReportCreationRequest,
   reportTypes,
 } from 'lib/types/report-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import {
   type ClientNewThreadRequest,
   type NewThreadResult,
   type ThreadInfo,
 } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import type {
   CallServerEndpointOptions,
   CallServerEndpointResponse,
 } from 'lib/utils/call-server-endpoint.js';
 import { getConfig } from 'lib/utils/config.js';
 import { getMessageForException, cloneError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import {
   generateReportID,
   useIsReportEnabled,
 } from 'lib/utils/report-utils.js';
 
 import {
   type EditInputBarMessageParameters,
   InputStateContext,
   type PendingMultimediaUploads,
   type MultimediaProcessingStep,
   type MessagePendingUploads,
   type InputState,
 } from './input-state.js';
 import { encryptMedia } from '../media/encryption-utils.js';
 import { disposeTempFile } from '../media/file-utils.js';
 import { processMedia } from '../media/media-utils.js';
 import { displayActionResultModal } from '../navigation/action-result-modal.js';
 import { useCalendarQuery } from '../navigation/nav-selectors.js';
 import { useSelector } from '../redux/redux-utils.js';
 import blobServiceUploadHandler from '../utils/blob-service-upload.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 type MediaIDs =
   | { +type: 'photo', +localMediaID: string }
   | { +type: 'video', +localMediaID: string, +localThumbnailID: string };
 type UploadFileInput = {
   +selection: NativeMediaSelection,
   +ids: MediaIDs,
 };
 type WritableCompletedUploads = {
   [localMessageID: string]: ?$ReadOnlySet<string>,
 };
 type CompletedUploads = $ReadOnly<WritableCompletedUploads>;
 type ActiveURI = { +count: number, +onClear: $ReadOnlyArray<() => mixed> };
 
 type BaseProps = {
   +children: React.Node,
 };
 type Props = {
   ...BaseProps,
   +viewerID: ?string,
   +nextLocalID: string,
   +messageStoreMessages: { +[id: string]: RawMessageInfo },
   +ongoingMessageCreation: boolean,
   +hasWiFi: boolean,
   +mediaReportsEnabled: boolean,
   +calendarQuery: () => CalendarQuery,
   +dispatch: Dispatch,
   +staffCanSee: boolean,
   +dispatchActionPromise: DispatchActionPromise,
   +uploadMultimedia: (
     multimedia: Object,
     extras: MultimediaUploadExtras,
     callbacks: MultimediaUploadCallbacks,
   ) => Promise<UploadMultimediaResult>,
   +blobServiceUpload: BlobServiceUploadAction,
   +sendMultimediaMessage: (
     input: SendMultimediaMessageInput,
   ) => Promise<SendMessageResult>,
   +sendTextMessage: (input: SendTextMessageInput) => Promise<SendMessageResult>,
   +newThread: (request: ClientNewThreadRequest) => Promise<NewThreadResult>,
   +textMessageCreationSideEffectsFunc: CreationSideEffectsFunc<RawTextMessageInfo>,
 };
 type State = {
   +pendingUploads: PendingMultimediaUploads,
 };
 class InputStateContainer extends React.PureComponent<Props, State> {
   state: State = {
     pendingUploads: {},
   };
   sendCallbacks: Array<() => void> = [];
   activeURIs: Map<string, ActiveURI> = new Map();
   editInputBarCallbacks: Array<
     (params: EditInputBarMessageParameters) => void,
   > = [];
   scrollToMessageCallbacks: Array<(messageID: string) => void> = [];
   pendingThreadCreations: Map<string, Promise<string>> = new Map();
   pendingThreadUpdateHandlers: Map<string, (ThreadInfo) => mixed> = new Map();
   // TODO: flip the switch
   // Note that this enables Blob service for encrypted media only
   useBlobServiceUploads = false;
 
   // When the user sends a multimedia message that triggers the creation of a
   // sidebar, the sidebar gets created right away, but the message needs to wait
   // for the uploads to complete before sending. We use this Set to track the
   // message localIDs that need sidebarCreation: true.
   pendingSidebarCreationMessageLocalIDs: Set<string> = new Set();
 
   static getCompletedUploads(props: Props, state: State): CompletedUploads {
     const completedUploads: WritableCompletedUploads = {};
     for (const localMessageID in state.pendingUploads) {
       const messagePendingUploads = state.pendingUploads[localMessageID];
       const rawMessageInfo = props.messageStoreMessages[localMessageID];
       if (!rawMessageInfo) {
         continue;
       }
       invariant(
         rawMessageInfo.type === messageTypes.IMAGES ||
           rawMessageInfo.type === messageTypes.MULTIMEDIA,
         `rawMessageInfo ${localMessageID} should be multimedia`,
       );
 
       let allUploadsComplete = true;
       const completedUploadIDs = new Set(Object.keys(messagePendingUploads));
       for (const singleMedia of rawMessageInfo.media) {
         if (isLocalUploadID(singleMedia.id)) {
           allUploadsComplete = false;
           completedUploadIDs.delete(singleMedia.id);
         }
       }
 
       if (allUploadsComplete) {
         completedUploads[localMessageID] = null;
       } else if (completedUploadIDs.size > 0) {
         completedUploads[localMessageID] = completedUploadIDs;
       }
     }
     return completedUploads;
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (this.props.viewerID !== prevProps.viewerID) {
       this.setState({ pendingUploads: {} });
       return;
     }
 
     const currentlyComplete = InputStateContainer.getCompletedUploads(
       this.props,
       this.state,
     );
     const previouslyComplete = InputStateContainer.getCompletedUploads(
       prevProps,
       prevState,
     );
 
     const newPendingUploads: PendingMultimediaUploads = {};
     let pendingUploadsChanged = false;
     const readyMessageIDs = [];
     for (const localMessageID in this.state.pendingUploads) {
       const messagePendingUploads = this.state.pendingUploads[localMessageID];
       const prevRawMessageInfo = prevProps.messageStoreMessages[localMessageID];
       const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
       const completedUploadIDs = currentlyComplete[localMessageID];
       const previouslyCompletedUploadIDs = previouslyComplete[localMessageID];
 
       if (!rawMessageInfo && prevRawMessageInfo) {
         pendingUploadsChanged = true;
         continue;
       } else if (completedUploadIDs === null) {
         // All of this message's uploads have been completed
         newPendingUploads[localMessageID] = {};
         if (previouslyCompletedUploadIDs !== null) {
           readyMessageIDs.push(localMessageID);
           pendingUploadsChanged = true;
         }
         continue;
       } else if (!completedUploadIDs) {
         // Nothing has been completed
         newPendingUploads[localMessageID] = messagePendingUploads;
         continue;
       }
 
       const newUploads: MessagePendingUploads = {};
       let uploadsChanged = false;
       for (const localUploadID in messagePendingUploads) {
         if (!completedUploadIDs.has(localUploadID)) {
           newUploads[localUploadID] = messagePendingUploads[localUploadID];
         } else if (
           !previouslyCompletedUploadIDs ||
           !previouslyCompletedUploadIDs.has(localUploadID)
         ) {
           uploadsChanged = true;
         }
       }
 
       if (uploadsChanged) {
         pendingUploadsChanged = true;
         newPendingUploads[localMessageID] = newUploads;
       } else {
         newPendingUploads[localMessageID] = messagePendingUploads;
       }
     }
     if (pendingUploadsChanged) {
       this.setState({ pendingUploads: newPendingUploads });
     }
 
     for (const localMessageID of readyMessageIDs) {
       const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
       if (!rawMessageInfo) {
         continue;
       }
       invariant(
         rawMessageInfo.type === messageTypes.IMAGES ||
           rawMessageInfo.type === messageTypes.MULTIMEDIA,
         `rawMessageInfo ${localMessageID} should be multimedia`,
       );
-      this.dispatchMultimediaMessageAction(rawMessageInfo);
+      void this.dispatchMultimediaMessageAction(rawMessageInfo);
     }
   }
 
   async dispatchMultimediaMessageAction(
     messageInfo: RawMultimediaMessageInfo,
   ): Promise<void> {
     if (!threadIsPending(messageInfo.threadID)) {
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         sendMultimediaMessageActionTypes,
         this.sendMultimediaMessageAction(messageInfo),
         undefined,
         messageInfo,
       );
       return;
     }
 
     this.props.dispatch({
       type: sendMultimediaMessageActionTypes.started,
       payload: messageInfo,
     });
 
     let newThreadID = null;
     try {
       const threadCreationPromise = this.pendingThreadCreations.get(
         messageInfo.threadID,
       );
       if (!threadCreationPromise) {
         // When we create or retry multimedia message, we add a promise to
         // pendingThreadCreations map. This promise can be removed in
         // sendMultimediaMessage and sendTextMessage methods. When any of these
         // method remove the promise, it has to be settled. If the promise was
         // fulfilled, this method would be called with realized thread, so we
         // can conclude that the promise was rejected. We don't have enough info
         // here to retry the thread creation, but we can mark the message as
         // failed. Then the retry will be possible and promise will be created
         // again.
         throw new Error('Thread creation failed');
       }
       newThreadID = await threadCreationPromise;
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = messageInfo.localID;
       copy.threadID = messageInfo.threadID;
       this.props.dispatch({
         type: sendMultimediaMessageActionTypes.failed,
         payload: copy,
         error: true,
       });
       return;
     } finally {
       this.pendingThreadCreations.delete(messageInfo.threadID);
     }
 
     const newMessageInfo = {
       ...messageInfo,
       threadID: newThreadID,
       time: Date.now(),
     };
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       sendMultimediaMessageActionTypes,
       this.sendMultimediaMessageAction(newMessageInfo),
       undefined,
       newMessageInfo,
     );
   }
 
   async sendMultimediaMessageAction(
     messageInfo: RawMultimediaMessageInfo,
   ): Promise<SendMessagePayload> {
     const { localID, threadID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should be set',
     );
     const sidebarCreation =
       this.pendingSidebarCreationMessageLocalIDs.has(localID);
     const mediaMessageContents = getMediaMessageServerDBContentsFromMedia(
       messageInfo.media,
     );
     try {
       const result = await this.props.sendMultimediaMessage({
         threadID,
         localID,
         mediaMessageContents,
         sidebarCreation,
       });
       this.pendingSidebarCreationMessageLocalIDs.delete(localID);
       return {
         localID,
         serverID: result.id,
         threadID,
         time: result.time,
         interface: result.interface,
       };
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = localID;
       copy.threadID = threadID;
       throw copy;
     }
   }
 
   inputStateSelector: State => InputState = createSelector(
     (state: State) => state.pendingUploads,
     (pendingUploads: PendingMultimediaUploads) =>
       ({
         pendingUploads,
         sendTextMessage: this.sendTextMessage,
         sendMultimediaMessage: this.sendMultimediaMessage,
         editInputMessage: this.editInputMessage,
         addEditInputMessageListener: this.addEditInputMessageListener,
         removeEditInputMessageListener: this.removeEditInputMessageListener,
         messageHasUploadFailure: this.messageHasUploadFailure,
         retryMessage: this.retryMessage,
         registerSendCallback: this.registerSendCallback,
         unregisterSendCallback: this.unregisterSendCallback,
         uploadInProgress: this.uploadInProgress,
         reportURIDisplayed: this.reportURIDisplayed,
         setPendingThreadUpdateHandler: this.setPendingThreadUpdateHandler,
         scrollToMessage: this.scrollToMessage,
         addScrollToMessageListener: this.addScrollToMessageListener,
         removeScrollToMessageListener: this.removeScrollToMessageListener,
       }: InputState),
   );
 
   scrollToMessage = (messageID: string) => {
     this.scrollToMessageCallbacks.forEach(callback => callback(messageID));
   };
 
   addScrollToMessageListener = (callback: (messageID: string) => void) => {
     this.scrollToMessageCallbacks.push(callback);
   };
 
   removeScrollToMessageListener = (
     callbackScrollToMessage: (messageID: string) => void,
   ) => {
     this.scrollToMessageCallbacks = this.scrollToMessageCallbacks.filter(
       candidate => candidate !== callbackScrollToMessage,
     );
   };
 
   uploadInProgress = (): boolean => {
     if (this.props.ongoingMessageCreation) {
       return true;
     }
     const { pendingUploads } = this.state;
     return values(pendingUploads).some(messagePendingUploads =>
       values(messagePendingUploads).some(upload => !upload.failed),
     );
   };
 
   sendTextMessage = async (
     messageInfo: RawTextMessageInfo,
     inputThreadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ) => {
     this.sendCallbacks.forEach(callback => callback());
 
     const { localID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should be set',
     );
     if (threadIsPendingSidebar(inputThreadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localID);
     }
 
     if (!threadIsPending(inputThreadInfo.id)) {
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         sendTextMessageActionTypes,
         this.sendTextMessageAction(
           messageInfo,
           inputThreadInfo,
           parentThreadInfo,
         ),
         undefined,
         messageInfo,
       );
       return;
     }
 
     this.props.dispatch({
       type: sendTextMessageActionTypes.started,
       payload: messageInfo,
     });
 
     let threadInfo = inputThreadInfo;
     const { viewerID } = this.props;
     if (viewerID && inputThreadInfo.type === threadTypes.SIDEBAR) {
       invariant(parentThreadInfo, 'sidebar should have parent');
       threadInfo = patchThreadInfoToIncludeMentionedMembersOfParent(
         inputThreadInfo,
         parentThreadInfo,
         messageInfo.text,
         viewerID,
       );
       if (threadInfo !== inputThreadInfo) {
         const pendingThreadUpdateHandler = this.pendingThreadUpdateHandlers.get(
           threadInfo.id,
         );
         pendingThreadUpdateHandler?.(threadInfo);
       }
     }
 
     let newThreadID = null;
     try {
       newThreadID = await this.startThreadCreation(threadInfo);
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = messageInfo.localID;
       copy.threadID = messageInfo.threadID;
       this.props.dispatch({
         type: sendTextMessageActionTypes.failed,
         payload: copy,
         error: true,
       });
       return;
     } finally {
       this.pendingThreadCreations.delete(threadInfo.id);
     }
 
     const newMessageInfo = {
       ...messageInfo,
       threadID: newThreadID,
       time: Date.now(),
     };
 
     // Branching to appease `flow`.
     const newThreadInfo = threadInfo.minimallyEncoded
       ? {
           ...threadInfo,
           id: newThreadID,
         }
       : {
           ...threadInfo,
           id: newThreadID,
         };
 
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       sendTextMessageActionTypes,
       this.sendTextMessageAction(
         newMessageInfo,
         newThreadInfo,
         parentThreadInfo,
       ),
       undefined,
       newMessageInfo,
     );
   };
 
   startThreadCreation(threadInfo: ThreadInfo): Promise<string> {
     if (!threadIsPending(threadInfo.id)) {
       return Promise.resolve(threadInfo.id);
     }
     let threadCreationPromise = this.pendingThreadCreations.get(threadInfo.id);
     if (!threadCreationPromise) {
       const calendarQuery = this.props.calendarQuery();
       threadCreationPromise = createRealThreadFromPendingThread({
         threadInfo,
         dispatchActionPromise: this.props.dispatchActionPromise,
         createNewThread: this.props.newThread,
         sourceMessageID: threadInfo.sourceMessageID,
         viewerID: this.props.viewerID,
         calendarQuery,
       });
       this.pendingThreadCreations.set(threadInfo.id, threadCreationPromise);
     }
     return threadCreationPromise;
   }
 
   async sendTextMessageAction(
     messageInfo: RawTextMessageInfo,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ): Promise<SendMessagePayload> {
     try {
       await this.props.textMessageCreationSideEffectsFunc(
         messageInfo,
         threadInfo,
         parentThreadInfo,
       );
       const { localID } = messageInfo;
       invariant(
         localID !== null && localID !== undefined,
         'localID should be set',
       );
       const sidebarCreation =
         this.pendingSidebarCreationMessageLocalIDs.has(localID);
       const result = await this.props.sendTextMessage({
         threadID: messageInfo.threadID,
         localID,
         text: messageInfo.text,
         sidebarCreation,
       });
       this.pendingSidebarCreationMessageLocalIDs.delete(localID);
       return {
         localID,
         serverID: result.id,
         threadID: messageInfo.threadID,
         time: result.time,
         interface: result.interface,
       };
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = messageInfo.localID;
       copy.threadID = messageInfo.threadID;
       throw copy;
     }
   }
 
   shouldEncryptMedia(threadInfo: ThreadInfo): boolean {
     return threadInfoInsideCommunity(threadInfo, commStaffCommunity.id);
   }
 
   sendMultimediaMessage = async (
     selections: $ReadOnlyArray<NativeMediaSelection>,
     threadInfo: ThreadInfo,
   ) => {
     this.sendCallbacks.forEach(callback => callback());
     const localMessageID = this.props.nextLocalID;
-    this.startThreadCreation(threadInfo);
+    void this.startThreadCreation(threadInfo);
 
     if (threadIsPendingSidebar(threadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localMessageID);
     }
 
     const uploadFileInputs = [],
       media: Array<Media> = [];
     for (const selection of selections) {
       const localMediaID = getNextLocalUploadID();
       let ids;
       if (
         selection.step === 'photo_library' ||
         selection.step === 'photo_capture' ||
         selection.step === 'photo_paste'
       ) {
         media.push({
           id: localMediaID,
           uri: selection.uri,
           type: 'photo',
           dimensions: selection.dimensions,
           localMediaSelection: selection,
           thumbHash: null,
         });
         ids = { type: 'photo', localMediaID };
       }
       const localThumbnailID = getNextLocalUploadID();
       if (selection.step === 'video_library') {
         media.push({
           id: localMediaID,
           uri: selection.uri,
           type: 'video',
           dimensions: selection.dimensions,
           localMediaSelection: selection,
           loop: false,
           thumbnailID: localThumbnailID,
           thumbnailURI: selection.uri,
           thumbnailThumbHash: null,
         });
         ids = { type: 'video', localMediaID, localThumbnailID };
       }
       invariant(ids, `unexpected MediaSelection ${selection.step}`);
       uploadFileInputs.push({ selection, ids });
     }
 
     const pendingUploads: MessagePendingUploads = {};
     for (const uploadFileInput of uploadFileInputs) {
       const { localMediaID } = uploadFileInput.ids;
       pendingUploads[localMediaID] = {
         failed: false,
         progressPercent: 0,
         processingStep: null,
       };
       if (uploadFileInput.ids.type === 'video') {
         const { localThumbnailID } = uploadFileInput.ids;
         pendingUploads[localThumbnailID] = {
           failed: false,
           progressPercent: 0,
           processingStep: null,
         };
       }
     }
 
     this.setState(
       prevState => {
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [localMessageID]: pendingUploads,
           },
         };
       },
       () => {
         const creatorID = this.props.viewerID;
         invariant(creatorID, 'need viewer ID in order to send a message');
         const messageInfo = createMediaMessageInfo(
           {
             localID: localMessageID,
             threadID: threadInfo.id,
             creatorID,
             media,
           },
           { forceMultimediaMessageType: this.shouldEncryptMedia(threadInfo) },
         );
         this.props.dispatch({
           type: createLocalMessageActionType,
           payload: messageInfo,
         });
       },
     );
 
     await this.uploadFiles(localMessageID, uploadFileInputs, threadInfo);
   };
 
   async uploadFiles(
     localMessageID: string,
     uploadFileInputs: $ReadOnlyArray<UploadFileInput>,
     threadInfo: ThreadInfo,
   ) {
     const results = await Promise.all(
       uploadFileInputs.map(uploadFileInput =>
         this.uploadFile(localMessageID, uploadFileInput, threadInfo),
       ),
     );
     const errors = [...new Set(results.filter(Boolean))];
     if (errors.length > 0) {
       displayActionResultModal(errors.join(', ') + ' :(');
     }
   }
 
   async uploadFile(
     localMessageID: string,
     uploadFileInput: UploadFileInput,
     threadInfo: ThreadInfo,
   ): Promise<?string> {
     const { ids, selection } = uploadFileInput;
     const { localMediaID } = ids;
     const start = selection.sendTime;
     const steps: Array<MediaMissionStep> = [selection];
     let encryptionSteps: $ReadOnlyArray<MediaMissionStep> = [];
     let serverID;
     let userTime;
     let errorMessage;
     let reportPromise: ?Promise<$ReadOnlyArray<MediaMissionStep>>;
     const filesToDispose = [];
 
     const onUploadFinished = async (result: MediaMissionResult) => {
       if (!this.props.mediaReportsEnabled) {
         return errorMessage;
       }
       if (reportPromise) {
         const finalSteps = await reportPromise;
         steps.push(...finalSteps);
         steps.push(...encryptionSteps);
       }
       const totalTime = Date.now() - start;
       userTime = userTime ? userTime : totalTime;
       this.queueMediaMissionReport(
         { localID: localMediaID, localMessageID, serverID },
         { steps, result, totalTime, userTime },
       );
       return errorMessage;
     };
     const onUploadFailed = (mediaID: string, message: string) => {
       errorMessage = message;
       this.handleUploadFailure(localMessageID, mediaID);
       userTime = Date.now() - start;
     };
 
     const onTranscodingProgress = (percent: number) => {
       this.setProgress(localMessageID, localMediaID, 'transcoding', percent);
     };
 
     let processedMedia;
     const processingStart = Date.now();
     try {
       const processMediaReturn = processMedia(selection, {
         hasWiFi: this.props.hasWiFi,
         finalFileHeaderCheck: this.props.staffCanSee,
         onTranscodingProgress,
       });
       reportPromise = processMediaReturn.reportPromise;
       const processResult = await processMediaReturn.resultPromise;
       if (!processResult.success) {
         const message =
           processResult.reason === 'video_too_long'
             ? `can't do vids longer than ${videoDurationLimit}min`
             : 'processing failed';
         onUploadFailed(localMediaID, message);
         return await onUploadFinished(processResult);
       }
       if (processResult.shouldDisposePath) {
         filesToDispose.push(processResult.shouldDisposePath);
       }
       processedMedia = processResult;
     } catch (e) {
       onUploadFailed(localMediaID, 'processing failed');
       return await onUploadFinished({
         success: false,
         reason: 'processing_exception',
         time: Date.now() - processingStart,
         exceptionMessage: getMessageForException(e),
       });
     }
 
     if (this.shouldEncryptMedia(threadInfo)) {
       const encryptionStart = Date.now();
       try {
         const { result: encryptionResult, ...encryptionReturn } =
           await encryptMedia(processedMedia);
         encryptionSteps = encryptionReturn.steps;
         if (!encryptionResult.success) {
           onUploadFailed(localMediaID, encryptionResult.reason);
           return await onUploadFinished(encryptionResult);
         }
         if (encryptionResult.shouldDisposePath) {
           filesToDispose.push(encryptionResult.shouldDisposePath);
         }
         processedMedia = encryptionResult;
       } catch (e) {
         onUploadFailed(localMediaID, 'encryption failed');
         return await onUploadFinished({
           success: false,
           reason: 'encryption_exception',
           time: Date.now() - encryptionStart,
           exceptionMessage: getMessageForException(e),
         });
       }
     }
 
     const { uploadURI, filename, mime } = processedMedia;
 
     const { hasWiFi } = this.props;
 
     const uploadStart = Date.now();
     let uploadExceptionMessage,
       uploadResult,
       uploadThumbnailResult,
       mediaMissionResult;
     try {
       if (
         this.useBlobServiceUploads &&
         (processedMedia.mediaType === 'encrypted_photo' ||
           processedMedia.mediaType === 'encrypted_video')
       ) {
         const uploadPromise = this.props.blobServiceUpload({
           uploadInput: {
             blobInput: {
               type: 'uri',
               uri: uploadURI,
               filename: filename,
               mimeType: mime,
             },
             blobHash: processedMedia.blobHash,
             encryptionKey: processedMedia.encryptionKey,
             dimensions: processedMedia.dimensions,
             thumbHash:
               processedMedia.mediaType === 'encrypted_photo'
                 ? processedMedia.thumbHash
                 : null,
           },
           keyserverOrThreadID: threadInfo.id,
           callbacks: {
             blobServiceUploadHandler,
             onProgress: (percent: number) => {
               this.setProgress(
                 localMessageID,
                 localMediaID,
                 'uploading',
                 percent,
               );
             },
           },
         });
 
         const uploadThumbnailPromise: Promise<?BlobServiceUploadResult> =
           (async () => {
             if (processedMedia.mediaType !== 'encrypted_video') {
               return undefined;
             }
             return await this.props.blobServiceUpload({
               uploadInput: {
                 blobInput: {
                   type: 'uri',
                   uri: processedMedia.uploadThumbnailURI,
                   filename: replaceExtension(`thumb${filename}`, 'jpg'),
                   mimeType: 'image/jpeg',
                 },
                 blobHash: processedMedia.thumbnailBlobHash,
                 encryptionKey: processedMedia.thumbnailEncryptionKey,
                 loop: false,
                 dimensions: processedMedia.dimensions,
                 thumbHash: processedMedia.thumbHash,
               },
               keyserverOrThreadID: threadInfo.id,
               callbacks: {
                 blobServiceUploadHandler,
               },
             });
           })();
 
         [uploadResult, uploadThumbnailResult] = await Promise.all([
           uploadPromise,
           uploadThumbnailPromise,
         ]);
       } else {
         const uploadPromise = this.props.uploadMultimedia(
           { uri: uploadURI, name: filename, type: mime },
           {
             ...processedMedia.dimensions,
             loop:
               processedMedia.mediaType === 'video' ||
               processedMedia.mediaType === 'encrypted_video'
                 ? processedMedia.loop
                 : undefined,
             encryptionKey: processedMedia.encryptionKey,
             thumbHash:
               processedMedia.mediaType === 'photo' ||
               processedMedia.mediaType === 'encrypted_photo'
                 ? processedMedia.thumbHash
                 : null,
           },
           {
             onProgress: (percent: number) =>
               this.setProgress(
                 localMessageID,
                 localMediaID,
                 'uploading',
                 percent,
               ),
             uploadBlob: this.uploadBlob,
           },
         );
 
         const uploadThumbnailPromise: Promise<?UploadMultimediaResult> =
           (async () => {
             if (
               processedMedia.mediaType !== 'video' &&
               processedMedia.mediaType !== 'encrypted_video'
             ) {
               return undefined;
             }
             return await this.props.uploadMultimedia(
               {
                 uri: processedMedia.uploadThumbnailURI,
                 name: replaceExtension(`thumb${filename}`, 'jpg'),
                 type: 'image/jpeg',
               },
               {
                 ...processedMedia.dimensions,
                 loop: false,
                 encryptionKey: processedMedia.thumbnailEncryptionKey,
                 thumbHash: processedMedia.thumbHash,
               },
               {
                 uploadBlob: this.uploadBlob,
               },
             );
           })();
 
         [uploadResult, uploadThumbnailResult] = await Promise.all([
           uploadPromise,
           uploadThumbnailPromise,
         ]);
       }
       mediaMissionResult = { success: true };
     } catch (e) {
       uploadExceptionMessage = getMessageForException(e);
       onUploadFailed(localMediaID, 'upload failed');
       mediaMissionResult = {
         success: false,
         reason: 'http_upload_failed',
         exceptionMessage: uploadExceptionMessage,
       };
     }
 
     if (
       ((processedMedia.mediaType === 'photo' ||
         processedMedia.mediaType === 'encrypted_photo') &&
         uploadResult) ||
       ((processedMedia.mediaType === 'video' ||
         processedMedia.mediaType === 'encrypted_video') &&
         uploadResult &&
         uploadThumbnailResult)
     ) {
       const { encryptionKey } = processedMedia;
       const { id, uri, dimensions, loop } = uploadResult;
       serverID = id;
 
       const mediaSourcePayload =
         processedMedia.mediaType === 'encrypted_photo' ||
         processedMedia.mediaType === 'encrypted_video'
           ? {
               type: processedMedia.mediaType,
               blobURI: uri,
               encryptionKey,
             }
           : {
               type: uploadResult.mediaType,
               uri,
             };
       let updateMediaPayload = {
         messageID: localMessageID,
         currentMediaID: localMediaID,
         mediaUpdate: {
           id,
           ...mediaSourcePayload,
           dimensions,
           localMediaSelection: undefined,
           loop: uploadResult.mediaType === 'video' ? loop : undefined,
         },
       };
 
       if (
         processedMedia.mediaType === 'video' ||
         processedMedia.mediaType === 'encrypted_video'
       ) {
         invariant(uploadThumbnailResult, 'uploadThumbnailResult exists');
         const { uri: thumbnailURI, id: thumbnailID } = uploadThumbnailResult;
         const { thumbnailEncryptionKey, thumbHash: thumbnailThumbHash } =
           processedMedia;
 
         if (processedMedia.mediaType === 'encrypted_video') {
           updateMediaPayload = {
             ...updateMediaPayload,
             mediaUpdate: {
               ...updateMediaPayload.mediaUpdate,
               thumbnailID,
               thumbnailBlobURI: thumbnailURI,
               thumbnailEncryptionKey,
               thumbnailThumbHash,
             },
           };
         } else {
           updateMediaPayload = {
             ...updateMediaPayload,
             mediaUpdate: {
               ...updateMediaPayload.mediaUpdate,
               thumbnailID,
               thumbnailURI,
               thumbnailThumbHash,
             },
           };
         }
       } else {
         updateMediaPayload = {
           ...updateMediaPayload,
           mediaUpdate: {
             ...updateMediaPayload.mediaUpdate,
             thumbHash: processedMedia.thumbHash,
           },
         };
       }
 
       // When we dispatch this action, it updates Redux and triggers the
       // componentDidUpdate in this class. componentDidUpdate will handle
       // calling dispatchMultimediaMessageAction once all the uploads are
       // complete, and does not wait until this function concludes.
       this.props.dispatch({
         type: updateMultimediaMessageMediaActionType,
         payload: updateMediaPayload,
       });
       userTime = Date.now() - start;
     }
 
     const processSteps = await reportPromise;
     reportPromise = null;
     steps.push(...processSteps);
     steps.push(...encryptionSteps);
     steps.push({
       step: 'upload',
       success: !!uploadResult,
       exceptionMessage: uploadExceptionMessage,
       time: Date.now() - uploadStart,
       inputFilename: filename,
       outputMediaType: uploadResult && uploadResult.mediaType,
       outputURI: uploadResult && uploadResult.uri,
       outputDimensions: uploadResult && uploadResult.dimensions,
       outputLoop: uploadResult && uploadResult.loop,
       hasWiFi,
     });
 
     const cleanupPromises = [];
 
     if (filesToDispose.length > 0) {
       // If processMedia needed to do any transcoding before upload, we dispose
       // of the resultant temporary file here. Since the transcoded temporary
       // file is only used for upload, we can dispose of it after processMedia
       // (reportPromise) and the upload are complete
       filesToDispose.forEach(shouldDisposePath => {
         cleanupPromises.push(
           (async () => {
             const disposeStep = await disposeTempFile(shouldDisposePath);
             steps.push(disposeStep);
           })(),
         );
       });
     }
 
     // if there's a thumbnail we'll temporarily unlink it here
     // instead of in media-utils, will be changed in later diffs
     if (processedMedia.mediaType === 'video') {
       const { uploadThumbnailURI } = processedMedia;
       cleanupPromises.push(
         (async () => {
           const { steps: clearSteps, result: thumbnailPath } =
             await this.waitForCaptureURIUnload(uploadThumbnailURI);
           steps.push(...clearSteps);
           if (!thumbnailPath) {
             return;
           }
           const disposeStep = await disposeTempFile(thumbnailPath);
           steps.push(disposeStep);
         })(),
       );
     }
 
     if (selection.captureTime || selection.step === 'photo_paste') {
       // If we are uploading a newly captured photo, we dispose of the original
       // file here. Note that we try to save photo captures to the camera roll
       // if we have permission. Even if we fail, this temporary file isn't
       // visible to the user, so there's no point in keeping it around. Since
       // the initial URI is used in rendering paths, we have to wait for it to
       // be replaced with the remote URI before we can dispose. Check out the
       // Multimedia component to see how the URIs get switched out.
       const captureURI = selection.uri;
       cleanupPromises.push(
         (async () => {
           const { steps: clearSteps, result: capturePath } =
             await this.waitForCaptureURIUnload(captureURI);
           steps.push(...clearSteps);
           if (!capturePath) {
             return;
           }
           const disposeStep = await disposeTempFile(capturePath);
           steps.push(disposeStep);
         })(),
       );
     }
 
     await Promise.all(cleanupPromises);
 
     return await onUploadFinished(mediaMissionResult);
   }
 
   setProgress(
     localMessageID: string,
     localUploadID: string,
     processingStep: MultimediaProcessingStep,
     progressPercent: number,
   ) {
     this.setState(prevState => {
       const pendingUploads = prevState.pendingUploads[localMessageID];
       if (!pendingUploads) {
         return {};
       }
       const pendingUpload = pendingUploads[localUploadID];
       if (!pendingUpload) {
         return {};
       }
       const newOutOfHundred = Math.floor(progressPercent * 100);
       const oldOutOfHundred = Math.floor(pendingUpload.progressPercent * 100);
       if (newOutOfHundred === oldOutOfHundred) {
         return {};
       }
       const newPendingUploads = {
         ...pendingUploads,
         [localUploadID]: {
           ...pendingUpload,
           progressPercent,
           processingStep,
         },
       };
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [localMessageID]: newPendingUploads,
         },
       };
     });
   }
 
   uploadBlob = async (
     url: string,
     cookie: ?string,
     sessionID: ?string,
     input: { +[key: string]: mixed },
     options?: ?CallServerEndpointOptions,
   ): Promise<CallServerEndpointResponse> => {
     invariant(
       cookie &&
         input.multimedia &&
         Array.isArray(input.multimedia) &&
         input.multimedia.length === 1 &&
         input.multimedia[0] &&
         typeof input.multimedia[0] === 'object',
       'InputStateContainer.uploadBlob sent incorrect input',
     );
     const { uri, name, type } = input.multimedia[0];
     invariant(
       typeof uri === 'string' &&
         typeof name === 'string' &&
         typeof type === 'string',
       'InputStateContainer.uploadBlob sent incorrect input',
     );
 
     const parameters: { [key: string]: mixed } = {};
     parameters.cookie = cookie;
     parameters.filename = name;
 
     for (const key in input) {
       if (
         key === 'multimedia' ||
         key === 'cookie' ||
         key === 'sessionID' ||
         key === 'filename'
       ) {
         continue;
       }
       const value = input[key];
       invariant(
         typeof value === 'string',
         'blobUpload calls can only handle string values for non-multimedia keys',
       );
       parameters[key] = value;
     }
 
     let path = uri;
     if (Platform.OS === 'android') {
       const resolvedPath = pathFromURI(uri);
       if (resolvedPath) {
         path = resolvedPath;
       }
     }
     const uploadTask = FileSystem.createUploadTask(
       url,
       path,
       {
         uploadType: FileSystem.FileSystemUploadType.MULTIPART,
         fieldName: 'multimedia',
         headers: {
           Accept: 'application/json',
         },
         parameters,
       },
       uploadProgress => {
         if (options && options.onProgress) {
           const { totalByteSent, totalBytesExpectedToSend } = uploadProgress;
           options.onProgress(totalByteSent / totalBytesExpectedToSend);
         }
       },
     );
     if (options && options.abortHandler) {
       options.abortHandler(() => uploadTask.cancelAsync());
     }
     try {
       const response = await uploadTask.uploadAsync();
       return JSON.parse(response.body);
     } catch (e) {
       throw new Error(
         `Failed to upload blob: ${
           getMessageForException(e) ?? 'unknown error'
         }`,
       );
     }
   };
 
   handleUploadFailure(localMessageID: string, localUploadID: string) {
     this.setState(prevState => {
       const uploads = prevState.pendingUploads[localMessageID];
       const upload = uploads[localUploadID];
       if (!upload) {
         // The upload has been completed before it failed
         return {};
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [localMessageID]: {
             ...uploads,
             [localUploadID]: {
               ...upload,
               failed: true,
               progressPercent: 0,
             },
           },
         },
       };
     });
   }
 
   queueMediaMissionReport(
     ids: { localID: string, localMessageID: string, serverID: ?string },
     mediaMission: MediaMission,
   ) {
     const report: ClientMediaMissionReportCreationRequest = {
       type: reportTypes.MEDIA_MISSION,
       time: Date.now(),
       platformDetails: getConfig().platformDetails,
       mediaMission,
       uploadServerID: ids.serverID,
       uploadLocalID: ids.localID,
       messageLocalID: ids.localMessageID,
       id: generateReportID(),
     };
     this.props.dispatch({
       type: queueReportsActionType,
       payload: {
         reports: [report],
       },
     });
   }
 
   messageHasUploadFailure = (localMessageID: string): boolean => {
     const pendingUploads = this.state.pendingUploads[localMessageID];
     if (!pendingUploads) {
       return false;
     }
     return values(pendingUploads).some(upload => upload.failed);
   };
 
   editInputMessage = (params: EditInputBarMessageParameters) => {
     this.editInputBarCallbacks.forEach(addEditInputBarCallback =>
       addEditInputBarCallback(params),
     );
   };
 
   addEditInputMessageListener = (
     callbackEditInputBar: (params: EditInputBarMessageParameters) => void,
   ) => {
     this.editInputBarCallbacks.push(callbackEditInputBar);
   };
 
   removeEditInputMessageListener = (
     callbackEditInputBar: (params: EditInputBarMessageParameters) => void,
   ) => {
     this.editInputBarCallbacks = this.editInputBarCallbacks.filter(
       candidate => candidate !== callbackEditInputBar,
     );
   };
 
   retryTextMessage = async (
     rawMessageInfo: RawTextMessageInfo,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ) => {
     await this.sendTextMessage(
       {
         ...rawMessageInfo,
         time: Date.now(),
       },
       threadInfo,
       parentThreadInfo,
     );
   };
 
   retryMultimediaMessage = async (
     rawMessageInfo: RawMultimediaMessageInfo,
     localMessageID: string,
     threadInfo: ThreadInfo,
   ): Promise<void> => {
     const pendingUploads = this.state.pendingUploads[localMessageID] ?? {};
 
     const now = Date.now();
 
-    this.startThreadCreation(threadInfo);
+    void this.startThreadCreation(threadInfo);
 
     if (threadIsPendingSidebar(threadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localMessageID);
     }
 
     const updateMedia = <T: Media>(media: $ReadOnlyArray<T>): T[] =>
       media.map(singleMedia => {
         invariant(
           singleMedia.type === 'photo' || singleMedia.type === 'video',
           'Retry selection must be unencrypted',
         );
 
         let updatedMedia = singleMedia;
 
         const oldMediaID = updatedMedia.id;
         if (
           // not complete
           isLocalUploadID(oldMediaID) &&
           // not still ongoing
           (!pendingUploads[oldMediaID] || pendingUploads[oldMediaID].failed)
         ) {
           // If we have an incomplete upload that isn't in pendingUploads, that
           // indicates the app has restarted. We'll reassign a new localID to
           // avoid collisions. Note that this isn't necessary for the message ID
           // since the localID reducer prevents collisions there
           const mediaID = pendingUploads[oldMediaID]
             ? oldMediaID
             : getNextLocalUploadID();
           if (updatedMedia.type === 'photo') {
             updatedMedia = {
               type: 'photo',
               ...updatedMedia,
               id: mediaID,
             };
           } else {
             updatedMedia = {
               type: 'video',
               ...updatedMedia,
               id: mediaID,
             };
           }
         }
 
         if (updatedMedia.type === 'video') {
           const oldThumbnailID = updatedMedia.thumbnailID;
           invariant(oldThumbnailID, 'oldThumbnailID not null or undefined');
           if (
             // not complete
             isLocalUploadID(oldThumbnailID) &&
             // not still ongoing
             (!pendingUploads[oldThumbnailID] ||
               pendingUploads[oldThumbnailID].failed)
           ) {
             const thumbnailID = pendingUploads[oldThumbnailID]
               ? oldThumbnailID
               : getNextLocalUploadID();
             updatedMedia = {
               ...updatedMedia,
               thumbnailID,
             };
           }
         }
 
         if (updatedMedia === singleMedia) {
           return singleMedia;
         }
 
         const oldSelection = updatedMedia.localMediaSelection;
         invariant(
           oldSelection,
           'localMediaSelection should be set on locally created Media',
         );
         const retries = oldSelection.retries ? oldSelection.retries + 1 : 1;
 
         // We switch for Flow
         let selection;
         if (oldSelection.step === 'photo_capture') {
           selection = { ...oldSelection, sendTime: now, retries };
         } else if (oldSelection.step === 'photo_library') {
           selection = { ...oldSelection, sendTime: now, retries };
         } else if (oldSelection.step === 'photo_paste') {
           selection = { ...oldSelection, sendTime: now, retries };
         } else {
           selection = { ...oldSelection, sendTime: now, retries };
         }
 
         if (updatedMedia.type === 'photo') {
           return {
             type: 'photo',
             ...updatedMedia,
             localMediaSelection: selection,
           };
         }
         return {
           type: 'video',
           ...updatedMedia,
           localMediaSelection: selection,
         };
       });
 
     let newRawMessageInfo;
     // This conditional is for Flow
     if (rawMessageInfo.type === messageTypes.MULTIMEDIA) {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: now,
         media: updateMedia(rawMessageInfo.media),
       }: RawMediaMessageInfo);
     } else if (rawMessageInfo.type === messageTypes.IMAGES) {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: now,
         media: updateMedia(rawMessageInfo.media),
       }: RawImagesMessageInfo);
     } else {
       invariant(false, `rawMessageInfo ${localMessageID} should be multimedia`);
     }
 
     const incompleteMedia: Media[] = [];
     for (const singleMedia of newRawMessageInfo.media) {
       if (isLocalUploadID(singleMedia.id)) {
         incompleteMedia.push(singleMedia);
       }
     }
     if (incompleteMedia.length === 0) {
-      this.dispatchMultimediaMessageAction(newRawMessageInfo);
+      void this.dispatchMultimediaMessageAction(newRawMessageInfo);
       this.setState(prevState => ({
         pendingUploads: {
           ...prevState.pendingUploads,
           [localMessageID]: {},
         },
       }));
       return;
     }
 
     const retryMedia = incompleteMedia.filter(
       ({ id }) => !pendingUploads[id] || pendingUploads[id].failed,
     );
     if (retryMedia.length === 0) {
       // All media are already in the process of being uploaded
       return;
     }
 
     // We're not actually starting the send here,
     // we just use this action to update the message in Redux
     this.props.dispatch({
       type: sendMultimediaMessageActionTypes.started,
       payload: newRawMessageInfo,
     });
 
     // We clear out the failed status on individual media here,
     // which makes the UI show pending status instead of error messages
     for (const singleMedia of retryMedia) {
       pendingUploads[singleMedia.id] = {
         failed: false,
         progressPercent: 0,
         processingStep: null,
       };
       if (singleMedia.type === 'video') {
         const { thumbnailID } = singleMedia;
         invariant(thumbnailID, 'thumbnailID not null or undefined');
         pendingUploads[thumbnailID] = {
           failed: false,
           progressPercent: 0,
           processingStep: null,
         };
       }
     }
     this.setState(prevState => ({
       pendingUploads: {
         ...prevState.pendingUploads,
         [localMessageID]: pendingUploads,
       },
     }));
 
     const uploadFileInputs = retryMedia.map(singleMedia => {
       invariant(
         singleMedia.localMediaSelection,
         'localMediaSelection should be set on locally created Media',
       );
 
       let ids;
       if (singleMedia.type === 'photo') {
         ids = { type: 'photo', localMediaID: singleMedia.id };
       } else {
         invariant(
           singleMedia.thumbnailID,
           'singleMedia.thumbnailID should be set for videos',
         );
         ids = {
           type: 'video',
           localMediaID: singleMedia.id,
           localThumbnailID: singleMedia.thumbnailID,
         };
       }
 
       return {
         selection: singleMedia.localMediaSelection,
         ids,
       };
     });
 
     await this.uploadFiles(localMessageID, uploadFileInputs, threadInfo);
   };
 
   retryMessage = async (
     localMessageID: string,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ) => {
     this.sendCallbacks.forEach(callback => callback());
 
     const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
     invariant(rawMessageInfo, `rawMessageInfo ${localMessageID} should exist`);
 
     if (rawMessageInfo.type === messageTypes.TEXT) {
       await this.retryTextMessage(rawMessageInfo, threadInfo, parentThreadInfo);
     } else if (
       rawMessageInfo.type === messageTypes.IMAGES ||
       rawMessageInfo.type === messageTypes.MULTIMEDIA
     ) {
       await this.retryMultimediaMessage(
         rawMessageInfo,
         localMessageID,
         threadInfo,
       );
     }
   };
 
   registerSendCallback = (callback: () => void) => {
     this.sendCallbacks.push(callback);
   };
 
   unregisterSendCallback = (callback: () => void) => {
     this.sendCallbacks = this.sendCallbacks.filter(
       candidate => candidate !== callback,
     );
   };
 
   reportURIDisplayed = (uri: string, loaded: boolean) => {
     const prevActiveURI = this.activeURIs.get(uri);
     const curCount = prevActiveURI && prevActiveURI.count;
     const prevCount = curCount ? curCount : 0;
     const count = loaded ? prevCount + 1 : prevCount - 1;
     const prevOnClear = prevActiveURI && prevActiveURI.onClear;
     const onClear = prevOnClear ? prevOnClear : [];
     const activeURI = { count, onClear };
     if (count) {
       this.activeURIs.set(uri, activeURI);
       return;
     }
     this.activeURIs.delete(uri);
     for (const callback of onClear) {
       callback();
     }
   };
 
   waitForCaptureURIUnload(uri: string): Promise<{
     +steps: $ReadOnlyArray<MediaMissionStep>,
     +result: ?string,
   }> {
     const start = Date.now();
     const path = pathFromURI(uri);
     if (!path) {
       return Promise.resolve({
         result: null,
         steps: [
           {
             step: 'wait_for_capture_uri_unload',
             success: false,
             time: Date.now() - start,
             uri,
           },
         ],
       });
     }
 
     const getResult = () => ({
       result: path,
       steps: [
         {
           step: 'wait_for_capture_uri_unload',
           success: true,
           time: Date.now() - start,
           uri,
         },
       ],
     });
 
     const activeURI = this.activeURIs.get(uri);
     if (!activeURI) {
       return Promise.resolve(getResult());
     }
 
     return new Promise(resolve => {
       const finish = () => resolve(getResult());
       const newActiveURI = {
         ...activeURI,
         onClear: [...activeURI.onClear, finish],
       };
       this.activeURIs.set(uri, newActiveURI);
     });
   }
 
   setPendingThreadUpdateHandler = (
     threadID: string,
     pendingThreadUpdateHandler: ?(ThreadInfo) => mixed,
   ) => {
     if (!pendingThreadUpdateHandler) {
       this.pendingThreadUpdateHandlers.delete(threadID);
     } else {
       this.pendingThreadUpdateHandlers.set(
         threadID,
         pendingThreadUpdateHandler,
       );
     }
   };
 
   render(): React.Node {
     const inputState = this.inputStateSelector(this.state);
     return (
       <InputStateContext.Provider value={inputState}>
         {this.props.children}
       </InputStateContext.Provider>
     );
   }
 }
 
 const mediaCreationLoadingStatusSelector = createLoadingStatusSelector(
   sendMultimediaMessageActionTypes,
 );
 const textCreationLoadingStatusSelector = createLoadingStatusSelector(
   sendTextMessageActionTypes,
 );
 
 const ConnectedInputStateContainer: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedInputStateContainer(
     props: BaseProps,
   ) {
     const viewerID = useSelector(
       state => state.currentUserInfo && state.currentUserInfo.id,
     );
     const nextLocalID = useNextLocalID();
     const messageStoreMessages = useSelector(
       state => state.messageStore.messages,
     );
     const ongoingMessageCreation = useSelector(
       state =>
         combineLoadingStatuses(
           mediaCreationLoadingStatusSelector(state),
           textCreationLoadingStatusSelector(state),
         ) === 'loading',
     );
     const hasWiFi = useSelector(state => state.connectivity.hasWiFi);
     const calendarQuery = useCalendarQuery();
     const callUploadMultimedia = useServerCall(uploadMultimedia);
     const callBlobServiceUpload = useBlobServiceUpload();
     const callSendMultimediaMessage = useSendMultimediaMessage();
     const callSendTextMessage = useSendTextMessage();
     const callNewThread = useNewThread();
     const dispatchActionPromise = useDispatchActionPromise();
     const dispatch = useDispatch();
     const mediaReportsEnabled = useIsReportEnabled('mediaReports');
     const staffCanSee = useStaffCanSee();
     const textMessageCreationSideEffectsFunc =
       useMessageCreationSideEffectsFunc<RawTextMessageInfo>(messageTypes.TEXT);
 
     return (
       <InputStateContainer
         {...props}
         viewerID={viewerID}
         nextLocalID={nextLocalID}
         messageStoreMessages={messageStoreMessages}
         ongoingMessageCreation={ongoingMessageCreation}
         hasWiFi={hasWiFi}
         mediaReportsEnabled={mediaReportsEnabled}
         calendarQuery={calendarQuery}
         uploadMultimedia={callUploadMultimedia}
         blobServiceUpload={callBlobServiceUpload}
         sendMultimediaMessage={callSendMultimediaMessage}
         sendTextMessage={callSendTextMessage}
         newThread={callNewThread}
         dispatchActionPromise={dispatchActionPromise}
         dispatch={dispatch}
         staffCanSee={staffCanSee}
         textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
       />
     );
   });
 
 export default ConnectedInputStateContainer;
diff --git a/native/keyboard/keyboard-state-container.react.js b/native/keyboard/keyboard-state-container.react.js
index 46aef59ef..5e17f6cf9 100644
--- a/native/keyboard/keyboard-state-container.react.js
+++ b/native/keyboard/keyboard-state-container.react.js
@@ -1,147 +1,147 @@
 // @flow
 
 import * as React from 'react';
 import { Platform } from 'react-native';
 import { KeyboardUtils } from 'react-native-keyboard-input';
 
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import sleep from 'lib/utils/sleep.js';
 
 import KeyboardInputHost from './keyboard-input-host.react.js';
 import { KeyboardContext } from './keyboard-state.js';
 import {
   addKeyboardShowListener,
   addKeyboardDismissListener,
   removeKeyboardListener,
 } from './keyboard.js';
 import { tabBarAnimationDuration } from '../navigation/tab-bar.react.js';
 import { waitForInteractions } from '../utils/timers.js';
 
 type Props = {
   +children: React.Node,
 };
 type State = {
   +systemKeyboardShowing: boolean,
   +mediaGalleryOpen: boolean,
   +mediaGalleryThread: ?ThreadInfo,
   +renderKeyboardInputHost: boolean,
 };
 class KeyboardStateContainer extends React.PureComponent<Props, State> {
   state: State = {
     systemKeyboardShowing: false,
     mediaGalleryOpen: false,
     mediaGalleryThread: null,
     renderKeyboardInputHost: false,
   };
   keyboardShowListener: ?Object;
   keyboardDismissListener: ?Object;
 
   keyboardShow: () => void = () => {
     this.setState({ systemKeyboardShowing: true });
   };
 
   keyboardDismiss: () => void = () => {
     this.setState({ systemKeyboardShowing: false });
   };
 
   componentDidMount() {
     this.keyboardShowListener = addKeyboardShowListener(this.keyboardShow);
     this.keyboardDismissListener = addKeyboardDismissListener(
       this.keyboardDismiss,
     );
   }
 
   componentWillUnmount() {
     if (this.keyboardShowListener) {
       removeKeyboardListener(this.keyboardShowListener);
       this.keyboardShowListener = null;
     }
     if (this.keyboardDismissListener) {
       removeKeyboardListener(this.keyboardDismissListener);
       this.keyboardDismissListener = null;
     }
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (Platform.OS !== 'android') {
       return;
     }
     if (this.state.mediaGalleryOpen && !prevState.mediaGalleryOpen) {
-      (async () => {
+      void (async () => {
         await sleep(tabBarAnimationDuration);
         await waitForInteractions();
         this.setState({ renderKeyboardInputHost: true });
       })();
     }
   }
 
   dismissKeyboard: () => void = () => {
     KeyboardUtils.dismiss();
     this.hideMediaGallery();
   };
 
   dismissKeyboardIfShowing: () => boolean = () => {
     if (!this.keyboardShowing) {
       return false;
     }
     this.dismissKeyboard();
     return true;
   };
 
   get keyboardShowing(): boolean {
     const { systemKeyboardShowing, mediaGalleryOpen } = this.state;
     return systemKeyboardShowing || mediaGalleryOpen;
   }
 
   showMediaGallery: (thread: ThreadInfo) => void = (thread: ThreadInfo) => {
     this.setState({
       mediaGalleryOpen: true,
       mediaGalleryThread: thread,
     });
   };
 
   hideMediaGallery: () => void = () => {
     this.setState({
       mediaGalleryOpen: false,
       mediaGalleryThread: null,
       renderKeyboardInputHost: false,
     });
   };
 
   getMediaGalleryThread: () => ?ThreadInfo = () =>
     this.state.mediaGalleryThread;
 
   render(): React.Node {
     const { systemKeyboardShowing, mediaGalleryOpen, renderKeyboardInputHost } =
       this.state;
     const {
       keyboardShowing,
       dismissKeyboard,
       dismissKeyboardIfShowing,
       showMediaGallery,
       hideMediaGallery,
       getMediaGalleryThread,
     } = this;
     const keyboardState = {
       keyboardShowing,
       dismissKeyboard,
       dismissKeyboardIfShowing,
       systemKeyboardShowing,
       mediaGalleryOpen,
       showMediaGallery,
       hideMediaGallery,
       getMediaGalleryThread,
     };
     const keyboardInputHost = renderKeyboardInputHost ? (
       <KeyboardInputHost />
     ) : null;
     return (
       <KeyboardContext.Provider value={keyboardState}>
         {this.props.children}
         {keyboardInputHost}
       </KeyboardContext.Provider>
     );
   }
 }
 
 export default KeyboardStateContainer;
diff --git a/native/markdown/markdown-utils.js b/native/markdown/markdown-utils.js
index eda004d26..d9f280975 100644
--- a/native/markdown/markdown-utils.js
+++ b/native/markdown/markdown-utils.js
@@ -1,102 +1,102 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Linking } from 'react-native';
 
 import { inviteLinkURL } from 'lib/facts/links.js';
 
 import {
   MarkdownContext,
   type MarkdownContextType,
 } from './markdown-context.js';
 import { MarkdownSpoilerContext } from './markdown-spoiler-context.js';
 import { MessagePressResponderContext } from '../chat/message-press-responder-context.js';
 import { TextMessageMarkdownContext } from '../chat/text-message-markdown-context.js';
 import { DeepLinksContext } from '../navigation/deep-links-context-provider.react.js';
 import Alert from '../utils/alert.js';
 import { normalizeURL } from '../utils/url-utils.js';
 
 function useMarkdownOnPressUtils(): {
   markdownContext: MarkdownContextType,
   isRevealed: boolean,
   messageKey: ?string,
   onLongPressHandler: ?() => void,
 } {
   const markdownContext = React.useContext(MarkdownContext);
   invariant(markdownContext, 'MarkdownContext should be set');
 
   const markdownSpoilerContext = React.useContext(MarkdownSpoilerContext);
   // Since MarkdownSpoilerContext may not be set, we need
   // to default isRevealed to true for when
   // we use the ternary operator in the onPress
   const isRevealed = markdownSpoilerContext?.isRevealed ?? true;
 
   const textMessageMarkdownContext = React.useContext(
     TextMessageMarkdownContext,
   );
   const messageKey = textMessageMarkdownContext?.messageKey;
 
   const messagePressResponderContext = React.useContext(
     MessagePressResponderContext,
   );
 
   const onLongPressHandler = messagePressResponderContext?.onPressMessage;
 
   return {
     markdownContext,
     isRevealed,
     messageKey,
     onLongPressHandler,
   };
 }
 
 function useHandleLinkClick(
   inputURL: string,
   markdownContext: MarkdownContextType,
   messageKey: ?string,
 ): () => void {
   const { setLinkModalActive } = markdownContext;
   const onDismiss = React.useCallback(() => {
     messageKey && setLinkModalActive({ [(messageKey: string)]: false });
   }, [setLinkModalActive, messageKey]);
 
   const url = normalizeURL(inputURL);
   const onConfirm = React.useCallback(() => {
     onDismiss();
-    Linking.openURL(url);
+    void Linking.openURL(url);
   }, [url, onDismiss]);
 
   let displayURL = url.substring(0, 64);
   if (url.length > displayURL.length) {
     displayURL += '…';
   }
 
   const deepLinksContext = React.useContext(DeepLinksContext);
   return React.useCallback(() => {
     if (url.startsWith(inviteLinkURL(''))) {
       deepLinksContext?.setCurrentLinkUrl(url);
       return;
     }
     messageKey && setLinkModalActive({ [(messageKey: string)]: true });
     Alert.alert(
       'External link',
       `You sure you want to open this link?\n\n${displayURL}`,
       [
         { text: 'Cancel', style: 'cancel', onPress: onDismiss },
         { text: 'Open', onPress: onConfirm },
       ],
       { cancelable: true, onDismiss },
     );
   }, [
     url,
     messageKey,
     setLinkModalActive,
     displayURL,
     onDismiss,
     onConfirm,
     deepLinksContext,
   ]);
 }
 
 export { useMarkdownOnPressUtils, useHandleLinkClick };
diff --git a/native/media/camera-modal.react.js b/native/media/camera-modal.react.js
index beb8682cb..c8257011b 100644
--- a/native/media/camera-modal.react.js
+++ b/native/media/camera-modal.react.js
@@ -1,1219 +1,1221 @@
 // @flow
 
 import Icon from '@expo/vector-icons/Ionicons.js';
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   View,
   Text,
   StyleSheet,
   TouchableOpacity,
   Platform,
   Image,
   Animated,
   Easing,
 } from 'react-native';
 import { RNCamera } from 'react-native-camera';
 import filesystem from 'react-native-fs';
 import {
   PinchGestureHandler,
   TapGestureHandler,
   State as GestureState,
   type PinchGestureEvent,
   type TapGestureEvent,
 } from 'react-native-gesture-handler';
 import Orientation from 'react-native-orientation-locker';
 import type { Orientations } from 'react-native-orientation-locker';
 import Reanimated, {
   EasingNode as ReanimatedEasing,
   type EventResult,
 } from 'react-native-reanimated';
 import { SafeAreaView } from 'react-native-safe-area-context';
 
 import { pathFromURI, filenameFromPathOrURI } from 'lib/media/file-utils.js';
 import { useIsAppForegrounded } from 'lib/shared/lifecycle-utils.js';
 import type { PhotoCapture } from 'lib/types/media-types.js';
 import type { ReactRef } from 'lib/types/react-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import SendMediaButton from './send-media-button.react.js';
 import type { RegistrationNavigationProp } from '../account/registration/registration-navigator.react.js';
 import ContentLoading from '../components/content-loading.react.js';
 import ConnectedStatusBar from '../connected-status-bar.react.js';
 import type { AppNavigationProp } from '../navigation/app-navigator.react.js';
 import {
   OverlayContext,
   type OverlayContextType,
 } from '../navigation/overlay-context.js';
 import { updateDeviceCameraInfoActionType } from '../redux/action-types.js';
 import { type DimensionsInfo } from '../redux/dimensions-updater.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { colors } from '../themes/colors.js';
 import { type DeviceCameraInfo } from '../types/camera.js';
 import type { NativeMethods } from '../types/react-native.js';
 import {
   AnimatedView,
   type ViewStyle,
   type AnimatedViewStyle,
 } from '../types/styles.js';
 import { clamp, gestureJustEnded } from '../utils/animation-utils.js';
 
 /* eslint-disable import/no-named-as-default-member */
 const {
   Value,
   Node,
   Clock,
   event,
   Extrapolate,
   block,
   set,
   call,
   cond,
   not,
   and,
   or,
   eq,
   greaterThan,
   lessThan,
   add,
   sub,
   multiply,
   divide,
   abs,
   interpolateNode,
   startClock,
   stopClock,
   clockRunning,
   timing,
   spring,
   SpringUtils,
 } = Reanimated;
 /* eslint-enable import/no-named-as-default-member */
 
 const maxZoom = 16;
 const zoomUpdateFactor = (() => {
   if (Platform.OS === 'ios') {
     return 0.002;
   }
   if (Platform.OS === 'android' && Platform.Version > 26) {
     return 0.005;
   }
   if (Platform.OS === 'android' && Platform.Version > 23) {
     return 0.01;
   }
   return 0.03;
 })();
 
 const stagingModeAnimationConfig = {
   duration: 150,
   easing: ReanimatedEasing.inOut(ReanimatedEasing.ease),
 };
 const sendButtonAnimationConfig = {
   duration: 150,
   easing: Easing.inOut(Easing.ease),
   useNativeDriver: true,
 };
 
 const indicatorSpringConfig = {
   ...SpringUtils.makeDefaultConfig(),
   damping: 0,
   mass: 0.6,
   toValue: 1,
 };
 const indicatorTimingConfig = {
   duration: 500,
   easing: ReanimatedEasing.out(ReanimatedEasing.ease),
   toValue: 0,
 };
 function runIndicatorAnimation(
   // Inputs
   springClock: Clock,
   delayClock: Clock,
   timingClock: Clock,
   animationRunning: Node,
   // Outputs
   scale: Value,
   opacity: Value,
 ): Node {
   const delayStart = new Value(0);
 
   const springScale = new Value(0.75);
   const delayScale = new Value(0);
   const timingScale = new Value(0.75);
 
   const animatedScale = cond(
     clockRunning(springClock),
     springScale,
     cond(clockRunning(delayClock), delayScale, timingScale),
   );
   const lastAnimatedScale = new Value(0.75);
   const numScaleLoops = new Value(0);
 
   const springState = {
     finished: new Value(1),
     velocity: new Value(0),
     time: new Value(0),
     position: springScale,
   };
   const timingState = {
     finished: new Value(1),
     frameTime: new Value(0),
     time: new Value(0),
     position: timingScale,
   };
 
   return block([
     cond(not(animationRunning), [
       set(springState.finished, 0),
       set(springState.velocity, 0),
       set(springState.time, 0),
       set(springScale, 0.75),
       set(lastAnimatedScale, 0.75),
       set(numScaleLoops, 0),
       set(opacity, 1),
       startClock(springClock),
     ]),
     [
       cond(
         clockRunning(springClock),
         spring(springClock, springState, indicatorSpringConfig),
       ),
       timing(timingClock, timingState, indicatorTimingConfig),
     ],
     [
       cond(
         and(
           greaterThan(animatedScale, 1.2),
           not(greaterThan(lastAnimatedScale, 1.2)),
         ),
         [
           set(numScaleLoops, add(numScaleLoops, 1)),
           cond(greaterThan(numScaleLoops, 1), [
             set(springState.finished, 1),
             stopClock(springClock),
             set(delayScale, springScale),
             set(delayStart, delayClock),
             startClock(delayClock),
           ]),
         ],
       ),
       set(lastAnimatedScale, animatedScale),
     ],
     cond(
       and(
         clockRunning(delayClock),
         greaterThan(delayClock, add(delayStart, 400)),
       ),
       [
         stopClock(delayClock),
         set(timingState.finished, 0),
         set(timingState.frameTime, 0),
         set(timingState.time, 0),
         set(timingScale, delayScale),
         startClock(timingClock),
       ],
     ),
     cond(
       and(springState.finished, timingState.finished),
       stopClock(timingClock),
     ),
     set(scale, animatedScale),
     cond(clockRunning(timingClock), set(opacity, clamp(animatedScale, 0, 1))),
   ]);
 }
 
 type RNCameraStatus = 'READY' | 'PENDING_AUTHORIZATION' | 'NOT_AUTHORIZED';
 
 type TouchableOpacityInstance = React.AbstractComponent<
   React.ElementConfig<typeof TouchableOpacity>,
   NativeMethods,
 >;
 
 type BaseProps = {
   +handlePhotoCapture: (capture: PhotoCapture) => mixed,
   +navigation:
     | AppNavigationProp<'ChatCameraModal'>
     | AppNavigationProp<'UserAvatarCameraModal'>
     | AppNavigationProp<'ThreadAvatarCameraModal'>
     | RegistrationNavigationProp<'RegistrationUserAvatarCameraModal'>,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +dimensions: DimensionsInfo,
   +deviceCameraInfo: DeviceCameraInfo,
   +deviceOrientation: Orientations,
   +foreground: boolean,
   // Redux dispatch functions
   +dispatch: Dispatch,
   // withOverlayContext
   +overlayContext: ?OverlayContextType,
 };
 type State = {
   +zoom: number,
   +useFrontCamera: boolean,
   +hasCamerasOnBothSides: boolean,
   +flashMode: number,
   +autoFocusPointOfInterest: ?{
     x: number,
     y: number,
     autoExposure?: boolean,
   },
   +stagingMode: boolean,
   +pendingPhotoCapture: ?PhotoCapture,
 };
 class CameraModal extends React.PureComponent<Props, State> {
   camera: ?RNCamera;
 
   pinchEvent: EventResult<PinchGestureEvent>;
   pinchHandler: ReactRef<PinchGestureHandler> = React.createRef();
   tapEvent: EventResult<TapGestureEvent>;
   tapHandler: ReactRef<TapGestureHandler> = React.createRef();
   animationCode: Node;
 
   closeButton: ?React.ElementRef<TouchableOpacityInstance>;
   closeButtonX: Value = new Value(-1);
   closeButtonY: Value = new Value(-1);
   closeButtonWidth: Value = new Value(0);
   closeButtonHeight: Value = new Value(0);
 
   photoButton: ?React.ElementRef<TouchableOpacityInstance>;
   photoButtonX: Value = new Value(-1);
   photoButtonY: Value = new Value(-1);
   photoButtonWidth: Value = new Value(0);
   photoButtonHeight: Value = new Value(0);
 
   switchCameraButton: ?React.ElementRef<TouchableOpacityInstance>;
   switchCameraButtonX: Value = new Value(-1);
   switchCameraButtonY: Value = new Value(-1);
   switchCameraButtonWidth: Value = new Value(0);
   switchCameraButtonHeight: Value = new Value(0);
 
   flashButton: ?React.ElementRef<TouchableOpacityInstance>;
   flashButtonX: Value = new Value(-1);
   flashButtonY: Value = new Value(-1);
   flashButtonWidth: Value = new Value(0);
   flashButtonHeight: Value = new Value(0);
 
   focusIndicatorX: Value = new Value(-1);
   focusIndicatorY: Value = new Value(-1);
   focusIndicatorScale: Value = new Value(0);
   focusIndicatorOpacity: Value = new Value(0);
 
   cancelIndicatorAnimation: Value = new Value(0);
 
   cameraIDsFetched = false;
 
   stagingModeProgress: Value = new Value(0);
   sendButtonProgress: Animated.Value = new Animated.Value(0);
   sendButtonStyle: ViewStyle;
   overlayStyle: AnimatedViewStyle;
 
   constructor(props: Props) {
     super(props);
 
     this.state = {
       zoom: 0,
       useFrontCamera: props.deviceCameraInfo.defaultUseFrontCamera,
       hasCamerasOnBothSides: props.deviceCameraInfo.hasCamerasOnBothSides,
       flashMode: RNCamera.Constants.FlashMode.off,
       autoFocusPointOfInterest: undefined,
       stagingMode: false,
       pendingPhotoCapture: undefined,
     };
 
     const sendButtonScale = this.sendButtonProgress.interpolate({
       inputRange: [0, 1],
       outputRange: ([1.1, 1]: number[]), // Flow...
     });
     this.sendButtonStyle = {
       opacity: this.sendButtonProgress,
       transform: [{ scale: sendButtonScale }],
     };
 
     const overlayOpacity = interpolateNode(this.stagingModeProgress, {
       inputRange: [0, 0.01, 1],
       outputRange: [0, 0.5, 0],
       extrapolate: Extrapolate.CLAMP,
     });
     this.overlayStyle = {
       ...styles.overlay,
       opacity: overlayOpacity,
     };
 
     const pinchState = new Value(-1);
     const pinchScale = new Value(1);
     this.pinchEvent = event([
       {
         nativeEvent: {
           state: pinchState,
           scale: pinchScale,
         },
       },
     ]);
 
     const tapState = new Value(-1);
     const tapX = new Value(0);
     const tapY = new Value(0);
     this.tapEvent = event([
       {
         nativeEvent: {
           state: tapState,
           x: tapX,
           y: tapY,
         },
       },
     ]);
 
     this.animationCode = block([
       this.zoomAnimationCode(pinchState, pinchScale),
       this.focusAnimationCode(tapState, tapX, tapY),
     ]);
   }
 
   zoomAnimationCode(pinchState: Node, pinchScale: Node): Node {
     const pinchJustEnded = gestureJustEnded(pinchState);
 
     const zoomBase = new Value(1);
     const zoomReported = new Value(1);
 
     const currentZoom = interpolateNode(multiply(zoomBase, pinchScale), {
       inputRange: [1, 8],
       outputRange: [1, 8],
       extrapolate: Extrapolate.CLAMP,
     });
     const cameraZoomFactor = interpolateNode(zoomReported, {
       inputRange: [1, 8],
       outputRange: [0, 1],
       extrapolate: Extrapolate.CLAMP,
     });
     const resolvedZoom = cond(
       eq(pinchState, GestureState.ACTIVE),
       currentZoom,
       zoomBase,
     );
 
     return block([
       cond(pinchJustEnded, set(zoomBase, currentZoom)),
       cond(
         or(
           pinchJustEnded,
           greaterThan(
             abs(sub(divide(resolvedZoom, zoomReported), 1)),
             zoomUpdateFactor,
           ),
         ),
         [
           set(zoomReported, resolvedZoom),
           call([cameraZoomFactor], this.updateZoom),
         ],
       ),
     ]);
   }
 
   focusAnimationCode(tapState: Node, tapX: Node, tapY: Node): Node {
     const lastTapX = new Value(0);
     const lastTapY = new Value(0);
     const fingerJustReleased = and(
       gestureJustEnded(tapState),
       this.outsideButtons(lastTapX, lastTapY),
     );
 
     const indicatorSpringClock = new Clock();
     const indicatorDelayClock = new Clock();
     const indicatorTimingClock = new Clock();
     const indicatorAnimationRunning = or(
       clockRunning(indicatorSpringClock),
       clockRunning(indicatorDelayClock),
       clockRunning(indicatorTimingClock),
     );
 
     return block([
       cond(fingerJustReleased, [
         call([tapX, tapY], this.focusOnPoint),
         set(this.focusIndicatorX, tapX),
         set(this.focusIndicatorY, tapY),
         stopClock(indicatorSpringClock),
         stopClock(indicatorDelayClock),
         stopClock(indicatorTimingClock),
       ]),
       cond(this.cancelIndicatorAnimation, [
         set(this.cancelIndicatorAnimation, 0),
         stopClock(indicatorSpringClock),
         stopClock(indicatorDelayClock),
         stopClock(indicatorTimingClock),
         set(this.focusIndicatorOpacity, 0),
       ]),
       cond(
         or(fingerJustReleased, indicatorAnimationRunning),
         runIndicatorAnimation(
           indicatorSpringClock,
           indicatorDelayClock,
           indicatorTimingClock,
           indicatorAnimationRunning,
           this.focusIndicatorScale,
           this.focusIndicatorOpacity,
         ),
       ),
       set(lastTapX, tapX),
       set(lastTapY, tapY),
     ]);
   }
 
   outsideButtons(x: Node, y: Node): Node {
     const {
       closeButtonX,
       closeButtonY,
       closeButtonWidth,
       closeButtonHeight,
       photoButtonX,
       photoButtonY,
       photoButtonWidth,
       photoButtonHeight,
       switchCameraButtonX,
       switchCameraButtonY,
       switchCameraButtonWidth,
       switchCameraButtonHeight,
       flashButtonX,
       flashButtonY,
       flashButtonWidth,
       flashButtonHeight,
     } = this;
     return and(
       or(
         lessThan(x, closeButtonX),
         greaterThan(x, add(closeButtonX, closeButtonWidth)),
         lessThan(y, closeButtonY),
         greaterThan(y, add(closeButtonY, closeButtonHeight)),
       ),
       or(
         lessThan(x, photoButtonX),
         greaterThan(x, add(photoButtonX, photoButtonWidth)),
         lessThan(y, photoButtonY),
         greaterThan(y, add(photoButtonY, photoButtonHeight)),
       ),
       or(
         lessThan(x, switchCameraButtonX),
         greaterThan(x, add(switchCameraButtonX, switchCameraButtonWidth)),
         lessThan(y, switchCameraButtonY),
         greaterThan(y, add(switchCameraButtonY, switchCameraButtonHeight)),
       ),
       or(
         lessThan(x, flashButtonX),
         greaterThan(x, add(flashButtonX, flashButtonWidth)),
         lessThan(y, flashButtonY),
         greaterThan(y, add(flashButtonY, flashButtonHeight)),
       ),
     );
   }
 
   static isActive(props: Props): boolean {
     const { overlayContext } = props;
     if (!overlayContext) {
       return true;
     }
     return !overlayContext.isDismissing;
   }
 
   componentDidMount() {
     if (CameraModal.isActive(this.props)) {
       Orientation.unlockAllOrientations();
     }
   }
 
   componentWillUnmount() {
     if (CameraModal.isActive(this.props)) {
       Orientation.lockToPortrait();
     }
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     const isActive = CameraModal.isActive(this.props);
     const wasActive = CameraModal.isActive(prevProps);
     if (isActive && !wasActive) {
       Orientation.unlockAllOrientations();
     } else if (!isActive && wasActive) {
       Orientation.lockToPortrait();
     }
 
     if (!this.state.hasCamerasOnBothSides && prevState.hasCamerasOnBothSides) {
       this.switchCameraButtonX.setValue(-1);
       this.switchCameraButtonY.setValue(-1);
       this.switchCameraButtonWidth.setValue(0);
       this.switchCameraButtonHeight.setValue(0);
     }
 
     if (this.props.deviceOrientation !== prevProps.deviceOrientation) {
       this.setState({ autoFocusPointOfInterest: null });
       this.cancelIndicatorAnimation.setValue(1);
     }
 
     if (this.props.foreground && !prevProps.foreground && this.camera) {
-      this.camera.refreshAuthorizationStatus();
+      void this.camera.refreshAuthorizationStatus();
     }
 
     if (this.state.stagingMode && !prevState.stagingMode) {
       this.cancelIndicatorAnimation.setValue(1);
       this.focusIndicatorOpacity.setValue(0);
       timing(this.stagingModeProgress, {
         ...stagingModeAnimationConfig,
         toValue: 1,
       }).start();
     } else if (!this.state.stagingMode && prevState.stagingMode) {
       this.stagingModeProgress.setValue(0);
     }
 
     if (this.state.pendingPhotoCapture && !prevState.pendingPhotoCapture) {
       Animated.timing(this.sendButtonProgress, {
         ...sendButtonAnimationConfig,
         toValue: 1,
       }).start();
     } else if (
       !this.state.pendingPhotoCapture &&
       prevState.pendingPhotoCapture
     ) {
-      CameraModal.cleanUpPendingPhotoCapture(prevState.pendingPhotoCapture);
+      void CameraModal.cleanUpPendingPhotoCapture(
+        prevState.pendingPhotoCapture,
+      );
       this.sendButtonProgress.setValue(0);
     }
   }
 
   static async cleanUpPendingPhotoCapture(pendingPhotoCapture: PhotoCapture) {
     const path = pathFromURI(pendingPhotoCapture.uri);
     if (!path) {
       return;
     }
     try {
       await filesystem.unlink(path);
     } catch (e) {}
   }
 
   get containerStyle(): AnimatedViewStyle {
     const { overlayContext } = this.props;
     if (!overlayContext) {
       return styles.container;
     }
     return {
       ...styles.container,
       opacity: overlayContext.position,
     };
   }
 
   get focusIndicatorStyle(): AnimatedViewStyle {
     return {
       ...styles.focusIndicator,
       opacity: this.focusIndicatorOpacity,
       transform: [
         { translateX: this.focusIndicatorX },
         { translateY: this.focusIndicatorY },
         { scale: this.focusIndicatorScale },
       ],
     };
   }
 
   renderCamera = ({
     camera,
     status,
   }: {
     +camera: RNCamera & { +_cameraHandle?: mixed, ... },
     status: RNCameraStatus,
     ...
   }): React.Node => {
     if (camera && camera._cameraHandle) {
-      this.fetchCameraIDs(camera);
+      void this.fetchCameraIDs(camera);
     }
     if (this.state.stagingMode) {
       return this.renderStagingView();
     }
 
     return (
       <SafeAreaView style={styles.fill}>
         <View style={styles.fill}>
           {this.renderCameraContent(status)}
           <TouchableOpacity
             onPress={this.close}
             onLayout={this.onCloseButtonLayout}
             style={styles.closeButton}
             ref={this.closeButtonRef}
           >
             <Text style={styles.closeIcon}>×</Text>
           </TouchableOpacity>
         </View>
       </SafeAreaView>
     );
   };
 
   renderStagingView(): React.Node {
     let image = null;
     const { pendingPhotoCapture } = this.state;
     if (pendingPhotoCapture) {
       const imageSource = { uri: pendingPhotoCapture.uri };
       image = <Image source={imageSource} style={styles.stagingImage} />;
     } else {
       image = <ContentLoading fillType="flex" colors={colors.dark} />;
     }
 
     return (
       <>
         {image}
         <SafeAreaView style={styles.stagingViewOverlay}>
           <View style={styles.fill}>
             <TouchableOpacity
               onPress={this.clearPendingImage}
               style={styles.retakeButton}
             >
               <Icon name="ios-arrow-back" style={styles.retakeIcon} />
             </TouchableOpacity>
             <SendMediaButton
               onPress={this.sendPhoto}
               pointerEvents={pendingPhotoCapture ? 'auto' : 'none'}
               containerStyle={styles.sendButtonContainer}
               style={this.sendButtonStyle}
             />
           </View>
         </SafeAreaView>
       </>
     );
   }
 
   renderCameraContent(status: RNCameraStatus): React.Node {
     if (status === 'PENDING_AUTHORIZATION') {
       return <ContentLoading fillType="flex" colors={colors.dark} />;
     } else if (status === 'NOT_AUTHORIZED') {
       return (
         <View style={styles.authorizationDeniedContainer}>
           <Text style={styles.authorizationDeniedText}>
             {'don’t have permission :('}
           </Text>
         </View>
       );
     }
 
     let switchCameraButton = null;
     if (this.state.hasCamerasOnBothSides) {
       switchCameraButton = (
         <TouchableOpacity
           onPress={this.switchCamera}
           onLayout={this.onSwitchCameraButtonLayout}
           style={styles.switchCameraButton}
           ref={this.switchCameraButtonRef}
         >
           <Icon name="ios-camera-reverse" style={styles.switchCameraIcon} />
         </TouchableOpacity>
       );
     }
 
     let flashIcon;
     if (this.state.flashMode === RNCamera.Constants.FlashMode.on) {
       flashIcon = <Icon name="ios-flash" style={styles.flashIcon} />;
     } else if (this.state.flashMode === RNCamera.Constants.FlashMode.off) {
       flashIcon = <Icon name="ios-flash-off" style={styles.flashIcon} />;
     } else {
       flashIcon = (
         <>
           <Icon name="ios-flash" style={styles.flashIcon} />
           <Text style={styles.flashIconAutoText}>A</Text>
         </>
       );
     }
 
     return (
       <PinchGestureHandler
         onGestureEvent={this.pinchEvent}
         onHandlerStateChange={this.pinchEvent}
         simultaneousHandlers={this.tapHandler}
         ref={this.pinchHandler}
       >
         <Reanimated.View style={styles.fill}>
           <TapGestureHandler
             onHandlerStateChange={this.tapEvent}
             simultaneousHandlers={this.pinchHandler}
             waitFor={this.pinchHandler}
             ref={this.tapHandler}
           >
             <Reanimated.View style={styles.fill}>
               <Reanimated.View style={this.focusIndicatorStyle} />
               <TouchableOpacity
                 onPress={this.changeFlashMode}
                 onLayout={this.onFlashButtonLayout}
                 style={styles.flashButton}
                 ref={this.flashButtonRef}
               >
                 {flashIcon}
               </TouchableOpacity>
               <View style={styles.bottomButtonsContainer}>
                 <TouchableOpacity
                   onPress={this.takePhoto}
                   onLayout={this.onPhotoButtonLayout}
                   style={styles.saveButton}
                   ref={this.photoButtonRef}
                 >
                   <View style={styles.saveButtonInner} />
                 </TouchableOpacity>
                 {switchCameraButton}
               </View>
             </Reanimated.View>
           </TapGestureHandler>
         </Reanimated.View>
       </PinchGestureHandler>
     );
   }
 
   render(): React.Node {
     const statusBar = CameraModal.isActive(this.props) ? (
       <ConnectedStatusBar hidden />
     ) : null;
     const type = this.state.useFrontCamera
       ? RNCamera.Constants.Type.front
       : RNCamera.Constants.Type.back;
     return (
       <Reanimated.View style={this.containerStyle}>
         {statusBar}
         <Reanimated.Code exec={this.animationCode} />
         <RNCamera
           type={type}
           captureAudio={false}
           maxZoom={maxZoom}
           zoom={this.state.zoom}
           flashMode={this.state.flashMode}
           autoFocusPointOfInterest={this.state.autoFocusPointOfInterest}
           style={styles.fill}
           androidCameraPermissionOptions={null}
           ref={this.cameraRef}
         >
           {this.renderCamera}
         </RNCamera>
         <AnimatedView style={this.overlayStyle} pointerEvents="none" />
       </Reanimated.View>
     );
   }
 
   cameraRef = (camera: ?RNCamera) => {
     this.camera = camera;
   };
 
   closeButtonRef = (
     closeButton: ?React.ElementRef<typeof TouchableOpacity>,
   ) => {
     this.closeButton = (closeButton: any);
   };
 
   onCloseButtonLayout = () => {
     const { closeButton } = this;
     if (!closeButton) {
       return;
     }
     closeButton.measure((x, y, width, height, pageX, pageY) => {
       this.closeButtonX.setValue(pageX);
       this.closeButtonY.setValue(pageY);
       this.closeButtonWidth.setValue(width);
       this.closeButtonHeight.setValue(height);
     });
   };
 
   photoButtonRef = (
     photoButton: ?React.ElementRef<typeof TouchableOpacity>,
   ) => {
     this.photoButton = (photoButton: any);
   };
 
   onPhotoButtonLayout = () => {
     const { photoButton } = this;
     if (!photoButton) {
       return;
     }
     photoButton.measure((x, y, width, height, pageX, pageY) => {
       this.photoButtonX.setValue(pageX);
       this.photoButtonY.setValue(pageY);
       this.photoButtonWidth.setValue(width);
       this.photoButtonHeight.setValue(height);
     });
   };
 
   switchCameraButtonRef = (
     switchCameraButton: ?React.ElementRef<typeof TouchableOpacity>,
   ) => {
     this.switchCameraButton = (switchCameraButton: any);
   };
 
   onSwitchCameraButtonLayout = () => {
     const { switchCameraButton } = this;
     if (!switchCameraButton) {
       return;
     }
     switchCameraButton.measure((x, y, width, height, pageX, pageY) => {
       this.switchCameraButtonX.setValue(pageX);
       this.switchCameraButtonY.setValue(pageY);
       this.switchCameraButtonWidth.setValue(width);
       this.switchCameraButtonHeight.setValue(height);
     });
   };
 
   flashButtonRef = (
     flashButton: ?React.ElementRef<typeof TouchableOpacity>,
   ) => {
     this.flashButton = (flashButton: any);
   };
 
   onFlashButtonLayout = () => {
     const { flashButton } = this;
     if (!flashButton) {
       return;
     }
     flashButton.measure((x, y, width, height, pageX, pageY) => {
       this.flashButtonX.setValue(pageX);
       this.flashButtonY.setValue(pageY);
       this.flashButtonWidth.setValue(width);
       this.flashButtonHeight.setValue(height);
     });
   };
 
   close = () => {
     const { overlayContext, navigation } = this.props;
     if (overlayContext && navigation.goBackOnce) {
       navigation.goBackOnce();
     } else {
       navigation.goBack();
     }
   };
 
   takePhoto = async () => {
     const { camera } = this;
     invariant(camera, 'camera ref should be set');
     this.setState({ stagingMode: true });
 
     // We avoid flipping this.state.useFrontCamera if we discover we don't
     // actually have a back camera since it causes a bit of lag, but this
     // means there are cases where it is false but we are actually using the
     // front camera
     const { hasCamerasOnBothSides, defaultUseFrontCamera } =
       this.props.deviceCameraInfo;
     const usingFrontCamera =
       this.state.useFrontCamera ||
       (!hasCamerasOnBothSides && defaultUseFrontCamera);
 
     const startTime = Date.now();
     const photoPromise = camera.takePictureAsync({
       pauseAfterCapture: Platform.OS === 'android',
       mirrorImage: usingFrontCamera,
       fixOrientation: true,
     });
 
     if (Platform.OS === 'ios') {
       camera.pausePreview();
     }
     const { uri, width, height } = await photoPromise;
     const filename = filenameFromPathOrURI(uri);
     invariant(
       filename,
       `unable to parse filename out of react-native-camera URI ${uri}`,
     );
 
     const now = Date.now();
     const pendingPhotoCapture = {
       step: 'photo_capture',
       uri,
       dimensions: { width, height },
       filename,
       time: now - startTime,
       captureTime: now,
       selectTime: 0,
       sendTime: 0,
       retries: 0,
     };
 
     this.setState({
       pendingPhotoCapture,
       zoom: 0,
       autoFocusPointOfInterest: undefined,
     });
   };
 
   sendPhoto = async () => {
     const { pendingPhotoCapture } = this.state;
     if (!pendingPhotoCapture) {
       return;
     }
 
     const now = Date.now();
     const capture = {
       ...pendingPhotoCapture,
       selectTime: now,
       sendTime: now,
     };
 
     this.close();
 
     this.props.handlePhotoCapture(capture);
   };
 
   clearPendingImage = () => {
     invariant(this.camera, 'camera ref should be set');
     this.camera.resumePreview();
     this.setState({
       stagingMode: false,
       pendingPhotoCapture: undefined,
     });
   };
 
   switchCamera = () => {
     this.setState((prevState: State) => ({
       useFrontCamera: !prevState.useFrontCamera,
     }));
   };
 
   updateZoom = ([zoom]: [number]) => {
     this.setState({ zoom });
   };
 
   changeFlashMode = () => {
     if (this.state.flashMode === RNCamera.Constants.FlashMode.on) {
       this.setState({ flashMode: RNCamera.Constants.FlashMode.off });
     } else if (this.state.flashMode === RNCamera.Constants.FlashMode.off) {
       this.setState({ flashMode: RNCamera.Constants.FlashMode.auto });
     } else {
       this.setState({ flashMode: RNCamera.Constants.FlashMode.on });
     }
   };
 
   focusOnPoint = ([inputX, inputY]: [number, number]) => {
     const { width: screenWidth, height: screenHeight } = this.props.dimensions;
     const relativeX = inputX / screenWidth;
     const relativeY = inputY / screenHeight;
 
     // react-native-camera's autoFocusPointOfInterest prop is based on a
     // LANDSCAPE-LEFT orientation, so we need to map to that
     let x, y;
     if (this.props.deviceOrientation === 'LANDSCAPE-LEFT') {
       x = relativeX;
       y = relativeY;
     } else if (this.props.deviceOrientation === 'LANDSCAPE-RIGHT') {
       x = 1 - relativeX;
       y = 1 - relativeY;
     } else if (this.props.deviceOrientation === 'PORTRAIT-UPSIDEDOWN') {
       x = 1 - relativeY;
       y = relativeX;
     } else {
       x = relativeY;
       y = 1 - relativeX;
     }
 
     const autoFocusPointOfInterest =
       Platform.OS === 'ios' ? { x, y, autoExposure: true } : { x, y };
     this.setState({ autoFocusPointOfInterest });
   };
 
   fetchCameraIDs = async (camera: RNCamera) => {
     if (this.cameraIDsFetched) {
       return;
     }
     this.cameraIDsFetched = true;
 
     const deviceCameras = await camera.getCameraIdsAsync();
 
     let hasFront = false,
       hasBack = false,
       i = 0;
     while ((!hasFront || !hasBack) && i < deviceCameras.length) {
       const deviceCamera = deviceCameras[i];
       if (deviceCamera.type === RNCamera.Constants.Type.front) {
         hasFront = true;
       } else if (deviceCamera.type === RNCamera.Constants.Type.back) {
         hasBack = true;
       }
       i++;
     }
 
     const hasCamerasOnBothSides = hasFront && hasBack;
     const defaultUseFrontCamera = !hasBack && hasFront;
     if (hasCamerasOnBothSides !== this.state.hasCamerasOnBothSides) {
       this.setState({ hasCamerasOnBothSides });
     }
     const {
       hasCamerasOnBothSides: oldHasCamerasOnBothSides,
       defaultUseFrontCamera: oldDefaultUseFrontCamera,
     } = this.props.deviceCameraInfo;
     if (
       hasCamerasOnBothSides !== oldHasCamerasOnBothSides ||
       defaultUseFrontCamera !== oldDefaultUseFrontCamera
     ) {
       this.props.dispatch({
         type: updateDeviceCameraInfoActionType,
         payload: { hasCamerasOnBothSides, defaultUseFrontCamera },
       });
     }
   };
 }
 
 const styles = StyleSheet.create({
   authorizationDeniedContainer: {
     alignItems: 'center',
     flex: 1,
     justifyContent: 'center',
   },
   authorizationDeniedText: {
     color: colors.dark.listSeparatorLabel,
     fontSize: 28,
     textAlign: 'center',
   },
   bottomButtonsContainer: {
     alignItems: 'center',
     bottom: 20,
     flexDirection: 'row',
     flex: 1,
     justifyContent: 'center',
     left: 0,
     position: 'absolute',
     right: 0,
   },
   closeButton: {
     left: 16,
     paddingBottom: 2,
     paddingHorizontal: 8,
     position: 'absolute',
     top: 6,
   },
   closeIcon: {
     color: 'white',
     fontSize: 36,
     textShadowColor: 'black',
     textShadowOffset: { width: 0, height: 1 },
     textShadowRadius: 1,
   },
   container: {
     backgroundColor: 'black',
     flex: 1,
   },
   fill: {
     flex: 1,
   },
   flashButton: {
     marginTop: (Platform.select({ android: 15, default: 13 }): number),
     paddingHorizontal: 10,
     paddingVertical: 3,
     position: 'absolute',
     right: 15,
     top: 3,
   },
   flashIcon: {
     color: 'white',
     fontSize: 24,
     textShadowColor: 'black',
     textShadowOffset: { width: 0, height: 1 },
     textShadowRadius: 1,
   },
   flashIconAutoText: {
     color: 'white',
     fontSize: 10,
     fontWeight: 'bold',
     position: 'absolute',
     right: 5,
     textShadowColor: 'black',
     textShadowOffset: { width: 0, height: 1 },
     textShadowRadius: 1,
     top: 0,
   },
   focusIndicator: {
     borderColor: 'white',
     borderRadius: 24,
     borderWidth: 1,
     height: 24,
     left: -12,
     position: 'absolute',
     top: -12,
     width: 24,
   },
   overlay: {
     backgroundColor: 'white',
     bottom: 0,
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
   retakeButton: {
     left: 20,
     marginTop: (Platform.select({ android: 15, default: 15 }): number),
     paddingBottom: 3,
     paddingHorizontal: 10,
     position: 'absolute',
     top: 6,
   },
   retakeIcon: {
     color: 'white',
     fontSize: 24,
     textShadowColor: 'black',
     textShadowOffset: { width: 0, height: 1 },
     textShadowRadius: 1,
   },
   saveButton: {
     alignItems: 'center',
     borderColor: 'white',
     borderRadius: 75,
     borderWidth: 4,
     height: 75,
     justifyContent: 'center',
     width: 75,
   },
   saveButtonInner: {
     backgroundColor: '#FFFFFF88',
     borderRadius: 60,
     height: 60,
     width: 60,
   },
   sendButtonContainer: {
     bottom: 22,
     position: 'absolute',
     right: 32,
   },
   stagingImage: {
     backgroundColor: 'black',
     flex: 1,
     resizeMode: 'contain',
   },
   stagingViewOverlay: {
     bottom: 0,
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
   switchCameraButton: {
     justifyContent: 'center',
     paddingHorizontal: 8,
     paddingVertical: 2,
     position: 'absolute',
     right: 18,
   },
   switchCameraIcon: {
     color: 'white',
     fontSize: 36,
     textShadowColor: 'black',
     textShadowOffset: { width: 0, height: 1 },
     textShadowRadius: 1,
   },
 });
 
 const ConnectedCameraModal: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedCameraModal(props: BaseProps) {
     const dimensions = useSelector(state => state.dimensions);
     const deviceCameraInfo = useSelector(state => state.deviceCameraInfo);
     const deviceOrientation = useSelector(state => state.deviceOrientation);
     const foreground = useIsAppForegrounded();
     const overlayContext = React.useContext(OverlayContext);
     const dispatch = useDispatch();
 
     return (
       <CameraModal
         {...props}
         dimensions={dimensions}
         deviceCameraInfo={deviceCameraInfo}
         deviceOrientation={deviceOrientation}
         foreground={foreground}
         dispatch={dispatch}
         overlayContext={overlayContext}
       />
     );
   });
 
 export default ConnectedCameraModal;
diff --git a/native/media/encrypted-image.react.js b/native/media/encrypted-image.react.js
index dbbca66f6..42407e86a 100644
--- a/native/media/encrypted-image.react.js
+++ b/native/media/encrypted-image.react.js
@@ -1,121 +1,121 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
 import { connectionSelector } from 'lib/selectors/keyserver-selectors.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import { decryptBase64, decryptMedia } from './encryption-utils.js';
 import LoadableImage from './loadable-image.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import type { ImageSource } from '../types/react-native.js';
 import type { ImageStyle } from '../types/styles.js';
 
 type BaseProps = {
   +blobURI: string,
   +encryptionKey: string,
   +onLoad?: (uri: string) => void,
   +spinnerColor: string,
   +style: ImageStyle,
   +invisibleLoad: boolean,
   +thumbHash?: ?string,
 };
 type Props = {
   ...BaseProps,
 };
 
 function EncryptedImage(props: Props): React.Node {
   const {
     blobURI,
     encryptionKey,
     onLoad: onLoadProp,
     thumbHash: encryptedThumbHash,
   } = props;
 
   const mediaCache = React.useContext(MediaCacheContext);
   const [source, setSource] = React.useState<?ImageSource>(null);
 
   const connection = useSelector(connectionSelector(ashoatKeyserverID));
   invariant(connection, 'keyserver missing from keyserverStore');
   const connectionStatus = connection.status;
   const prevConnectionStatusRef = React.useRef(connectionStatus);
   const [attempt, setAttempt] = React.useState(0);
   const [errorOccured, setErrorOccured] = React.useState(false);
 
   if (prevConnectionStatusRef.current !== connectionStatus) {
     if (!source && connectionStatus === 'connected') {
       setAttempt(attempt + 1);
     }
     prevConnectionStatusRef.current = connectionStatus;
   }
 
   const placeholder = React.useMemo(() => {
     if (!encryptedThumbHash) {
       return null;
     }
     try {
       const decryptedThumbHash = decryptBase64(
         encryptedThumbHash,
         encryptionKey,
       );
       return { thumbhash: decryptedThumbHash };
     } catch (e) {
       return null;
     }
   }, [encryptedThumbHash, encryptionKey]);
 
   React.useEffect(() => {
     let isMounted = true;
     setSource(null);
 
     const loadDecrypted = async () => {
       const cached = await mediaCache?.get(blobURI);
       if (cached && isMounted) {
         setSource({ uri: cached });
         return;
       }
 
       const { result } = await decryptMedia(blobURI, encryptionKey, {
         destination: 'data_uri',
       });
 
       if (isMounted) {
         if (result.success) {
-          mediaCache?.set(blobURI, result.uri);
+          void mediaCache?.set(blobURI, result.uri);
           setSource({ uri: result.uri });
         } else {
           setErrorOccured(true);
         }
       }
     };
 
-    loadDecrypted();
+    void loadDecrypted();
 
     return () => {
       isMounted = false;
     };
   }, [attempt, blobURI, encryptionKey, mediaCache]);
 
   const onLoad = React.useCallback(() => {
     onLoadProp && onLoadProp(blobURI);
   }, [blobURI, onLoadProp]);
 
   const { style, spinnerColor, invisibleLoad } = props;
 
   return (
     <LoadableImage
       placeholder={placeholder}
       source={source}
       onLoad={onLoad}
       spinnerColor={spinnerColor}
       style={style}
       invisibleLoad={invisibleLoad}
       key={attempt}
       errorOccured={errorOccured}
     />
   );
 }
 
 export default EncryptedImage;
diff --git a/native/media/media-gallery-keyboard.react.js b/native/media/media-gallery-keyboard.react.js
index ae379d973..bd9847575 100644
--- a/native/media/media-gallery-keyboard.react.js
+++ b/native/media/media-gallery-keyboard.react.js
@@ -1,684 +1,684 @@
 // @flow
 
 import * as ImagePicker from 'expo-image-picker';
 import * as MediaLibrary from 'expo-media-library';
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   View,
   Text,
   FlatList,
   ActivityIndicator,
   Animated,
   Easing,
   Platform,
 } from 'react-native';
 import { KeyboardRegistry } from 'react-native-keyboard-input';
 import { Provider } from 'react-redux';
 
 import {
   extensionFromFilename,
   filenameFromPathOrURI,
 } from 'lib/media/file-utils.js';
 import { useIsAppForegrounded } from 'lib/shared/lifecycle-utils.js';
 import type { MediaLibrarySelection } from 'lib/types/media-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 
 import { getCompatibleMediaURI } from './identifier-utils.js';
 import MediaGalleryMedia from './media-gallery-media.react.js';
 import SendMediaButton from './send-media-button.react.js';
 import Button from '../components/button.react.js';
 import type { DimensionsInfo } from '../redux/dimensions-updater.react.js';
 import { store } from '../redux/redux-setup.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { type Colors, useColors, useStyles } from '../themes/colors.js';
 import type {
   LayoutEvent,
   ViewableItemsChange,
 } from '../types/react-native.js';
 import type { ViewStyle } from '../types/styles.js';
 
 const animationSpec = {
   duration: 400,
   easing: Easing.inOut(Easing.ease),
   useNativeDriver: true,
 };
 
 const unboundStyles = {
   container: {
     backgroundColor: 'listBackground',
     position: 'absolute',
     left: 0,
     right: 0,
     top: 0,
   },
   galleryHeader: {
     height: 56,
     borderTopWidth: 1,
     borderColor: 'modalForegroundBorder',
     flexDirection: 'row',
     alignItems: 'center',
     justifyContent: 'space-between',
     paddingHorizontal: 16,
   },
   galleryHeaderTitle: {
     color: 'modalForegroundLabel',
     fontSize: 14,
     fontWeight: '500',
   },
   nativePickerButton: {
     backgroundColor: 'rgba(255, 255, 255, 0.08)',
     borderRadius: 8,
     paddingHorizontal: 12,
     paddingVertical: 7,
   },
   nativePickerButtonLabel: {
     color: 'modalButtonLabel',
     fontSize: 12,
     fontWeight: '500',
   },
   galleryContainer: {
     flex: 1,
     alignItems: 'center',
     flexDirection: 'row',
   },
   error: {
     color: 'listBackgroundLabel',
     flex: 1,
     fontSize: 28,
     textAlign: 'center',
   },
   loadingIndicator: {
     flex: 1,
   },
   sendButtonContainer: {
     bottom: 20,
     position: 'absolute',
     right: 30,
   },
   separator: {
     width: 2,
   },
 };
 
 type BaseProps = {
   +threadInfo: ?ThreadInfo,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +dimensions: DimensionsInfo,
   +foreground: boolean,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
 };
 type State = {
   +selections: ?$ReadOnlyArray<MediaLibrarySelection>,
   +error: ?string,
   +containerHeight: ?number,
   // null means end reached; undefined means no fetch yet
   +cursor: ?string,
   +queuedMediaURIs: ?Set<string>,
   +focusedMediaURI: ?string,
   +dimensions: DimensionsInfo,
 };
 class MediaGalleryKeyboard extends React.PureComponent<Props, State> {
   mounted = false;
   fetchingPhotos = false;
   flatList: ?FlatList<MediaLibrarySelection>;
   viewableIndices: number[] = [];
   queueModeProgress: Animated.Value = new Animated.Value(0);
   sendButtonStyle: ViewStyle;
   mediaSelected = false;
 
   constructor(props: Props) {
     super(props);
     const sendButtonScale = this.queueModeProgress.interpolate({
       inputRange: [0, 1],
       outputRange: ([1.3, 1]: number[]), // Flow...
     });
     this.sendButtonStyle = {
       opacity: this.queueModeProgress,
       transform: [{ scale: sendButtonScale }],
     };
     this.state = {
       selections: null,
       error: null,
       containerHeight: null,
       cursor: undefined,
       queuedMediaURIs: null,
       focusedMediaURI: null,
       dimensions: props.dimensions,
     };
   }
 
   static getDerivedStateFromProps(props: Props): Partial<State> {
     // We keep this in state since we pass this.state as
     // FlatList's extraData prop
     return { dimensions: props.dimensions };
   }
 
   componentDidMount() {
     this.mounted = true;
-    this.fetchPhotos();
+    void this.fetchPhotos();
   }
 
   componentWillUnmount() {
     this.mounted = false;
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     const { queuedMediaURIs } = this.state;
     const prevQueuedMediaURIs = prevState.queuedMediaURIs;
     if (queuedMediaURIs && !prevQueuedMediaURIs) {
       Animated.timing(this.queueModeProgress, {
         ...animationSpec,
         toValue: 1,
       }).start();
     } else if (!queuedMediaURIs && prevQueuedMediaURIs) {
       Animated.timing(this.queueModeProgress, {
         ...animationSpec,
         toValue: 0,
       }).start();
     }
 
     const { flatList, viewableIndices } = this;
     const { selections, focusedMediaURI } = this.state;
     let scrollingSomewhere = false;
     if (flatList && selections) {
       let newURI;
       if (focusedMediaURI && focusedMediaURI !== prevState.focusedMediaURI) {
         newURI = focusedMediaURI;
       } else if (
         queuedMediaURIs &&
         (!prevQueuedMediaURIs ||
           queuedMediaURIs.size > prevQueuedMediaURIs.size)
       ) {
         const flowMadeMeDoThis = queuedMediaURIs;
         for (const queuedMediaURI of flowMadeMeDoThis) {
           if (prevQueuedMediaURIs && prevQueuedMediaURIs.has(queuedMediaURI)) {
             continue;
           }
           newURI = queuedMediaURI;
           break;
         }
       }
       let index;
       if (newURI !== null && newURI !== undefined) {
         index = selections.findIndex(({ uri }) => uri === newURI);
       }
       if (index !== null && index !== undefined) {
         if (index === viewableIndices[0]) {
           scrollingSomewhere = true;
           flatList.scrollToIndex({ index });
         } else if (index === viewableIndices[viewableIndices.length - 1]) {
           scrollingSomewhere = true;
           flatList.scrollToIndex({ index, viewPosition: 1 });
         }
       }
     }
 
     if (this.props.foreground && !prevProps.foreground) {
-      this.fetchPhotos();
+      void this.fetchPhotos();
     }
 
     if (
       !scrollingSomewhere &&
       this.flatList &&
       this.state.selections &&
       prevState.selections &&
       this.state.selections.length > 0 &&
       prevState.selections.length > 0 &&
       this.state.selections[0].uri !== prevState.selections[0].uri
     ) {
       this.flatList.scrollToIndex({ index: 0 });
     }
   }
 
   guardedSetState(change: Partial<State>) {
     if (this.mounted) {
       this.setState(change);
     }
   }
 
   async fetchPhotos(after?: ?string) {
     if (this.fetchingPhotos) {
       return;
     }
     this.fetchingPhotos = true;
     try {
       const hasPermission = await this.getPermissions();
       if (!hasPermission) {
         return;
       }
       const { assets, endCursor, hasNextPage } =
         await MediaLibrary.getAssetsAsync({
           first: 20,
           after,
           mediaType: [
             MediaLibrary.MediaType.photo,
             MediaLibrary.MediaType.video,
           ],
           sortBy: [MediaLibrary.SortBy.modificationTime],
         });
 
       let firstRemoved = false,
         lastRemoved = false;
 
       const mediaURIs = this.state.selections
         ? this.state.selections.map(({ uri }) => uri)
         : [];
       const existingURIs = new Set(mediaURIs);
       let first = true;
       const selections = assets
         .map(asset => {
           const { id, height, width, filename, mediaType, duration } = asset;
           const isVideo = mediaType === MediaLibrary.MediaType.video;
           const uri = getCompatibleMediaURI(
             asset.uri,
             extensionFromFilename(filename),
           );
 
           if (existingURIs.has(uri)) {
             if (first) {
               firstRemoved = true;
             }
             lastRemoved = true;
             first = false;
             return null;
           }
           first = false;
           lastRemoved = false;
           existingURIs.add(uri);
 
           if (isVideo) {
             return {
               step: 'video_library',
               dimensions: { height, width },
               uri,
               filename,
               mediaNativeID: id,
               duration,
               selectTime: 0,
               sendTime: 0,
               retries: 0,
             };
           } else {
             return {
               step: 'photo_library',
               dimensions: { height, width },
               uri,
               filename,
               mediaNativeID: id,
               selectTime: 0,
               sendTime: 0,
               retries: 0,
             };
           }
         })
         .filter(Boolean);
 
       let appendOrPrepend = after ? 'append' : 'prepend';
       if (firstRemoved && !lastRemoved) {
         appendOrPrepend = 'append';
       } else if (!firstRemoved && lastRemoved) {
         appendOrPrepend = 'prepend';
       }
 
       let newSelections = selections;
       if (this.state.selections) {
         if (appendOrPrepend === 'prepend') {
           newSelections = [...newSelections, ...this.state.selections];
         } else {
           newSelections = [...this.state.selections, ...newSelections];
         }
       }
 
       this.guardedSetState({
         selections: newSelections,
         error: null,
         cursor: hasNextPage ? endCursor : null,
       });
     } catch (e) {
       this.guardedSetState({
         selections: null,
         error: 'something went wrong :(',
       });
     }
     this.fetchingPhotos = false;
   }
 
   openNativePicker = async () => {
     try {
       const { assets, canceled } = await ImagePicker.launchImageLibraryAsync({
         mediaTypes: ImagePicker.MediaTypeOptions.All,
         allowsEditing: false,
         allowsMultipleSelection: true,
         // maximum quality is 1 - it disables compression
         quality: 1,
         // we don't want to compress videos at this point
         videoExportPreset: ImagePicker.VideoExportPreset.Passthrough,
       });
 
       if (canceled || assets.length === 0) {
         return;
       }
 
       const selections = assets.map(asset => {
         const {
           width,
           height,
           fileName,
           type,
           duration,
           assetId: mediaNativeID,
         } = asset;
         const isVideo = type === 'video';
         const filename = fileName || filenameFromPathOrURI(asset.uri) || '';
         const uri = getCompatibleMediaURI(
           asset.uri,
           extensionFromFilename(filename),
         );
 
         if (isVideo) {
           return {
             step: 'video_library',
             dimensions: { height, width },
             uri,
             filename,
             mediaNativeID,
             duration,
             selectTime: 0,
             sendTime: 0,
             retries: 0,
           };
         } else {
           return {
             step: 'photo_library',
             dimensions: { height, width },
             uri,
             filename,
             mediaNativeID,
             selectTime: 0,
             sendTime: 0,
             retries: 0,
           };
         }
       });
 
       this.sendMedia(selections);
     } catch (e) {
       if (__DEV__) {
         console.warn(e);
       }
       this.guardedSetState({
         selections: null,
         error: 'something went wrong :(',
       });
     }
   };
 
   async getPermissions(): Promise<boolean> {
     const { granted } = await MediaLibrary.requestPermissionsAsync();
     if (!granted) {
       this.guardedSetState({ error: "don't have permission :(" });
     }
     return granted;
   }
 
   get queueModeActive(): boolean {
     return !!this.state.queuedMediaURIs;
   }
 
   renderItem = (row: { +item: MediaLibrarySelection, ... }): React.Node => {
     const { containerHeight, queuedMediaURIs } = this.state;
     invariant(containerHeight, 'should be set');
     const { uri } = row.item;
     const isQueued = !!(queuedMediaURIs && queuedMediaURIs.has(uri));
     const { queueModeActive } = this;
     return (
       <MediaGalleryMedia
         selection={row.item}
         containerHeight={containerHeight}
         queueModeActive={queueModeActive}
         isQueued={isQueued}
         setMediaQueued={this.setMediaQueued}
         sendMedia={this.sendSingleMedia}
         isFocused={this.state.focusedMediaURI === uri}
         setFocus={this.setFocus}
         dimensions={this.state.dimensions}
       />
     );
   };
 
   ItemSeparator = (): React.Node => {
     return <View style={this.props.styles.separator} />;
   };
 
   static keyExtractor = (item: MediaLibrarySelection): string => {
     return item.uri;
   };
 
   GalleryHeader = (): React.Node => (
     <View style={this.props.styles.galleryHeader}>
       <Text style={this.props.styles.galleryHeaderTitle}>Photos</Text>
       <Button
         onPress={this.openNativePicker}
         style={this.props.styles.nativePickerButton}
       >
         <Text style={this.props.styles.nativePickerButtonLabel}>
           Browse all Photos
         </Text>
       </Button>
     </View>
   );
 
   render(): React.Node {
     let content;
     const { selections, error, containerHeight } = this.state;
     const bottomOffsetStyle: ViewStyle = {
       marginBottom: this.props.dimensions.bottomInset,
     };
     if (selections && selections.length > 0 && containerHeight) {
       content = (
         <FlatList
           horizontal={true}
           data={selections}
           renderItem={this.renderItem}
           ItemSeparatorComponent={this.ItemSeparator}
           keyExtractor={MediaGalleryKeyboard.keyExtractor}
           scrollsToTop={false}
           showsHorizontalScrollIndicator={false}
           onEndReached={this.onEndReached}
           onEndReachedThreshold={5}
           onViewableItemsChanged={this.onViewableItemsChanged}
           extraData={this.state}
           ref={this.flatListRef}
         />
       );
     } else if (selections && containerHeight) {
       content = (
         <Text style={[this.props.styles.error, bottomOffsetStyle]}>
           no media was found!
         </Text>
       );
     } else if (error) {
       content = (
         <Text style={[this.props.styles.error, bottomOffsetStyle]}>
           {error}
         </Text>
       );
     } else {
       content = (
         <ActivityIndicator
           color={this.props.colors.listSeparatorLabel}
           size="large"
           style={[this.props.styles.loadingIndicator, bottomOffsetStyle]}
         />
       );
     }
 
     const { queuedMediaURIs } = this.state;
     const queueCount = queuedMediaURIs ? queuedMediaURIs.size : 0;
     const bottomInset: number = Platform.select({
       ios: -1 * this.props.dimensions.bottomInset,
       default: 0,
     });
     const containerStyle = { bottom: bottomInset };
     return (
       <View style={[this.props.styles.container, containerStyle]}>
         <this.GalleryHeader />
         <View
           style={this.props.styles.galleryContainer}
           onLayout={this.onContainerLayout}
         >
           {content}
           <SendMediaButton
             onPress={this.sendQueuedMedia}
             queueCount={queueCount}
             pointerEvents={queuedMediaURIs ? 'auto' : 'none'}
             containerStyle={[
               this.props.styles.sendButtonContainer,
               bottomOffsetStyle,
             ]}
             style={this.sendButtonStyle}
           />
         </View>
       </View>
     );
   }
 
   flatListRef = (flatList: ?FlatList<MediaLibrarySelection>) => {
     this.flatList = flatList;
   };
 
   onContainerLayout = (event: LayoutEvent) => {
     this.guardedSetState({ containerHeight: event.nativeEvent.layout.height });
   };
 
   onEndReached = () => {
     const { cursor } = this.state;
     if (cursor !== null) {
-      this.fetchPhotos(cursor);
+      void this.fetchPhotos(cursor);
     }
   };
 
   onViewableItemsChanged = (info: ViewableItemsChange) => {
     const viewableIndices = [];
     for (const { index } of info.viewableItems) {
       if (index !== null && index !== undefined) {
         viewableIndices.push(index);
       }
     }
     this.viewableIndices = viewableIndices;
   };
 
   setMediaQueued = (selection: MediaLibrarySelection, isQueued: boolean) => {
     this.setState((prevState: State) => {
       const prevQueuedMediaURIs = prevState.queuedMediaURIs
         ? [...prevState.queuedMediaURIs]
         : [];
       if (isQueued) {
         return {
           queuedMediaURIs: new Set([...prevQueuedMediaURIs, selection.uri]),
           focusedMediaURI: null,
         };
       }
       const queuedMediaURIs = prevQueuedMediaURIs.filter(
         uri => uri !== selection.uri,
       );
       if (queuedMediaURIs.length < prevQueuedMediaURIs.length) {
         return {
           queuedMediaURIs: new Set(queuedMediaURIs),
           focusedMediaURI: null,
         };
       }
       return null;
     });
   };
 
   setFocus = (selection: MediaLibrarySelection, isFocused: boolean) => {
     const { uri } = selection;
     if (isFocused) {
       this.setState({ focusedMediaURI: uri });
     } else if (this.state.focusedMediaURI === uri) {
       this.setState({ focusedMediaURI: null });
     }
   };
 
   sendSingleMedia = (selection: MediaLibrarySelection) => {
     this.sendMedia([selection]);
   };
 
   sendQueuedMedia = () => {
     const { selections, queuedMediaURIs } = this.state;
     if (!selections || !queuedMediaURIs) {
       return;
     }
     const queuedSelections = [];
     for (const uri of queuedMediaURIs) {
       for (const selection of selections) {
         if (selection.uri === uri) {
           queuedSelections.push(selection);
           break;
         }
       }
     }
     this.sendMedia(queuedSelections);
   };
 
   sendMedia(selections: $ReadOnlyArray<MediaLibrarySelection>) {
     if (this.mediaSelected) {
       return;
     }
     this.mediaSelected = true;
 
     const now = Date.now();
     const timeProps = {
       selectTime: now,
       sendTime: now,
     };
     const selectionsWithTime = selections.map(selection => ({
       ...selection,
       ...timeProps,
     }));
 
     KeyboardRegistry.onItemSelected(mediaGalleryKeyboardName, {
       selections: selectionsWithTime,
       threadInfo: this.props.threadInfo,
     });
   }
 }
 
 const mediaGalleryKeyboardName = 'MediaGalleryKeyboard';
 
 function ConnectedMediaGalleryKeyboard(props: BaseProps) {
   const dimensions = useSelector(state => state.dimensions);
   const foreground = useIsAppForegrounded();
   const colors = useColors();
   const styles = useStyles(unboundStyles);
   return (
     <MediaGalleryKeyboard
       dimensions={dimensions}
       foreground={foreground}
       colors={colors}
       styles={styles}
       {...props}
     />
   );
 }
 
 function ReduxMediaGalleryKeyboard(props: BaseProps) {
   return (
     <Provider store={store}>
       <ConnectedMediaGalleryKeyboard {...props} />
     </Provider>
   );
 }
 
 KeyboardRegistry.registerKeyboard(
   mediaGalleryKeyboardName,
   () => ReduxMediaGalleryKeyboard,
 );
 
 export { mediaGalleryKeyboardName };
diff --git a/native/media/video-playback-modal.react.js b/native/media/video-playback-modal.react.js
index d50bf3635..c57041a7f 100644
--- a/native/media/video-playback-modal.react.js
+++ b/native/media/video-playback-modal.react.js
@@ -1,834 +1,834 @@
 // @flow
 
 import Icon from '@expo/vector-icons/MaterialCommunityIcons.js';
 import invariant from 'invariant';
 import * as React from 'react';
 import { useState } from 'react';
 import { View, Text, TouchableOpacity } from 'react-native';
 import filesystem from 'react-native-fs';
 import {
   TapGestureHandler,
   type TapGestureEvent,
 } from 'react-native-gesture-handler';
 import * as Progress from 'react-native-progress';
 import Animated from 'react-native-reanimated';
 import { SafeAreaView } from 'react-native-safe-area-context';
 import Video from 'react-native-video';
 
 import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
 import { useIsAppBackgroundedOrInactive } from 'lib/shared/lifecycle-utils.js';
 import type { MediaInfo } from 'lib/types/media-types.js';
 
 import { decryptMedia } from './encryption-utils.js';
 import { formatDuration } from './video-utils.js';
 import ConnectedStatusBar from '../connected-status-bar.react.js';
 import type { AppNavigationProp } from '../navigation/app-navigator.react.js';
 import { OverlayContext } from '../navigation/overlay-context.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { derivedDimensionsInfoSelector } from '../selectors/dimensions-selectors.js';
 import { useStyles } from '../themes/colors.js';
 import type { ChatMultimediaMessageInfoItem } from '../types/chat-types.js';
 import type {
   VerticalBounds,
   LayoutCoordinates,
 } from '../types/layout-types.js';
 import type { NativeMethods } from '../types/react-native.js';
 import { gestureJustEnded, animateTowards } from '../utils/animation-utils.js';
 
 type TouchableOpacityInstance = React.AbstractComponent<
   React.ElementConfig<typeof TouchableOpacity>,
   NativeMethods,
 >;
 
 type VideoRef = {
   +seek: number => mixed,
   ...
 };
 
 /* eslint-disable import/no-named-as-default-member */
 const {
   Extrapolate,
   and,
   or,
   block,
   cond,
   eq,
   ceil,
   call,
   set,
   add,
   sub,
   multiply,
   divide,
   not,
   max,
   min,
   lessThan,
   greaterThan,
   abs,
   interpolateNode,
   useValue,
   event,
 } = Animated;
 
 export type VideoPlaybackModalParams = {
   +presentedFrom: string,
   +mediaInfo: MediaInfo,
   +initialCoordinates: LayoutCoordinates,
   +verticalBounds: VerticalBounds,
   +item: ChatMultimediaMessageInfoItem,
 };
 
 type ReactNativeVideoOnProgressData = {
   +currentTime: number,
   +playableDuration: number,
   +seekableDuration: number,
 };
 
 type Props = {
   +navigation: AppNavigationProp<'VideoPlaybackModal'>,
   +route: NavigationRoute<'VideoPlaybackModal'>,
 };
 function VideoPlaybackModal(props: Props): React.Node {
   const { mediaInfo } = props.route.params;
 
   const { uri: videoUri, holder: blobURI, encryptionKey } = mediaInfo;
   const [videoSource, setVideoSource] = React.useState(
     videoUri ? { uri: videoUri } : undefined,
   );
 
   const mediaCache = React.useContext(MediaCacheContext);
 
   React.useEffect(() => {
     // skip for unencrypted videos
     if (!blobURI || !encryptionKey) {
       return undefined;
     }
 
     let isMounted = true;
     let uriToDispose;
     setVideoSource(undefined);
 
     const loadDecrypted = async () => {
       const cached = await mediaCache?.get(blobURI);
       if (cached && isMounted) {
         setVideoSource({ uri: cached });
         return;
       }
 
       const { result } = await decryptMedia(blobURI, encryptionKey, {
         destination: 'file',
       });
       if (result.success) {
         const { uri } = result;
         const cacheSetPromise = mediaCache?.set(blobURI, uri);
         if (isMounted) {
           uriToDispose = uri;
           setVideoSource({ uri });
         } else {
           // dispose of the temporary file immediately when unmounted
           // but wait for the cache to be set
           await cacheSetPromise;
           filesystem.unlink(uri);
         }
       }
     };
-    loadDecrypted();
+    void loadDecrypted();
 
     return () => {
       isMounted = false;
       if (uriToDispose) {
         // remove the temporary file created by decryptMedia
         filesystem.unlink(uriToDispose);
       }
     };
   }, [blobURI, encryptionKey, mediaCache]);
 
   const closeButtonX = useValue(-1);
   const closeButtonY = useValue(-1);
   const closeButtonWidth = useValue(-1);
   const closeButtonHeight = useValue(-1);
   const closeButtonRef =
     React.useRef<?React.ElementRef<TouchableOpacityInstance>>();
   const closeButton = closeButtonRef.current;
   const onCloseButtonLayoutCalledRef = React.useRef(false);
   const onCloseButtonLayout = React.useCallback(() => {
     onCloseButtonLayoutCalledRef.current = true;
   }, []);
   const onCloseButtonLayoutCalled = onCloseButtonLayoutCalledRef.current;
   React.useEffect(() => {
     if (!closeButton || !onCloseButtonLayoutCalled) {
       return;
     }
     closeButton.measure((x, y, width, height, pageX, pageY) => {
       closeButtonX.setValue(pageX);
       closeButtonY.setValue(pageY);
       closeButtonWidth.setValue(width);
       closeButtonHeight.setValue(height);
     });
   }, [
     closeButton,
     onCloseButtonLayoutCalled,
     closeButtonX,
     closeButtonY,
     closeButtonWidth,
     closeButtonHeight,
   ]);
 
   const footerX = useValue(-1);
   const footerY = useValue(-1);
   const footerWidth = useValue(-1);
   const footerHeight = useValue(-1);
   const footerRef = React.useRef<?React.ElementRef<typeof View>>();
   const footer = footerRef.current;
   const onFooterLayoutCalledRef = React.useRef(false);
   const onFooterLayout = React.useCallback(() => {
     onFooterLayoutCalledRef.current = true;
   }, []);
   const onFooterLayoutCalled = onFooterLayoutCalledRef.current;
   React.useEffect(() => {
     if (!footer || !onFooterLayoutCalled) {
       return;
     }
     footer.measure((x, y, width, height, pageX, pageY) => {
       footerX.setValue(pageX);
       footerY.setValue(pageY);
       footerWidth.setValue(width);
       footerHeight.setValue(height);
     });
   }, [
     footer,
     onFooterLayoutCalled,
     footerX,
     footerY,
     footerWidth,
     footerHeight,
   ]);
 
   const controlsShowing = useValue(1);
   const outsideButtons = React.useCallback(
     (x: Animated.Value, y: Animated.Value) =>
       and(
         or(
           eq(controlsShowing, 0),
           lessThan(x, closeButtonX),
           greaterThan(x, add(closeButtonX, closeButtonWidth)),
           lessThan(y, closeButtonY),
           greaterThan(y, add(closeButtonY, closeButtonHeight)),
         ),
         or(
           eq(controlsShowing, 0),
           lessThan(x, footerX),
           greaterThan(x, add(footerX, footerWidth)),
           lessThan(y, footerY),
           greaterThan(y, add(footerY, footerHeight)),
         ),
       ),
     [
       controlsShowing,
       closeButtonX,
       closeButtonY,
       closeButtonWidth,
       closeButtonHeight,
       footerX,
       footerY,
       footerWidth,
       footerHeight,
     ],
   );
 
   /* ===== START FADE CONTROL ANIMATION ===== */
 
   const singleTapState = useValue(-1);
   const singleTapX = useValue(0);
   const singleTapY = useValue(0);
 
   const singleTapEvent = React.useMemo(
     () =>
       event<TapGestureEvent>([
         {
           nativeEvent: {
             state: singleTapState,
             x: singleTapX,
             y: singleTapY,
           },
         },
       ]),
     [singleTapState, singleTapX, singleTapY],
   );
 
   const lastTapX = useValue(-1);
   const lastTapY = useValue(-1);
 
   const activeControlsOpacity = React.useMemo(
     () =>
       animateTowards(
         block([
           cond(
             and(
               gestureJustEnded(singleTapState),
               outsideButtons(lastTapX, lastTapY),
             ),
             set(controlsShowing, not(controlsShowing)),
           ),
           set(lastTapX, singleTapX),
           set(lastTapY, singleTapY),
           controlsShowing,
         ]),
         150,
       ),
     [
       singleTapState,
       controlsShowing,
       outsideButtons,
       lastTapX,
       lastTapY,
       singleTapX,
       singleTapY,
     ],
   );
 
   const [controlsEnabled, setControlsEnabled] = React.useState(true);
   const enableControls = React.useCallback(() => setControlsEnabled(true), []);
   const disableControls = React.useCallback(
     () => setControlsEnabled(false),
     [],
   );
 
   const previousOpacityCeiling = useValue(-1);
   const opacityCeiling = React.useMemo(
     () => ceil(activeControlsOpacity),
     [activeControlsOpacity],
   );
 
   const opacityJustChanged = React.useMemo(
     () =>
       cond(eq(previousOpacityCeiling, opacityCeiling), 0, [
         set(previousOpacityCeiling, opacityCeiling),
         1,
       ]),
     [previousOpacityCeiling, opacityCeiling],
   );
 
   const toggleControls = React.useMemo(
     () => [
       cond(
         and(eq(opacityJustChanged, 1), eq(opacityCeiling, 0)),
         call([], disableControls),
       ),
       cond(
         and(eq(opacityJustChanged, 1), eq(opacityCeiling, 1)),
         call([], enableControls),
       ),
     ],
     [opacityJustChanged, opacityCeiling, disableControls, enableControls],
   );
 
   /* ===== END FADE CONTROL ANIMATION ===== */
 
   const mediaDimensions = mediaInfo.dimensions;
   const screenDimensions = useSelector(derivedDimensionsInfoSelector);
 
   const frame = React.useMemo(
     () => ({
       width: screenDimensions.width,
       height: screenDimensions.safeAreaHeight,
     }),
     [screenDimensions],
   );
 
   const mediaDisplayDimensions = React.useMemo(() => {
     let { height: maxHeight, width: maxWidth } = frame;
     if (maxHeight > maxWidth) {
       maxHeight -= 100;
     } else {
       maxWidth -= 100;
     }
 
     if (
       mediaDimensions.height < maxHeight &&
       mediaDimensions.width < maxWidth
     ) {
       return mediaDimensions;
     }
 
     const heightRatio = maxHeight / mediaDimensions.height;
     const widthRatio = maxWidth / mediaDimensions.width;
 
     if (heightRatio < widthRatio) {
       return {
         height: maxHeight,
         width: mediaDimensions.width * heightRatio,
       };
     } else {
       return {
         width: maxWidth,
         height: mediaDimensions.height * widthRatio,
       };
     }
   }, [frame, mediaDimensions]);
 
   const centerX = useValue(frame.width / 2);
   const centerY = useValue(frame.height / 2 + screenDimensions.topInset);
   const frameWidth = useValue(frame.width);
   const frameHeight = useValue(frame.height);
   const imageWidth = useValue(mediaDisplayDimensions.width);
   const imageHeight = useValue(mediaDisplayDimensions.height);
 
   React.useEffect(() => {
     const { width: frameW, height: frameH } = frame;
     const { topInset } = screenDimensions;
     frameWidth.setValue(frameW);
     frameHeight.setValue(frameH);
 
     centerX.setValue(frameW / 2);
     centerY.setValue(frameH / 2 + topInset);
 
     const { width, height } = mediaDisplayDimensions;
     imageWidth.setValue(width);
     imageHeight.setValue(height);
   }, [
     screenDimensions,
     frame,
     mediaDisplayDimensions,
     frameWidth,
     frameHeight,
     centerX,
     centerY,
     imageWidth,
     imageHeight,
   ]);
 
   const left = React.useMemo(
     () => sub(centerX, divide(imageWidth, 2)),
     [centerX, imageWidth],
   );
   const top = React.useMemo(
     () => sub(centerY, divide(imageHeight, 2)),
     [centerY, imageHeight],
   );
 
   const { initialCoordinates } = props.route.params;
 
   const initialScale = React.useMemo(
     () => divide(initialCoordinates.width, imageWidth),
     [initialCoordinates, imageWidth],
   );
 
   const initialTranslateX = React.useMemo(
     () =>
       sub(
         initialCoordinates.x + initialCoordinates.width / 2,
         add(left, divide(imageWidth, 2)),
       ),
     [initialCoordinates, left, imageWidth],
   );
 
   const initialTranslateY = React.useMemo(
     () =>
       sub(
         initialCoordinates.y + initialCoordinates.height / 2,
         add(top, divide(imageHeight, 2)),
       ),
     [initialCoordinates, top, imageHeight],
   );
 
   // The all-important outputs
   const curScale = useValue(1);
   const curX = useValue(0);
   const curY = useValue(0);
   const curBackdropOpacity = useValue(1);
 
   const progressiveOpacity = React.useMemo(
     () =>
       max(
         min(
           sub(1, abs(divide(curX, frameWidth))),
           sub(1, abs(divide(curY, frameHeight))),
         ),
         0,
       ),
     [curX, curY, frameWidth, frameHeight],
   );
 
   const updates = React.useMemo(
     () => [toggleControls, set(curBackdropOpacity, progressiveOpacity)],
     [curBackdropOpacity, progressiveOpacity, toggleControls],
   );
   const updatedScale = React.useMemo(
     () => [updates, curScale],
     [updates, curScale],
   );
   const updatedCurX = React.useMemo(() => [updates, curX], [updates, curX]);
   const updatedCurY = React.useMemo(() => [updates, curY], [updates, curY]);
   const updatedBackdropOpacity = React.useMemo(
     () => [updates, curBackdropOpacity],
     [updates, curBackdropOpacity],
   );
 
   const updatedActiveControlsOpacity = React.useMemo(
     () => block([updates, activeControlsOpacity]),
     [updates, activeControlsOpacity],
   );
 
   const overlayContext = React.useContext(OverlayContext);
   invariant(overlayContext, 'VideoPlaybackModal should have OverlayContext');
   const navigationProgress = overlayContext.position;
 
   const reverseNavigationProgress = React.useMemo(
     () => sub(1, navigationProgress),
     [navigationProgress],
   );
 
   const dismissalButtonOpacity = interpolateNode(updatedBackdropOpacity, {
     inputRange: [0.95, 1],
     outputRange: [0, 1],
     extrapolate: Extrapolate.CLAMP,
   });
   const controlsOpacity = multiply(
     navigationProgress,
     dismissalButtonOpacity,
     updatedActiveControlsOpacity,
   );
 
   const scale = React.useMemo(
     () =>
       add(
         multiply(reverseNavigationProgress, initialScale),
         multiply(navigationProgress, updatedScale),
       ),
     [reverseNavigationProgress, initialScale, navigationProgress, updatedScale],
   );
 
   const x = React.useMemo(
     () =>
       add(
         multiply(reverseNavigationProgress, initialTranslateX),
         multiply(navigationProgress, updatedCurX),
       ),
     [
       reverseNavigationProgress,
       initialTranslateX,
       navigationProgress,
       updatedCurX,
     ],
   );
 
   const y = React.useMemo(
     () =>
       add(
         multiply(reverseNavigationProgress, initialTranslateY),
         multiply(navigationProgress, updatedCurY),
       ),
     [
       reverseNavigationProgress,
       initialTranslateY,
       navigationProgress,
       updatedCurY,
     ],
   );
 
   const backdropOpacity = React.useMemo(
     () => multiply(navigationProgress, updatedBackdropOpacity),
     [navigationProgress, updatedBackdropOpacity],
   );
 
   const imageContainerOpacity = React.useMemo(
     () =>
       interpolateNode(navigationProgress, {
         inputRange: [0, 0.1],
         outputRange: [0, 1],
         extrapolate: Extrapolate.CLAMP,
       }),
     [navigationProgress],
   );
 
   const { verticalBounds } = props.route.params;
   const videoContainerStyle = React.useMemo(() => {
     const { height, width } = mediaDisplayDimensions;
     const { height: frameH, width: frameW } = frame;
 
     return {
       height,
       width,
       marginTop:
         (frameH - height) / 2 + screenDimensions.topInset - verticalBounds.y,
       marginLeft: (frameW - width) / 2,
       opacity: imageContainerOpacity,
       transform: [{ translateX: x }, { translateY: y }, { scale: scale }],
     };
   }, [
     mediaDisplayDimensions,
     frame,
     screenDimensions.topInset,
     verticalBounds.y,
     imageContainerOpacity,
     x,
     y,
     scale,
   ]);
 
   const styles = useStyles(unboundStyles);
 
   const [paused, setPaused] = useState(false);
   const [percentElapsed, setPercentElapsed] = useState(0);
   const [spinnerVisible, setSpinnerVisible] = useState(true);
   const [timeElapsed, setTimeElapsed] = useState('0:00');
   const [totalDuration, setTotalDuration] = useState('0:00');
   const videoRef = React.useRef<?VideoRef>();
 
   const backgroundedOrInactive = useIsAppBackgroundedOrInactive();
   React.useEffect(() => {
     if (backgroundedOrInactive) {
       setPaused(true);
       controlsShowing.setValue(1);
     }
   }, [backgroundedOrInactive, controlsShowing]);
 
   const { navigation } = props;
 
   const togglePlayback = React.useCallback(() => {
     setPaused(!paused);
   }, [paused]);
 
   const resetVideo = React.useCallback(() => {
     invariant(videoRef.current, 'videoRef.current should be set in resetVideo');
     videoRef.current.seek(0);
   }, []);
 
   const progressCallback = React.useCallback(
     (res: ReactNativeVideoOnProgressData) => {
       setTimeElapsed(formatDuration(res.currentTime));
       setTotalDuration(formatDuration(res.seekableDuration));
       setPercentElapsed(
         Math.ceil((res.currentTime / res.seekableDuration) * 100),
       );
     },
     [],
   );
 
   const readyForDisplayCallback = React.useCallback(() => {
     setSpinnerVisible(false);
   }, []);
 
   const statusBar = overlayContext.isDismissing ? null : (
     <ConnectedStatusBar hidden />
   );
 
   const backdropStyle = React.useMemo(
     () => ({ opacity: backdropOpacity }),
     [backdropOpacity],
   );
 
   const contentContainerStyle = React.useMemo(() => {
     const fullScreenHeight = screenDimensions.height;
     const bottom = fullScreenHeight - verticalBounds.y - verticalBounds.height;
 
     // margin will clip, but padding won't
     const verticalStyle = overlayContext.isDismissing
       ? { marginTop: verticalBounds.y, marginBottom: bottom }
       : { paddingTop: verticalBounds.y, paddingBottom: bottom };
     return [styles.contentContainer, verticalStyle];
   }, [
     screenDimensions.height,
     verticalBounds.y,
     verticalBounds.height,
     overlayContext.isDismissing,
     styles.contentContainer,
   ]);
 
   let controls;
   if (videoSource) {
     controls = (
       <Animated.View
         style={[styles.controls, { opacity: controlsOpacity }]}
         pointerEvents={controlsEnabled ? 'box-none' : 'none'}
       >
         <SafeAreaView style={styles.fill}>
           <View style={styles.fill}>
             <View style={styles.header}>
               <View style={styles.closeButton}>
                 <TouchableOpacity
                   onPress={navigation.goBackOnce}
                   ref={(closeButtonRef: any)}
                   onLayout={onCloseButtonLayout}
                 >
                   <Icon name="close" size={30} style={styles.iconButton} />
                 </TouchableOpacity>
               </View>
             </View>
             <View
               style={styles.footer}
               ref={footerRef}
               onLayout={onFooterLayout}
             >
               <TouchableOpacity
                 onPress={togglePlayback}
                 style={styles.playPauseButton}
               >
                 <Icon
                   name={paused ? 'play' : 'pause'}
                   size={28}
                   style={styles.iconButton}
                 />
               </TouchableOpacity>
               <View style={styles.progressBar}>
                 <Progress.Bar
                   progress={percentElapsed / 100}
                   height={4}
                   width={null}
                   color={styles.progressBar.color}
                   style={styles.expand}
                 />
               </View>
               <Text style={styles.durationText}>
                 {timeElapsed} / {totalDuration}
               </Text>
             </View>
           </View>
         </SafeAreaView>
       </Animated.View>
     );
   }
 
   let spinner;
   if (spinnerVisible) {
     spinner = (
       <Progress.Circle
         size={80}
         indeterminate={true}
         color="white"
         style={styles.progressCircle}
       />
     );
   }
 
   let videoPlayer;
   if (videoSource) {
     videoPlayer = (
       <Video
         source={videoSource}
         ref={videoRef}
         style={styles.backgroundVideo}
         paused={paused}
         onProgress={progressCallback}
         onEnd={resetVideo}
         onReadyForDisplay={readyForDisplayCallback}
       />
     );
   }
 
   return (
     <TapGestureHandler onHandlerStateChange={singleTapEvent} minPointers={1}>
       <Animated.View style={styles.expand}>
         {statusBar}
         <Animated.View style={[styles.backdrop, backdropStyle]} />
         <View style={contentContainerStyle}>
           {spinner}
           <Animated.View style={videoContainerStyle}>
             {videoPlayer}
           </Animated.View>
         </View>
         {controls}
       </Animated.View>
     </TapGestureHandler>
   );
 }
 
 const unboundStyles = {
   expand: {
     flex: 1,
   },
   backgroundVideo: {
     position: 'absolute',
     top: 0,
     left: 0,
     bottom: 0,
     right: 0,
   },
   footer: {
     position: 'absolute',
     left: 0,
     right: 0,
     bottom: 0,
     backgroundColor: 'rgba(52,52,52,0.6)',
     height: 76,
     display: 'flex',
     flexDirection: 'row',
     justifyContent: 'center',
     alignItems: 'center',
     paddingHorizontal: 8,
   },
   header: {
     position: 'absolute',
     left: 0,
     right: 0,
     top: 0,
   },
   playPauseButton: {
     display: 'flex',
     justifyContent: 'center',
     alignItems: 'center',
   },
   closeButton: {
     paddingTop: 10,
     paddingRight: 20,
     justifyContent: 'flex-end',
     alignItems: 'center',
     flexDirection: 'row',
     height: 100,
   },
   progressBar: {
     flex: 1,
     position: 'relative',
     alignItems: 'center',
     justifyContent: 'center',
     color: 'white',
     paddingRight: 10,
     display: 'flex',
     flexDirection: 'row',
   },
   progressCircle: {
     position: 'absolute',
     alignItems: 'center',
     justifyContent: 'center',
     top: 0,
     bottom: 0,
     left: 0,
     right: 0,
   },
   iconButton: {
     marginHorizontal: 10,
     color: 'white',
   },
   durationText: {
     color: 'white',
     fontSize: 11,
     width: 70,
   },
   backdrop: {
     backgroundColor: 'black',
     bottom: 0,
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
   controls: {
     position: 'absolute',
     bottom: 0,
     left: 0,
     right: 0,
     top: 0,
   },
   contentContainer: {
     flex: 1,
     overflow: 'hidden',
   },
   fill: {
     flex: 1,
   },
 };
 
 export default VideoPlaybackModal;
diff --git a/native/media/video-utils.js b/native/media/video-utils.js
index 88e7c54cb..989f1695e 100644
--- a/native/media/video-utils.js
+++ b/native/media/video-utils.js
@@ -1,294 +1,294 @@
 // @flow
 
 import invariant from 'invariant';
 import { Platform } from 'react-native';
 import filesystem from 'react-native-fs';
 
 import { mediaConfig, pathFromURI } from 'lib/media/file-utils.js';
 import { getVideoProcessingPlan } from 'lib/media/video-utils.js';
 import type { ProcessPlan } from 'lib/media/video-utils.js';
 import type {
   MediaMissionStep,
   MediaMissionFailure,
   VideoProbeMediaMissionStep,
   TranscodeVideoMediaMissionStep,
   VideoGenerateThumbnailMediaMissionStep,
   Dimensions,
 } from 'lib/types/media-types.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 
 import { ffmpeg } from './ffmpeg.js';
 import { temporaryDirectoryPath } from './file-utils.js';
 import { generateThumbhashStep } from './media-utils.js';
 
 // These are some numbers I sorta kinda made up
 // We should try to calculate them on a per-device basis
 const uploadSpeeds = Object.freeze({
   wifi: 4096, // in KiB/s
   cellular: 512, // in KiB/s
 });
 const clientTranscodeSpeed = 1.15; // in seconds of video transcoded per second
 
 type ProcessVideoInfo = {
   +uri: string,
   +mime: string,
   +filename: ?string,
   +fileSize: number,
   +dimensions: Dimensions,
   +hasWiFi: boolean,
 };
 
 type VideoProcessConfig = {
   +onTranscodingProgress?: (percent: number) => void,
 };
 
 type ProcessVideoResponse = {
   +success: true,
   +uri: string,
   +thumbnailURI: string,
   +mime: string,
   +dimensions: Dimensions,
   +loop: boolean,
   +thumbHash: ?string,
 };
 async function processVideo(
   input: ProcessVideoInfo,
   config: VideoProcessConfig,
 ): Promise<{
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: MediaMissionFailure | ProcessVideoResponse,
 }> {
   const steps: Array<MediaMissionStep> = [];
 
   const path = pathFromURI(input.uri);
   invariant(path, `could not extract path from ${input.uri}`);
 
   const initialCheckStep = await checkVideoInfo(path);
   steps.push(initialCheckStep);
   if (!initialCheckStep.success || !initialCheckStep.duration) {
     return { steps, result: { success: false, reason: 'video_probe_failed' } };
   }
   const { validFormat, duration } = initialCheckStep;
 
   const plan = getVideoProcessingPlan({
     inputPath: path,
     inputHasCorrectContainerAndCodec: validFormat,
     inputFileSize: input.fileSize,
     inputFilename: input.filename,
     inputMimeType: input.mime,
     inputDuration: duration,
     inputDimensions: input.dimensions,
     outputDirectory: temporaryDirectoryPath,
     // We want ffmpeg to use hardware-accelerated encoders. On iOS we can do
     // this using VideoToolbox, but ffmpeg on Android is still missing
     // MediaCodec encoding support: https://trac.ffmpeg.org/ticket/6407
     outputCodec: Platform.select({
       ios: 'h264_videotoolbox',
       //android: 'h264_mediacodec',
       default: 'h264',
     }),
     clientConnectionInfo: {
       hasWiFi: input.hasWiFi,
       speed: input.hasWiFi ? uploadSpeeds.wifi : uploadSpeeds.cellular,
     },
     clientTranscodeSpeed,
   });
   if (plan.action === 'reject') {
     return { steps, result: plan.failure };
   }
   if (plan.action === 'none') {
     const thumbnailStep = await generateThumbnail(path, plan.thumbnailPath);
     steps.push(thumbnailStep);
     if (!thumbnailStep.success) {
-      unlink(plan.thumbnailPath);
+      void unlink(plan.thumbnailPath);
       return {
         steps,
         result: { success: false, reason: 'video_generate_thumbnail_failed' },
       };
     }
     const thumbnailURI = `file://${plan.thumbnailPath}`;
     const thumbhashStep = await generateThumbhashStep(thumbnailURI);
     steps.push(thumbhashStep);
     const { thumbHash } = thumbhashStep;
     return {
       steps,
       result: {
         success: true,
         uri: input.uri,
         thumbnailURI,
         thumbHash,
         mime: 'video/mp4',
         dimensions: input.dimensions,
         loop: false,
       },
     };
   }
 
   const [thumbnailStep, transcodeStep] = await Promise.all([
     generateThumbnail(path, plan.thumbnailPath),
     transcodeVideo(plan, duration, config.onTranscodingProgress),
   ]);
   steps.push(thumbnailStep, transcodeStep);
 
   if (!thumbnailStep.success) {
-    unlink(plan.outputPath);
-    unlink(plan.thumbnailPath);
+    void unlink(plan.outputPath);
+    void unlink(plan.thumbnailPath);
     return {
       steps,
       result: {
         success: false,
         reason: 'video_generate_thumbnail_failed',
       },
     };
   }
   if (!transcodeStep.success) {
-    unlink(plan.outputPath);
-    unlink(plan.thumbnailPath);
+    void unlink(plan.outputPath);
+    void unlink(plan.thumbnailPath);
     return {
       steps,
       result: {
         success: false,
         reason: 'video_transcode_failed',
       },
     };
   }
 
   const transcodeProbeStep = await checkVideoInfo(plan.outputPath);
   steps.push(transcodeProbeStep);
   if (!transcodeProbeStep.validFormat) {
-    unlink(plan.outputPath);
-    unlink(plan.thumbnailPath);
+    void unlink(plan.outputPath);
+    void unlink(plan.thumbnailPath);
     return {
       steps,
       result: { success: false, reason: 'video_transcode_failed' },
     };
   }
 
   const dimensions = transcodeProbeStep.dimensions
     ? transcodeProbeStep.dimensions
     : input.dimensions;
   const loop = !!(
     mediaConfig[input.mime] &&
     mediaConfig[input.mime].videoConfig &&
     mediaConfig[input.mime].videoConfig.loop
   );
   const thumbnailURI = `file://${plan.thumbnailPath}`;
   const thumbhashStep = await generateThumbhashStep(thumbnailURI);
   steps.push(thumbhashStep);
   const { thumbHash } = thumbhashStep;
   return {
     steps,
     result: {
       success: true,
       uri: `file://${plan.outputPath}`,
       thumbnailURI,
       thumbHash,
       mime: 'video/mp4',
       dimensions,
       loop,
     },
   };
 }
 
 async function generateThumbnail(
   path: string,
   thumbnailPath: string,
 ): Promise<VideoGenerateThumbnailMediaMissionStep> {
   const thumbnailStart = Date.now();
   const thumbnailReturnCode = await ffmpeg.generateThumbnail(
     path,
     thumbnailPath,
   );
   const thumbnailGenerationSuccessful = thumbnailReturnCode === 0;
   return {
     step: 'video_generate_thumbnail',
     success: thumbnailGenerationSuccessful,
     time: Date.now() - thumbnailStart,
     returnCode: thumbnailReturnCode,
     thumbnailURI: thumbnailPath,
   };
 }
 
 async function transcodeVideo(
   plan: ProcessPlan,
   duration: number,
   onProgressCallback?: number => void,
 ): Promise<TranscodeVideoMediaMissionStep> {
   const transcodeStart = Date.now();
   let returnCode,
     newPath,
     stats,
     success = false,
     exceptionMessage;
   try {
     const { rc, lastStats } = await ffmpeg.transcodeVideo(
       plan.ffmpegCommand,
       duration,
       onProgressCallback,
     );
     success = rc === 0;
     if (success) {
       returnCode = rc;
       newPath = plan.outputPath;
       stats = lastStats;
     }
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
 
   return {
     step: 'video_ffmpeg_transcode',
     success,
     exceptionMessage,
     time: Date.now() - transcodeStart,
     returnCode,
     newPath,
     stats,
   };
 }
 
 async function checkVideoInfo(
   path: string,
 ): Promise<VideoProbeMediaMissionStep> {
   let codec,
     format,
     dimensions,
     duration,
     success = false,
     validFormat = false,
     exceptionMessage;
   const start = Date.now();
   try {
     ({ codec, format, dimensions, duration } = await ffmpeg.getVideoInfo(path));
     success = true;
     validFormat = codec === 'h264' && format.includes('mp4');
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'video_probe',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path,
     validFormat,
     duration,
     codec,
     format,
     dimensions,
   };
 }
 
 async function unlink(path: string) {
   try {
     await filesystem.unlink(path);
   } catch {}
 }
 
 function formatDuration(seconds: number): string {
   const mm = Math.floor(seconds / 60);
   const ss = (seconds % 60).toFixed(0).padStart(2, '0');
   return `${mm}:${ss}`;
 }
 
 export { processVideo, formatDuration };
diff --git a/native/navigation/app-navigator.react.js b/native/navigation/app-navigator.react.js
index e8d4bcc8b..73d8469d2 100644
--- a/native/navigation/app-navigator.react.js
+++ b/native/navigation/app-navigator.react.js
@@ -1,163 +1,163 @@
 // @flow
 
 import * as SplashScreen from 'expo-splash-screen';
 import * as React from 'react';
 import { PersistGate } from 'redux-persist/es/integration/react.js';
 
 import ActionResultModal from './action-result-modal.react.js';
 import { CommunityDrawerNavigator } from './community-drawer-navigator.react.js';
 import { createOverlayNavigator } from './overlay-navigator.react.js';
 import type {
   OverlayNavigationProp,
   OverlayNavigationHelpers,
 } from './overlay-navigator.react.js';
 import type { RootNavigationProp } from './root-navigator.react.js';
 import {
   UserAvatarCameraModalRouteName,
   ThreadAvatarCameraModalRouteName,
   ImageModalRouteName,
   MultimediaMessageTooltipModalRouteName,
   ActionResultModalRouteName,
   TextMessageTooltipModalRouteName,
   ThreadSettingsMemberTooltipModalRouteName,
   UserRelationshipTooltipModalRouteName,
   RobotextMessageTooltipModalRouteName,
   ChatCameraModalRouteName,
   VideoPlaybackModalRouteName,
   CommunityDrawerNavigatorRouteName,
   type ScreenParamList,
   type OverlayParamList,
   TogglePinModalRouteName,
 } from './route-names.js';
 import MultimediaMessageTooltipModal from '../chat/multimedia-message-tooltip-modal.react.js';
 import RobotextMessageTooltipModal from '../chat/robotext-message-tooltip-modal.react.js';
 import ThreadSettingsMemberTooltipModal from '../chat/settings/thread-settings-member-tooltip-modal.react.js';
 import TextMessageTooltipModal from '../chat/text-message-tooltip-modal.react.js';
 import TogglePinModal from '../chat/toggle-pin-modal.react.js';
 import KeyboardStateContainer from '../keyboard/keyboard-state-container.react.js';
 import ChatCameraModal from '../media/chat-camera-modal.react.js';
 import ImageModal from '../media/image-modal.react.js';
 import ThreadAvatarCameraModal from '../media/thread-avatar-camera-modal.react.js';
 import UserAvatarCameraModal from '../media/user-avatar-camera-modal.react.js';
 import VideoPlaybackModal from '../media/video-playback-modal.react.js';
 import UserRelationshipTooltipModal from '../profile/user-relationship-tooltip-modal.react.js';
 import PushHandler from '../push/push-handler.react.js';
 import { getPersistor } from '../redux/persist.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { RootContext } from '../root-context.js';
 import { useLoadCommFonts } from '../themes/fonts.js';
 import { waitForInteractions } from '../utils/timers.js';
 
 let splashScreenHasHidden = false;
 
 export type AppNavigationProp<
   RouteName: $Keys<OverlayParamList> = $Keys<OverlayParamList>,
 > = OverlayNavigationProp<ScreenParamList, RouteName>;
 
 const App = createOverlayNavigator<
   ScreenParamList,
   OverlayParamList,
   OverlayNavigationHelpers<ScreenParamList>,
 >();
 type AppNavigatorProps = {
   navigation: RootNavigationProp<'App'>,
   ...
 };
 function AppNavigator(props: AppNavigatorProps): React.Node {
   const { navigation } = props;
 
   const fontsLoaded = useLoadCommFonts();
 
   const rootContext = React.useContext(RootContext);
   const storeLoadedFromLocalDatabase = useSelector(state => state.storeLoaded);
   const setNavStateInitialized =
     rootContext && rootContext.setNavStateInitialized;
   React.useEffect(() => {
     setNavStateInitialized && setNavStateInitialized();
   }, [setNavStateInitialized]);
 
   const [localSplashScreenHasHidden, setLocalSplashScreenHasHidden] =
     React.useState(splashScreenHasHidden);
 
   React.useEffect(() => {
     if (localSplashScreenHasHidden || !fontsLoaded) {
       return;
     }
     splashScreenHasHidden = true;
-    (async () => {
+    void (async () => {
       await waitForInteractions();
       try {
         await SplashScreen.hideAsync();
       } finally {
         setLocalSplashScreenHasHidden(true);
       }
     })();
   }, [localSplashScreenHasHidden, fontsLoaded]);
 
   let pushHandler;
   if (localSplashScreenHasHidden) {
     pushHandler = (
       <PersistGate persistor={getPersistor()}>
         <PushHandler navigation={navigation} />
       </PersistGate>
     );
   }
   if (!storeLoadedFromLocalDatabase) {
     return null;
   }
   return (
     <KeyboardStateContainer>
       <App.Navigator>
         <App.Screen
           name={CommunityDrawerNavigatorRouteName}
           component={CommunityDrawerNavigator}
         />
         <App.Screen name={ImageModalRouteName} component={ImageModal} />
         <App.Screen
           name={MultimediaMessageTooltipModalRouteName}
           component={MultimediaMessageTooltipModal}
         />
         <App.Screen
           name={ActionResultModalRouteName}
           component={ActionResultModal}
         />
         <App.Screen
           name={TextMessageTooltipModalRouteName}
           component={TextMessageTooltipModal}
         />
         <App.Screen
           name={ThreadSettingsMemberTooltipModalRouteName}
           component={ThreadSettingsMemberTooltipModal}
         />
         <App.Screen
           name={UserRelationshipTooltipModalRouteName}
           component={UserRelationshipTooltipModal}
         />
         <App.Screen
           name={RobotextMessageTooltipModalRouteName}
           component={RobotextMessageTooltipModal}
         />
         <App.Screen
           name={ChatCameraModalRouteName}
           component={ChatCameraModal}
         />
         <App.Screen
           name={UserAvatarCameraModalRouteName}
           component={UserAvatarCameraModal}
         />
         <App.Screen
           name={ThreadAvatarCameraModalRouteName}
           component={ThreadAvatarCameraModal}
         />
         <App.Screen
           name={VideoPlaybackModalRouteName}
           component={VideoPlaybackModal}
         />
         <App.Screen name={TogglePinModalRouteName} component={TogglePinModal} />
       </App.Navigator>
       {pushHandler}
     </KeyboardStateContainer>
   );
 }
 
 export default AppNavigator;
diff --git a/native/navigation/deep-links-context-provider.react.js b/native/navigation/deep-links-context-provider.react.js
index c019de53a..2e3ac806a 100644
--- a/native/navigation/deep-links-context-provider.react.js
+++ b/native/navigation/deep-links-context-provider.react.js
@@ -1,139 +1,142 @@
 // @flow
 
 import { useNavigation } from '@react-navigation/native';
 import * as Application from 'expo-application';
 import * as React from 'react';
 import { Linking, Platform } from 'react-native';
 
 import {
   verifyInviteLink,
   verifyInviteLinkActionTypes,
 } from 'lib/actions/link-actions.js';
 import {
   parseInstallReferrerFromInviteLinkURL,
   parseDataFromDeepLink,
   type ParsedDeepLinkData,
 } from 'lib/facts/links.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import type { SetState } from 'lib/types/hook-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 
 import {
   InviteLinkModalRouteName,
   SecondaryDeviceQRCodeScannerRouteName,
 } from './route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useOnFirstLaunchEffect } from '../utils/hooks.js';
 
 type DeepLinksContextType = {
   +setCurrentLinkUrl: SetState<?string>,
 };
 
 const defaultContext = {
   setCurrentLinkUrl: () => {},
 };
 
 const DeepLinksContext: React.Context<DeepLinksContextType> =
   React.createContext<DeepLinksContextType>(defaultContext);
 
 type Props = {
   +children: React.Node,
 };
 function DeepLinksContextProvider(props: Props): React.Node {
   const { children } = props;
   const [currentLink, setCurrentLink] = React.useState<?string>(null);
 
   React.useEffect(() => {
     // This listener listens for an event where a user clicked a link when the
     // app was running
     const subscription = Linking.addEventListener('url', ({ url }) =>
       setCurrentLink(url),
     );
     // We're also checking if the app was opened by using a link.
     // In that case the listener won't be called and we're instead checking
     // if the initial URL is set.
-    (async () => {
+    void (async () => {
       const initialURL = await Linking.getInitialURL();
       if (initialURL) {
         setCurrentLink(initialURL);
       }
     })();
 
     return () => {
       subscription.remove();
     };
   }, []);
 
   const checkInstallReferrer = React.useCallback(async () => {
     if (Platform.OS !== 'android') {
       return;
     }
     const installReferrer = await Application.getInstallReferrerAsync();
     if (!installReferrer) {
       return;
     }
     const linkSecret = parseInstallReferrerFromInviteLinkURL(installReferrer);
     if (linkSecret) {
       setCurrentLink(linkSecret);
     }
   }, []);
   useOnFirstLaunchEffect('ANDROID_REFERRER', checkInstallReferrer);
 
   const loggedIn = useSelector(isLoggedIn);
   const dispatchActionPromise = useDispatchActionPromise();
   const validateLink = useServerCall(verifyInviteLink);
   const navigation = useNavigation();
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       if (!loggedIn || !currentLink) {
         return;
       }
       // We're setting this to null so that we ensure that each link click
       // results in at most one validation and navigation.
       setCurrentLink(null);
 
       const parsedData: ParsedDeepLinkData = parseDataFromDeepLink(currentLink);
       if (!parsedData) {
         return;
       }
 
       if (parsedData.type === 'invite-link') {
         const { secret } = parsedData.data;
         const validateLinkPromise = validateLink({ secret });
-        dispatchActionPromise(verifyInviteLinkActionTypes, validateLinkPromise);
+        void dispatchActionPromise(
+          verifyInviteLinkActionTypes,
+          validateLinkPromise,
+        );
         const result = await validateLinkPromise;
         if (result.status === 'already_joined') {
           return;
         }
 
         navigation.navigate<'InviteLinkModal'>({
           name: InviteLinkModalRouteName,
           params: {
             invitationDetails: result,
             secret,
           },
         });
       } else if (parsedData.type === 'qr-code') {
         navigation.navigate(SecondaryDeviceQRCodeScannerRouteName);
       }
     })();
   }, [currentLink, dispatchActionPromise, loggedIn, navigation, validateLink]);
 
   const contextValue = React.useMemo(
     () => ({
       setCurrentLinkUrl: setCurrentLink,
     }),
     [],
   );
 
   return (
     <DeepLinksContext.Provider value={contextValue}>
       {children}
     </DeepLinksContext.Provider>
   );
 }
 
 export { DeepLinksContext, DeepLinksContextProvider };
diff --git a/native/navigation/invite-link-modal.react.js b/native/navigation/invite-link-modal.react.js
index 8e3bc924b..0b37397d7 100644
--- a/native/navigation/invite-link-modal.react.js
+++ b/native/navigation/invite-link-modal.react.js
@@ -1,251 +1,254 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text, ActivityIndicator } from 'react-native';
 
 import {
   useJoinThread,
   joinThreadActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { InviteLinkVerificationResponse } from 'lib/types/link-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import { nonThreadCalendarQuery } from './nav-selectors.js';
 import { NavContext } from './navigation-context.js';
 import type { RootNavigationProp } from './root-navigator.react.js';
 import type { NavigationRoute } from './route-names.js';
 import Button from '../components/button.react.js';
 import Modal from '../components/modal.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 
 export type InviteLinkModalParams = {
   +invitationDetails: InviteLinkVerificationResponse,
   +secret: string,
 };
 
 type Props = {
   +navigation: RootNavigationProp<'InviteLinkModal'>,
   +route: NavigationRoute<'InviteLinkModal'>,
 };
 
 function InviteLinkModal(props: Props): React.Node {
   const styles = useStyles(unboundStyles);
   const { invitationDetails, secret } = props.route.params;
 
   React.useEffect(() => {
     if (invitationDetails.status === 'already_joined') {
       props.navigation.goBack();
     }
   }, [invitationDetails.status, props.navigation]);
 
   const header = React.useMemo(() => {
     if (invitationDetails.status === 'valid') {
       return (
         <>
           <Text style={styles.invitation}>You have been invited to join</Text>
           <Text style={styles.communityName}>
             {invitationDetails.community.name}
           </Text>
         </>
       );
     }
     return (
       <>
         <Text style={styles.invalidInviteTitle}>Invite invalid</Text>
         <Text style={styles.invalidInviteExplanation}>
           This invite link may be expired. Please try again with another invite
           link.
         </Text>
       </>
     );
   }, [
     invitationDetails,
     styles.communityName,
     styles.invalidInviteExplanation,
     styles.invalidInviteTitle,
     styles.invitation,
   ]);
 
   const callJoinThread = useJoinThread();
   const navContext = React.useContext(NavContext);
   const calendarQuery = useSelector(state =>
     nonThreadCalendarQuery({
       redux: state,
       navContext,
     }),
   );
   const communityID = invitationDetails.community?.id;
   const createJoinCommunityAction = React.useCallback(async () => {
     invariant(
       communityID,
       'CommunityID should be present while calling this function',
     );
     const query = calendarQuery();
     try {
       const result = await callJoinThread({
         threadID: communityID,
         calendarQuery: {
           startDate: query.startDate,
           endDate: query.endDate,
           filters: [
             ...query.filters,
             { type: 'threads', threadIDs: [communityID] },
           ],
         },
         inviteLinkSecret: secret,
       });
       props.navigation.goBack();
       return result;
     } catch (e) {
       props.navigation.setParams({
         invitationDetails: {
           status: 'invalid',
         },
         secret,
       });
       throw e;
     }
   }, [calendarQuery, callJoinThread, communityID, props.navigation, secret]);
   const dispatchActionPromise = useDispatchActionPromise();
   const joinCommunity = React.useCallback(() => {
-    dispatchActionPromise(joinThreadActionTypes, createJoinCommunityAction());
+    void dispatchActionPromise(
+      joinThreadActionTypes,
+      createJoinCommunityAction(),
+    );
   }, [createJoinCommunityAction, dispatchActionPromise]);
   const joinThreadLoadingStatus = useSelector(joinThreadLoadingStatusSelector);
 
   const buttons = React.useMemo(() => {
     if (invitationDetails.status === 'valid') {
       const joinButtonContent =
         joinThreadLoadingStatus === 'loading' ? (
           <ActivityIndicator
             size="small"
             color="white"
             style={styles.activityIndicatorStyle}
           />
         ) : (
           <Text style={styles.buttonText}>Accept invite</Text>
         );
       return (
         <>
           <Button
             style={[styles.button, styles.buttonPrimary, styles.gap]}
             onPress={joinCommunity}
             disabled={joinThreadLoadingStatus === 'loading'}
           >
             {joinButtonContent}
           </Button>
           <Button
             style={[styles.button, styles.buttonSecondary]}
             onPress={props.navigation.goBack}
           >
             <Text style={styles.buttonText}>Cancel</Text>
           </Button>
         </>
       );
     }
     return (
       <Button
         style={[styles.button, styles.buttonPrimary]}
         onPress={props.navigation.goBack}
       >
         <Text style={styles.buttonText}>Return to Comm</Text>
       </Button>
     );
   }, [
     invitationDetails.status,
     joinCommunity,
     joinThreadLoadingStatus,
     props.navigation.goBack,
     styles.activityIndicatorStyle,
     styles.button,
     styles.buttonPrimary,
     styles.buttonSecondary,
     styles.buttonText,
     styles.gap,
   ]);
 
   return (
     <Modal modalStyle={styles.modal}>
       <View>{header}</View>
       <View style={styles.separator} />
       <View>{buttons}</View>
     </Modal>
   );
 }
 
 const joinThreadLoadingStatusSelector = createLoadingStatusSelector(
   joinThreadActionTypes,
 );
 
 const unboundStyles = {
   modal: {
     backgroundColor: 'modalForeground',
     paddingVertical: 24,
     paddingHorizontal: 16,
     flex: 0,
   },
   invitation: {
     color: 'whiteText',
     textAlign: 'center',
     fontSize: 14,
     fontWeight: '400',
     lineHeight: 22,
     marginBottom: 24,
   },
   communityName: {
     color: 'whiteText',
     textAlign: 'center',
     fontSize: 18,
     fontWeight: '500',
     lineHeight: 24,
   },
   invalidInviteTitle: {
     color: 'whiteText',
     textAlign: 'center',
     fontSize: 22,
     fontWeight: '500',
     lineHeight: 28,
     marginBottom: 24,
   },
   invalidInviteExplanation: {
     color: 'whiteText',
     textAlign: 'center',
     fontSize: 14,
     fontWeight: '400',
     lineHeight: 22,
   },
   separator: {
     height: 1,
     backgroundColor: 'modalSeparator',
     marginVertical: 24,
   },
   gap: {
     marginBottom: 16,
   },
   button: {
     borderRadius: 8,
     paddingVertical: 12,
     paddingHorizontal: 24,
   },
   buttonPrimary: {
     backgroundColor: 'purpleButton',
   },
   buttonSecondary: {
     borderColor: 'secondaryButtonBorder',
     borderWidth: 1,
   },
   buttonText: {
     color: 'whiteText',
     textAlign: 'center',
     fontSize: 16,
     fontWeight: '500',
     lineHeight: 24,
   },
   activityIndicatorStyle: {
     paddingVertical: 2,
   },
 };
 
 export default InviteLinkModal;
diff --git a/native/profile/default-notifications-preferences.react.js b/native/profile/default-notifications-preferences.react.js
index 706df3400..c6cd949fd 100644
--- a/native/profile/default-notifications-preferences.react.js
+++ b/native/profile/default-notifications-preferences.react.js
@@ -1,213 +1,213 @@
 // @flow
 
 import * as React from 'react';
 import { View, Text, Platform } from 'react-native';
 import { ScrollView } from 'react-native-gesture-handler';
 
 import {
   useSetUserSettings,
   setUserSettingsActionTypes,
 } from 'lib/actions/user-actions.js';
 import { registerFetchKey } from 'lib/reducers/loading-reducer.js';
 import {
   type UpdateUserSettingsRequest,
   type NotificationTypes,
   type DefaultNotificationPayload,
   notificationTypes,
   userSettingsTypes,
 } from 'lib/types/account-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import Action from '../components/action-row.react.js';
 import SWMansionIcon from '../components/swmansion-icon.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 import Alert from '../utils/alert.js';
 
 const CheckIcon = () => (
   <SWMansionIcon
     name="check"
     size={20}
     color="#888888"
     style={unboundStyles.icon}
   />
 );
 
 type ProfileRowProps = {
   +content: string,
   +onPress: () => void,
   +danger?: boolean,
   +selected?: boolean,
 };
 
 function NotificationRow(props: ProfileRowProps): React.Node {
   const { content, onPress, danger, selected } = props;
   return (
     <Action.Row onPress={onPress}>
       <Action.Text danger={danger} content={content} />
       {selected ? <CheckIcon /> : null}
     </Action.Row>
   );
 }
 
 const unboundStyles = {
   scrollView: {
     backgroundColor: 'panelBackground',
   },
   scrollViewContentContainer: {
     paddingTop: 24,
   },
   section: {
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     borderTopWidth: 1,
     marginBottom: 24,
     marginVertical: 2,
   },
   icon: {
     lineHeight: Platform.OS === 'ios' ? 18 : 20,
   },
   header: {
     color: 'panelBackgroundLabel',
     fontSize: 12,
     fontWeight: '400',
     paddingBottom: 3,
     paddingHorizontal: 24,
   },
 };
 
 type BaseProps = {
   +navigation: ProfileNavigationProp<'DefaultNotifications'>,
   +route: NavigationRoute<'DefaultNotifications'>,
 };
 
 type Props = {
   ...BaseProps,
   +styles: $ReadOnly<typeof unboundStyles>,
   +dispatchActionPromise: DispatchActionPromise,
   +changeNotificationSettings: (
     notificationSettingsRequest: UpdateUserSettingsRequest,
   ) => Promise<void>,
   +selectedDefaultNotification: NotificationTypes,
 };
 
 class DefaultNotificationsPreferences extends React.PureComponent<Props> {
   async updatedDefaultNotifications(
     data: NotificationTypes,
   ): Promise<DefaultNotificationPayload> {
     const { changeNotificationSettings } = this.props;
 
     try {
       await changeNotificationSettings({
         name: userSettingsTypes.DEFAULT_NOTIFICATIONS,
         data,
       });
     } catch (e) {
       Alert.alert(
         'Unknown error',
         'Uhh... try again?',
         [{ text: 'OK', onPress: () => {} }],
         { cancelable: false },
       );
     }
 
     return {
       [userSettingsTypes.DEFAULT_NOTIFICATIONS]: data,
     };
   }
 
   selectNotificationSetting = (data: NotificationTypes) => {
     const { dispatchActionPromise } = this.props;
 
-    dispatchActionPromise(
+    void dispatchActionPromise(
       setUserSettingsActionTypes,
       this.updatedDefaultNotifications(data),
     );
   };
 
   selectAllNotifications = () => {
     this.selectNotificationSetting(notificationTypes.FOCUSED);
   };
 
   selectBackgroundNotifications = () => {
     this.selectNotificationSetting(notificationTypes.BACKGROUND);
   };
 
   selectNoneNotifications = () => {
     this.selectNotificationSetting(notificationTypes.BADGE_ONLY);
   };
 
   render(): React.Node {
     const { styles, selectedDefaultNotification } = this.props;
     return (
       <ScrollView
         contentContainerStyle={styles.scrollViewContentContainer}
         style={styles.scrollView}
       >
         <Text style={styles.header}>NOTIFICATIONS</Text>
         <View style={styles.section}>
           <NotificationRow
             content="Focused"
             onPress={this.selectAllNotifications}
             selected={notificationTypes.FOCUSED === selectedDefaultNotification}
           />
           <NotificationRow
             content="Focused (badge only)"
             onPress={this.selectBackgroundNotifications}
             selected={
               notificationTypes.BADGE_ONLY === selectedDefaultNotification
             }
           />
           <NotificationRow
             content="Background"
             onPress={this.selectNoneNotifications}
             selected={
               notificationTypes.BACKGROUND === selectedDefaultNotification
             }
           />
         </View>
       </ScrollView>
     );
   }
 }
 
 registerFetchKey(setUserSettingsActionTypes);
 const ConnectedDefaultNotificationPreferences: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedDefaultNotificationPreferences(
     props: BaseProps,
   ) {
     const styles = useStyles(unboundStyles);
     const dispatchActionPromise = useDispatchActionPromise();
     const changeNotificationSettings = useSetUserSettings();
     const defaultNotification = userSettingsTypes.DEFAULT_NOTIFICATIONS;
 
     const selectedDefaultNotification = useSelector<NotificationTypes>(
       ({ currentUserInfo }) => {
         if (
           currentUserInfo?.settings &&
           currentUserInfo?.settings[defaultNotification]
         ) {
           return currentUserInfo?.settings[defaultNotification];
         }
         return notificationTypes.FOCUSED;
       },
     );
 
     return (
       <DefaultNotificationsPreferences
         {...props}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         changeNotificationSettings={changeNotificationSettings}
         selectedDefaultNotification={selectedDefaultNotification}
       />
     );
   });
 
 export default ConnectedDefaultNotificationPreferences;
diff --git a/native/profile/delete-account.react.js b/native/profile/delete-account.react.js
index 43966efd3..b99ae8b50 100644
--- a/native/profile/delete-account.react.js
+++ b/native/profile/delete-account.react.js
@@ -1,122 +1,125 @@
 // @flow
 
 import * as React from 'react';
 import { Text, View, ActivityIndicator } from 'react-native';
 import { ScrollView } from 'react-native-gesture-handler';
 
 import {
   deleteKeyserverAccountActionTypes,
   useDeleteKeyserverAccount,
 } from 'lib/actions/user-actions.js';
 import { preRequestUserStateSelector } from 'lib/selectors/account-selectors.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import { deleteNativeCredentialsFor } from '../account/native-credentials.js';
 import Button from '../components/button.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 import Alert from '../utils/alert.js';
 
 const loadingStatusSelector = createLoadingStatusSelector(
   deleteKeyserverAccountActionTypes,
 );
 
 type Props = {
   +navigation: ProfileNavigationProp<'DeleteAccount'>,
   +route: NavigationRoute<'DeleteAccount'>,
 };
 const DeleteAccount: React.ComponentType<Props> = React.memo<Props>(
   function DeleteAccount() {
     const loadingStatus = useSelector(loadingStatusSelector);
     const preRequestUserState = useSelector(preRequestUserStateSelector);
     const styles = useStyles(unboundStyles);
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callDeleteAccount = useDeleteKeyserverAccount();
 
     const buttonContent =
       loadingStatus === 'loading' ? (
         <ActivityIndicator size="small" color="white" />
       ) : (
         <Text style={styles.saveText}>Delete account</Text>
       );
 
     const noWayToReverseThisStyles = React.useMemo(
       () => [styles.warningText, styles.lastWarningText],
       [styles.warningText, styles.lastWarningText],
     );
 
     const deleteAction = React.useCallback(async () => {
       try {
         await deleteNativeCredentialsFor();
         return await callDeleteAccount(preRequestUserState);
       } catch (e) {
         Alert.alert('Unknown error', 'Uhh... try again?', [{ text: 'OK' }], {
           cancelable: false,
         });
         throw e;
       }
     }, [callDeleteAccount, preRequestUserState]);
 
     const onDelete = React.useCallback(() => {
-      dispatchActionPromise(deleteKeyserverAccountActionTypes, deleteAction());
+      void dispatchActionPromise(
+        deleteKeyserverAccountActionTypes,
+        deleteAction(),
+      );
     }, [dispatchActionPromise, deleteAction]);
 
     return (
       <ScrollView
         contentContainerStyle={styles.scrollViewContentContainer}
         style={styles.scrollView}
       >
         <View>
           <Text style={styles.warningText}>
             Your account will be permanently deleted.
           </Text>
         </View>
         <View>
           <Text style={noWayToReverseThisStyles}>
             There is no way to reverse this.
           </Text>
         </View>
         <Button onPress={onDelete} style={styles.deleteButton}>
           {buttonContent}
         </Button>
       </ScrollView>
     );
   },
 );
 
 const unboundStyles = {
   deleteButton: {
     backgroundColor: 'vibrantRedButton',
     borderRadius: 5,
     flex: 1,
     marginHorizontal: 24,
     marginVertical: 12,
     padding: 12,
   },
   lastWarningText: {
     marginBottom: 24,
   },
   saveText: {
     color: 'white',
     fontSize: 18,
     textAlign: 'center',
   },
   scrollView: {
     backgroundColor: 'panelBackground',
   },
   scrollViewContentContainer: {
     paddingTop: 24,
   },
   warningText: {
     color: 'panelForegroundLabel',
     fontSize: 16,
     marginHorizontal: 24,
     textAlign: 'center',
   },
 };
 
 export default DeleteAccount;
diff --git a/native/profile/edit-password.react.js b/native/profile/edit-password.react.js
index 1b320f7dd..89069623c 100644
--- a/native/profile/edit-password.react.js
+++ b/native/profile/edit-password.react.js
@@ -1,371 +1,371 @@
 // @flow
 
 import { CommonActions } from '@react-navigation/native';
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   Text,
   View,
   TextInput as BaseTextInput,
   ActivityIndicator,
 } from 'react-native';
 import { ScrollView } from 'react-native-gesture-handler';
 
 import {
   changeUserPasswordActionTypes,
   changeUserPassword,
 } from 'lib/actions/user-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { PasswordUpdate } from 'lib/types/user-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import { setNativeCredentials } from '../account/native-credentials.js';
 import Button from '../components/button.react.js';
 import TextInput from '../components/text-input.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { type Colors, useColors, useStyles } from '../themes/colors.js';
 import Alert from '../utils/alert.js';
 
 const unboundStyles = {
   header: {
     color: 'panelBackgroundLabel',
     fontSize: 12,
     fontWeight: '400',
     paddingBottom: 3,
     paddingHorizontal: 24,
   },
   hr: {
     backgroundColor: 'panelForegroundBorder',
     height: 1,
     marginHorizontal: 15,
   },
   input: {
     color: 'panelForegroundLabel',
     flex: 1,
     fontFamily: 'Arial',
     fontSize: 16,
     paddingVertical: 0,
     borderBottomColor: 'transparent',
   },
   row: {
     flexDirection: 'row',
     justifyContent: 'space-between',
     paddingHorizontal: 24,
     paddingVertical: 9,
   },
   saveButton: {
     backgroundColor: 'vibrantGreenButton',
     borderRadius: 5,
     flex: 1,
     marginHorizontal: 24,
     marginVertical: 12,
     padding: 12,
   },
   saveText: {
     color: 'white',
     fontSize: 18,
     textAlign: 'center',
   },
   scrollView: {
     backgroundColor: 'panelBackground',
   },
   scrollViewContentContainer: {
     paddingTop: 24,
   },
   section: {
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     borderTopWidth: 1,
     marginBottom: 24,
     paddingVertical: 3,
   },
 };
 
 type BaseProps = {
   +navigation: ProfileNavigationProp<'EditPassword'>,
   +route: NavigationRoute<'EditPassword'>,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +loadingStatus: LoadingStatus,
   +username: ?string,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +changeUserPassword: (passwordUpdate: PasswordUpdate) => Promise<void>,
 };
 type State = {
   +currentPassword: string,
   +newPassword: string,
   +confirmPassword: string,
 };
 class EditPassword extends React.PureComponent<Props, State> {
   state: State = {
     currentPassword: '',
     newPassword: '',
     confirmPassword: '',
   };
   mounted = false;
   currentPasswordInput: ?React.ElementRef<typeof BaseTextInput>;
   newPasswordInput: ?React.ElementRef<typeof BaseTextInput>;
   confirmPasswordInput: ?React.ElementRef<typeof BaseTextInput>;
 
   componentDidMount() {
     this.mounted = true;
   }
 
   componentWillUnmount() {
     this.mounted = false;
   }
 
   render(): React.Node {
     const buttonContent =
       this.props.loadingStatus === 'loading' ? (
         <ActivityIndicator size="small" color="white" />
       ) : (
         <Text style={this.props.styles.saveText}>Save</Text>
       );
     const { panelForegroundTertiaryLabel } = this.props.colors;
     return (
       <ScrollView
         contentContainerStyle={this.props.styles.scrollViewContentContainer}
         style={this.props.styles.scrollView}
       >
         <Text style={this.props.styles.header}>CURRENT PASSWORD</Text>
         <View style={this.props.styles.section}>
           <View style={this.props.styles.row}>
             <TextInput
               style={this.props.styles.input}
               value={this.state.currentPassword}
               onChangeText={this.onChangeCurrentPassword}
               placeholder="Current password"
               placeholderTextColor={panelForegroundTertiaryLabel}
               secureTextEntry={true}
               textContentType="password"
               autoComplete="password"
               autoFocus={true}
               returnKeyType="next"
               onSubmitEditing={this.focusNewPassword}
               ref={this.currentPasswordRef}
             />
           </View>
         </View>
         <Text style={this.props.styles.header}>NEW PASSWORD</Text>
         <View style={this.props.styles.section}>
           <View style={this.props.styles.row}>
             <TextInput
               style={this.props.styles.input}
               value={this.state.newPassword}
               onChangeText={this.onChangeNewPassword}
               placeholder="New password"
               placeholderTextColor={panelForegroundTertiaryLabel}
               secureTextEntry={true}
               textContentType="newPassword"
               autoComplete="password-new"
               returnKeyType="next"
               onSubmitEditing={this.focusConfirmPassword}
               ref={this.newPasswordRef}
             />
           </View>
           <View style={this.props.styles.hr} />
           <View style={this.props.styles.row}>
             <TextInput
               style={this.props.styles.input}
               value={this.state.confirmPassword}
               onChangeText={this.onChangeConfirmPassword}
               placeholder="Confirm password"
               placeholderTextColor={panelForegroundTertiaryLabel}
               secureTextEntry={true}
               textContentType="newPassword"
               returnKeyType="go"
               onSubmitEditing={this.submitPassword}
               ref={this.confirmPasswordRef}
             />
           </View>
         </View>
         <Button
           onPress={this.submitPassword}
           style={this.props.styles.saveButton}
         >
           {buttonContent}
         </Button>
       </ScrollView>
     );
   }
 
   onChangeCurrentPassword = (currentPassword: string) => {
     this.setState({ currentPassword });
   };
 
   currentPasswordRef = (
     currentPasswordInput: ?React.ElementRef<typeof BaseTextInput>,
   ) => {
     this.currentPasswordInput = currentPasswordInput;
   };
 
   focusCurrentPassword = () => {
     invariant(this.currentPasswordInput, 'currentPasswordInput should be set');
     this.currentPasswordInput.focus();
   };
 
   onChangeNewPassword = (newPassword: string) => {
     this.setState({ newPassword });
   };
 
   newPasswordRef = (
     newPasswordInput: ?React.ElementRef<typeof BaseTextInput>,
   ) => {
     this.newPasswordInput = newPasswordInput;
   };
 
   focusNewPassword = () => {
     invariant(this.newPasswordInput, 'newPasswordInput should be set');
     this.newPasswordInput.focus();
   };
 
   onChangeConfirmPassword = (confirmPassword: string) => {
     this.setState({ confirmPassword });
   };
 
   confirmPasswordRef = (
     confirmPasswordInput: ?React.ElementRef<typeof BaseTextInput>,
   ) => {
     this.confirmPasswordInput = confirmPasswordInput;
   };
 
   focusConfirmPassword = () => {
     invariant(this.confirmPasswordInput, 'confirmPasswordInput should be set');
     this.confirmPasswordInput.focus();
   };
 
   goBackOnce() {
     this.props.navigation.dispatch(state => ({
       ...CommonActions.goBack(),
       target: state.key,
     }));
   }
 
   submitPassword = () => {
     if (this.state.newPassword === '') {
       Alert.alert(
         'Empty password',
         'New password cannot be empty',
         [{ text: 'OK', onPress: this.onNewPasswordAlertAcknowledged }],
         { cancelable: false },
       );
     } else if (this.state.newPassword !== this.state.confirmPassword) {
       Alert.alert(
         'Passwords don’t match',
         'New password fields must contain the same password',
         [{ text: 'OK', onPress: this.onNewPasswordAlertAcknowledged }],
         { cancelable: false },
       );
     } else if (this.state.newPassword === this.state.currentPassword) {
       this.goBackOnce();
     } else {
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         changeUserPasswordActionTypes,
         this.savePassword(),
       );
     }
   };
 
   async savePassword() {
     const { username } = this.props;
     if (!username) {
       return;
     }
     try {
       await this.props.changeUserPassword({
         updatedFields: {
           password: this.state.newPassword,
         },
         currentPassword: this.state.currentPassword,
       });
       await setNativeCredentials({
         username,
         password: this.state.newPassword,
       });
       this.goBackOnce();
     } catch (e) {
       if (e.message === 'invalid_credentials') {
         Alert.alert(
           'Incorrect password',
           'The current password you entered is incorrect',
           [{ text: 'OK', onPress: this.onCurrentPasswordAlertAcknowledged }],
           { cancelable: false },
         );
       } else {
         Alert.alert(
           'Unknown error',
           'Uhh... try again?',
           [{ text: 'OK', onPress: this.onUnknownErrorAlertAcknowledged }],
           { cancelable: false },
         );
       }
     }
   }
 
   onNewPasswordAlertAcknowledged = () => {
     this.setState(
       { newPassword: '', confirmPassword: '' },
       this.focusNewPassword,
     );
   };
 
   onCurrentPasswordAlertAcknowledged = () => {
     this.setState({ currentPassword: '' }, this.focusCurrentPassword);
   };
 
   onUnknownErrorAlertAcknowledged = () => {
     this.setState(
       { currentPassword: '', newPassword: '', confirmPassword: '' },
       this.focusCurrentPassword,
     );
   };
 }
 
 const loadingStatusSelector = createLoadingStatusSelector(
   changeUserPasswordActionTypes,
 );
 
 const ConnectedEditPassword: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedEditPassword(props: BaseProps) {
     const loadingStatus = useSelector(loadingStatusSelector);
     const username = useSelector(state => {
       if (state.currentUserInfo && !state.currentUserInfo.anonymous) {
         return state.currentUserInfo.username;
       }
       return undefined;
     });
     const colors = useColors();
     const styles = useStyles(unboundStyles);
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callChangeUserPassword = useServerCall(changeUserPassword);
 
     return (
       <EditPassword
         {...props}
         loadingStatus={loadingStatus}
         username={username}
         colors={colors}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         changeUserPassword={callChangeUserPassword}
       />
     );
   });
 
 export default ConnectedEditPassword;
diff --git a/native/profile/profile-screen.react.js b/native/profile/profile-screen.react.js
index f94007cb3..1132bd07c 100644
--- a/native/profile/profile-screen.react.js
+++ b/native/profile/profile-screen.react.js
@@ -1,464 +1,464 @@
 // @flow
 
 import * as React from 'react';
 import { View, Text, Platform, ScrollView } from 'react-native';
 
 import { logOutActionTypes, useLogOut } from 'lib/actions/user-actions.js';
 import { useStringForUser } from 'lib/hooks/ens-cache.js';
 import { preRequestUserStateSelector } from 'lib/selectors/account-selectors.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { accountHasPassword } from 'lib/shared/account-utils.js';
 import type { LogOutResult } from 'lib/types/account-types.js';
 import { type PreRequestUserState } from 'lib/types/session-types.js';
 import { type CurrentUserInfo } from 'lib/types/user-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import { deleteNativeCredentialsFor } from '../account/native-credentials.js';
 import EditUserAvatar from '../avatars/edit-user-avatar.react.js';
 import Action from '../components/action-row.react.js';
 import Button from '../components/button.react.js';
 import EditSettingButton from '../components/edit-setting-button.react.js';
 import SingleLine from '../components/single-line.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import {
   EditPasswordRouteName,
   DeleteAccountRouteName,
   BuildInfoRouteName,
   DevToolsRouteName,
   AppearancePreferencesRouteName,
   FriendListRouteName,
   BlockListRouteName,
   PrivacyPreferencesRouteName,
   DefaultNotificationsPreferencesRouteName,
   LinkedDevicesRouteName,
   BackupMenuRouteName,
   KeyserverSelectionListRouteName,
   TunnelbrokerMenuRouteName,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { type Colors, useColors, useStyles } from '../themes/colors.js';
 import Alert from '../utils/alert.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 type ProfileRowProps = {
   +content: string,
   +onPress: () => void,
   +danger?: boolean,
 };
 
 function ProfileRow(props: ProfileRowProps): React.Node {
   const { content, onPress, danger } = props;
   return (
     <Action.Row onPress={onPress}>
       <Action.Text danger={danger} content={content} />
       <Action.Icon name="ios-arrow-forward" />
     </Action.Row>
   );
 }
 
 const unboundStyles = {
   avatarSection: {
     alignItems: 'center',
     paddingVertical: 16,
   },
   container: {
     flex: 1,
   },
   content: {
     flex: 1,
   },
   deleteAccountButton: {
     paddingHorizontal: 24,
     paddingVertical: 12,
   },
   editPasswordButton: {
     paddingTop: Platform.OS === 'android' ? 3 : 2,
   },
   header: {
     color: 'panelBackgroundLabel',
     fontSize: 12,
     fontWeight: '400',
     paddingBottom: 3,
     paddingHorizontal: 24,
   },
   label: {
     color: 'panelForegroundTertiaryLabel',
     fontSize: 16,
     paddingRight: 12,
   },
   loggedInLabel: {
     color: 'panelForegroundTertiaryLabel',
     fontSize: 16,
   },
   logOutText: {
     color: 'link',
     fontSize: 16,
     paddingLeft: 6,
   },
   row: {
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'space-between',
   },
   scrollView: {
     backgroundColor: 'panelBackground',
   },
   scrollViewContentContainer: {
     paddingTop: 24,
   },
   paddedRow: {
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'space-between',
     paddingHorizontal: 24,
     paddingVertical: 10,
   },
   section: {
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     borderTopWidth: 1,
     marginBottom: 24,
     paddingVertical: 1,
   },
   unpaddedSection: {
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     borderTopWidth: 1,
     marginBottom: 24,
   },
   username: {
     color: 'panelForegroundLabel',
     flex: 1,
   },
   value: {
     color: 'panelForegroundLabel',
     fontSize: 16,
     textAlign: 'right',
   },
 };
 
 type BaseProps = {
   +navigation: ProfileNavigationProp<'ProfileScreen'>,
   +route: NavigationRoute<'ProfileScreen'>,
 };
 type Props = {
   ...BaseProps,
   +currentUserInfo: ?CurrentUserInfo,
   +preRequestUserState: PreRequestUserState,
   +logOutLoading: boolean,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   +dispatchActionPromise: DispatchActionPromise,
   +logOut: (preRequestUserState: PreRequestUserState) => Promise<LogOutResult>,
   +staffCanSee: boolean,
   +stringForUser: ?string,
   +isAccountWithPassword: boolean,
 };
 
 class ProfileScreen extends React.PureComponent<Props> {
   get loggedOutOrLoggingOut(): boolean {
     return (
       !this.props.currentUserInfo ||
       this.props.currentUserInfo.anonymous ||
       this.props.logOutLoading
     );
   }
 
   render(): React.Node {
     let developerTools,
       defaultNotifications,
       keyserverSelection,
       tunnelbrokerMenu;
     const { staffCanSee, isAccountWithPassword } = this.props;
     if (staffCanSee) {
       developerTools = (
         <ProfileRow content="Developer tools" onPress={this.onPressDevTools} />
       );
 
       defaultNotifications = (
         <ProfileRow
           content="Default Notifications"
           onPress={this.onPressDefaultNotifications}
         />
       );
 
       keyserverSelection = (
         <ProfileRow
           content="Keyservers"
           onPress={this.onPressKeyserverSelection}
         />
       );
 
       tunnelbrokerMenu = (
         <ProfileRow
           content="Tunnelbroker menu"
           onPress={this.onPressTunnelbrokerMenu}
         />
       );
     }
 
     let backupMenu;
     if (staffCanSee && isAccountWithPassword) {
       backupMenu = (
         <ProfileRow content="Backup menu" onPress={this.onPressBackupMenu} />
       );
     }
 
     let passwordEditionUI;
     if (accountHasPassword(this.props.currentUserInfo)) {
       passwordEditionUI = (
         <Action.Row>
           <Text style={this.props.styles.label}>Password</Text>
           <Text
             style={[this.props.styles.content, this.props.styles.value]}
             numberOfLines={1}
           >
             ••••••••••••••••
           </Text>
           <EditSettingButton
             onPress={this.onPressEditPassword}
             canChangeSettings={true}
             style={this.props.styles.editPasswordButton}
           />
         </Action.Row>
       );
     }
 
     let linkedDevices;
     if (__DEV__) {
       linkedDevices = (
         <ProfileRow content="Linked devices" onPress={this.onPressDevices} />
       );
     }
 
     return (
       <View style={this.props.styles.container}>
         <ScrollView
           contentContainerStyle={this.props.styles.scrollViewContentContainer}
           style={this.props.styles.scrollView}
         >
           <Text style={this.props.styles.header}>USER AVATAR</Text>
           <View
             style={[this.props.styles.section, this.props.styles.avatarSection]}
           >
             <EditUserAvatar userID={this.props.currentUserInfo?.id} />
           </View>
           <Text style={this.props.styles.header}>ACCOUNT</Text>
           <View style={this.props.styles.section}>
             <Action.Row>
               <Text style={this.props.styles.loggedInLabel}>Logged in as </Text>
               <SingleLine
                 style={[this.props.styles.label, this.props.styles.username]}
               >
                 {this.props.stringForUser}
               </SingleLine>
               <Button
                 onPress={this.onPressLogOut}
                 disabled={this.loggedOutOrLoggingOut}
               >
                 <Text style={this.props.styles.logOutText}>Log out</Text>
               </Button>
             </Action.Row>
             {passwordEditionUI}
           </View>
           <View style={this.props.styles.section}>
             <ProfileRow
               content="Friend list"
               onPress={this.onPressFriendList}
             />
             <ProfileRow content="Block list" onPress={this.onPressBlockList} />
           </View>
           <Text style={this.props.styles.header}>PREFERENCES</Text>
           <View style={this.props.styles.section}>
             <ProfileRow content="Appearance" onPress={this.onPressAppearance} />
             <ProfileRow content="Privacy" onPress={this.onPressPrivacy} />
             {defaultNotifications}
             {backupMenu}
             {tunnelbrokerMenu}
           </View>
           <View style={this.props.styles.section}>
             {linkedDevices}
             {keyserverSelection}
             <ProfileRow content="Build info" onPress={this.onPressBuildInfo} />
             {developerTools}
           </View>
           <View style={this.props.styles.unpaddedSection}>
             <ProfileRow
               content="Delete account..."
               danger
               onPress={this.onPressDeleteAccount}
             />
           </View>
         </ScrollView>
       </View>
     );
   }
 
   onPressLogOut = () => {
     if (this.loggedOutOrLoggingOut) {
       return;
     }
     if (!this.props.isAccountWithPassword) {
       Alert.alert(
         'Log out',
         'Are you sure you want to log out?',
         [
           { text: 'No', style: 'cancel' },
           {
             text: 'Yes',
             onPress: this.logOutWithoutDeletingNativeCredentialsWrapper,
             style: 'destructive',
           },
         ],
         { cancelable: true },
       );
       return;
     }
     const alertTitle =
       Platform.OS === 'ios' ? 'Keep Login Info in Keychain' : 'Keep Login Info';
     const alertDescription =
       'We will automatically fill out log-in forms with your credentials ' +
       'in the app.';
     Alert.alert(
       alertTitle,
       alertDescription,
       [
         { text: 'Cancel', style: 'cancel' },
         {
           text: 'Keep',
           onPress: this.logOutWithoutDeletingNativeCredentialsWrapper,
         },
         {
           text: 'Remove',
           onPress: this.logOutAndDeleteNativeCredentialsWrapper,
           style: 'destructive',
         },
       ],
       { cancelable: true },
     );
   };
 
   logOutWithoutDeletingNativeCredentialsWrapper = () => {
     if (this.loggedOutOrLoggingOut) {
       return;
     }
     this.logOut();
   };
 
   logOutAndDeleteNativeCredentialsWrapper = async () => {
     if (this.loggedOutOrLoggingOut) {
       return;
     }
     await this.deleteNativeCredentials();
     this.logOut();
   };
 
   logOut() {
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       logOutActionTypes,
       this.props.logOut(this.props.preRequestUserState),
     );
   }
 
   async deleteNativeCredentials() {
     await deleteNativeCredentialsFor();
   }
 
   onPressEditPassword = () => {
     this.props.navigation.navigate({ name: EditPasswordRouteName });
   };
 
   onPressDeleteAccount = () => {
     this.props.navigation.navigate({ name: DeleteAccountRouteName });
   };
 
   onPressDevices = () => {
     this.props.navigation.navigate({ name: LinkedDevicesRouteName });
   };
 
   onPressBuildInfo = () => {
     this.props.navigation.navigate({ name: BuildInfoRouteName });
   };
 
   onPressDevTools = () => {
     this.props.navigation.navigate({ name: DevToolsRouteName });
   };
 
   onPressAppearance = () => {
     this.props.navigation.navigate({ name: AppearancePreferencesRouteName });
   };
 
   onPressPrivacy = () => {
     this.props.navigation.navigate({ name: PrivacyPreferencesRouteName });
   };
 
   onPressDefaultNotifications = () => {
     this.props.navigation.navigate({
       name: DefaultNotificationsPreferencesRouteName,
     });
   };
 
   onPressFriendList = () => {
     this.props.navigation.navigate({ name: FriendListRouteName });
   };
 
   onPressBlockList = () => {
     this.props.navigation.navigate({ name: BlockListRouteName });
   };
 
   onPressBackupMenu = () => {
     this.props.navigation.navigate({ name: BackupMenuRouteName });
   };
 
   onPressTunnelbrokerMenu = () => {
     this.props.navigation.navigate({ name: TunnelbrokerMenuRouteName });
   };
 
   onPressKeyserverSelection = () => {
     this.props.navigation.navigate({ name: KeyserverSelectionListRouteName });
   };
 }
 
 const logOutLoadingStatusSelector =
   createLoadingStatusSelector(logOutActionTypes);
 
 const ConnectedProfileScreen: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedProfileScreen(props: BaseProps) {
     const currentUserInfo = useSelector(state => state.currentUserInfo);
     const preRequestUserState = useSelector(preRequestUserStateSelector);
     const logOutLoading =
       useSelector(logOutLoadingStatusSelector) === 'loading';
     const colors = useColors();
     const styles = useStyles(unboundStyles);
     const callLogOut = useLogOut();
     const dispatchActionPromise = useDispatchActionPromise();
     const staffCanSee = useStaffCanSee();
     const stringForUser = useStringForUser(currentUserInfo);
     const isAccountWithPassword = useSelector(state =>
       accountHasPassword(state.currentUserInfo),
     );
 
     return (
       <ProfileScreen
         {...props}
         currentUserInfo={currentUserInfo}
         preRequestUserState={preRequestUserState}
         logOutLoading={logOutLoading}
         colors={colors}
         styles={styles}
         logOut={callLogOut}
         dispatchActionPromise={dispatchActionPromise}
         staffCanSee={staffCanSee}
         stringForUser={stringForUser}
         isAccountWithPassword={isAccountWithPassword}
       />
     );
   });
 
 export default ConnectedProfileScreen;
diff --git a/native/profile/relationship-list-item.react.js b/native/profile/relationship-list-item.react.js
index da3a962fd..8f9e7bb51 100644
--- a/native/profile/relationship-list-item.react.js
+++ b/native/profile/relationship-list-item.react.js
@@ -1,356 +1,356 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text, TouchableOpacity, ActivityIndicator } from 'react-native';
 
 import {
   updateRelationshipsActionTypes,
   updateRelationships,
 } from 'lib/actions/relationship-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { ReactRef } from 'lib/types/react-types.js';
 import {
   type RelationshipRequest,
   type RelationshipAction,
   type RelationshipErrors,
   userRelationshipStatus,
   relationshipActions,
 } from 'lib/types/relationship-types.js';
 import type {
   AccountUserInfo,
   GlobalAccountUserInfo,
 } from 'lib/types/user-types.js';
 import {
   type DispatchActionPromise,
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import type { RelationshipListNavigate } from './relationship-list.react.js';
 import UserAvatar from '../avatars/user-avatar.react.js';
 import PencilIcon from '../components/pencil-icon.react.js';
 import SingleLine from '../components/single-line.react.js';
 import {
   type KeyboardState,
   KeyboardContext,
 } from '../keyboard/keyboard-state.js';
 import {
   OverlayContext,
   type OverlayContextType,
 } from '../navigation/overlay-context.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import {
   UserRelationshipTooltipModalRouteName,
   FriendListRouteName,
   BlockListRouteName,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { type Colors, useColors, useStyles } from '../themes/colors.js';
 import type { VerticalBounds } from '../types/layout-types.js';
 import { useNavigateToUserProfileBottomSheet } from '../user-profile/user-profile-utils.js';
 import Alert from '../utils/alert.js';
 
 const unboundStyles = {
   container: {
     flex: 1,
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 10,
     backgroundColor: 'panelForeground',
     borderColor: 'panelForegroundBorder',
   },
   borderBottom: {
     borderBottomWidth: 1,
   },
   buttonContainer: {
     flexDirection: 'row',
   },
   editButtonWithMargin: {
     marginLeft: 15,
   },
   username: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontSize: 16,
     lineHeight: 20,
     marginLeft: 8,
   },
   editButton: {
     paddingLeft: 10,
   },
   blueAction: {
     color: 'link',
     fontSize: 16,
     paddingLeft: 6,
   },
   redAction: {
     color: 'redText',
     fontSize: 16,
     paddingLeft: 6,
   },
 };
 
 type BaseProps = {
   +userInfo: AccountUserInfo,
   +lastListItem: boolean,
   +verticalBounds: ?VerticalBounds,
   +relationshipListRoute: NavigationRoute<'FriendList' | 'BlockList'>,
   +navigate: RelationshipListNavigate,
   +onSelect: (selectedUser: GlobalAccountUserInfo) => void,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +removeUserLoadingStatus: LoadingStatus,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +updateRelationships: (
     request: RelationshipRequest,
   ) => Promise<RelationshipErrors>,
   // withOverlayContext
   +overlayContext: ?OverlayContextType,
   // withKeyboardState
   +keyboardState: ?KeyboardState,
   +navigateToUserProfileBottomSheet: (userID: string) => mixed,
 };
 class RelationshipListItem extends React.PureComponent<Props> {
   editButton: ReactRef<React.ElementRef<typeof View>> = React.createRef();
 
   render(): React.Node {
     const {
       lastListItem,
       removeUserLoadingStatus,
       userInfo,
       relationshipListRoute,
     } = this.props;
     const relationshipsToEdit = {
       [FriendListRouteName]: [userRelationshipStatus.FRIEND],
       [BlockListRouteName]: [
         userRelationshipStatus.BOTH_BLOCKED,
         userRelationshipStatus.BLOCKED_BY_VIEWER,
       ],
     }[relationshipListRoute.name];
 
     const canEditFriendRequest = {
       [FriendListRouteName]: true,
       [BlockListRouteName]: false,
     }[relationshipListRoute.name];
 
     const borderBottom = lastListItem ? null : this.props.styles.borderBottom;
 
     let editButton = null;
     if (removeUserLoadingStatus === 'loading') {
       editButton = (
         <ActivityIndicator
           size="small"
           color={this.props.colors.panelForegroundSecondaryLabel}
         />
       );
     } else if (relationshipsToEdit.includes(userInfo.relationshipStatus)) {
       editButton = (
         <TouchableOpacity
           onPress={this.onPressEdit}
           style={this.props.styles.editButton}
         >
           <View onLayout={this.onLayout} ref={this.editButton}>
             <PencilIcon />
           </View>
         </TouchableOpacity>
       );
     } else if (
       userInfo.relationshipStatus === userRelationshipStatus.REQUEST_RECEIVED &&
       canEditFriendRequest
     ) {
       editButton = (
         <View style={this.props.styles.buttonContainer}>
           <TouchableOpacity
             onPress={this.onPressFriendUser}
             style={this.props.styles.editButton}
           >
             <Text style={this.props.styles.blueAction}>Accept</Text>
           </TouchableOpacity>
           <TouchableOpacity
             onPress={this.onPressUnfriendUser}
             style={[
               this.props.styles.editButton,
               this.props.styles.editButtonWithMargin,
             ]}
           >
             <Text style={this.props.styles.redAction}>Reject</Text>
           </TouchableOpacity>
         </View>
       );
     } else if (
       userInfo.relationshipStatus === userRelationshipStatus.REQUEST_SENT &&
       canEditFriendRequest
     ) {
       editButton = (
         <TouchableOpacity
           onPress={this.onPressUnfriendUser}
           style={this.props.styles.editButton}
         >
           <Text style={this.props.styles.redAction}>Cancel request</Text>
         </TouchableOpacity>
       );
     } else {
       editButton = (
         <TouchableOpacity
           onPress={this.onSelect}
           style={this.props.styles.editButton}
         >
           <Text style={this.props.styles.blueAction}>Add</Text>
         </TouchableOpacity>
       );
     }
 
     return (
       <TouchableOpacity
         onPress={this.onPressUser}
         style={[this.props.styles.container, borderBottom]}
       >
         <UserAvatar size="S" userID={this.props.userInfo.id} />
         <SingleLine style={this.props.styles.username}>
           {this.props.userInfo.username}
         </SingleLine>
         {editButton}
       </TouchableOpacity>
     );
   }
 
   onPressUser = () => {
     this.props.navigateToUserProfileBottomSheet(this.props.userInfo.id);
   };
 
   onSelect = () => {
     const { id, username } = this.props.userInfo;
     this.props.onSelect({ id, username });
   };
 
   visibleEntryIDs(): [string] {
     const { relationshipListRoute } = this.props;
     const id = {
       [FriendListRouteName]: 'unfriend',
       [BlockListRouteName]: 'unblock',
     }[relationshipListRoute.name];
     return [id];
   }
 
   onPressEdit = () => {
     if (this.props.keyboardState?.dismissKeyboardIfShowing()) {
       return;
     }
 
     const {
       editButton,
       props: { verticalBounds },
     } = this;
     const { overlayContext, userInfo } = this.props;
     invariant(
       overlayContext,
       'RelationshipListItem should have OverlayContext',
     );
     overlayContext.setScrollBlockingModalStatus('open');
 
     if (!editButton.current || !verticalBounds) {
       return;
     }
     const { relationshipStatus, ...restUserInfo } = userInfo;
     const relativeUserInfo = {
       ...restUserInfo,
       isViewer: false,
     };
     editButton.current.measure((x, y, width, height, pageX, pageY) => {
       const coordinates = { x: pageX, y: pageY, width, height };
       this.props.navigate<'UserRelationshipTooltipModal'>({
         name: UserRelationshipTooltipModalRouteName,
         params: {
           presentedFrom: this.props.relationshipListRoute.key,
           initialCoordinates: coordinates,
           verticalBounds,
           visibleEntryIDs: this.visibleEntryIDs(),
           relativeUserInfo,
           tooltipButtonIcon: 'pencil',
         },
       });
     });
   };
 
   // We need to set onLayout in order to allow .measure() to be on the ref
   onLayout = () => {};
 
   onPressFriendUser = () => {
     this.onPressUpdateFriendship(relationshipActions.FRIEND);
   };
 
   onPressUnfriendUser = () => {
     this.onPressUpdateFriendship(relationshipActions.UNFRIEND);
   };
 
   onPressUpdateFriendship(action: RelationshipAction) {
     const { id } = this.props.userInfo;
     const customKeyName = `${updateRelationshipsActionTypes.started}:${id}`;
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       updateRelationshipsActionTypes,
       this.updateFriendship(action),
       { customKeyName },
     );
   }
 
   async updateFriendship(
     action: RelationshipAction,
   ): Promise<RelationshipErrors> {
     try {
       return await this.props.updateRelationships({
         action,
         userIDs: [this.props.userInfo.id],
       });
     } catch (e) {
       Alert.alert('Unknown error', 'Uhh... try again?', [{ text: 'OK' }], {
         cancelable: true,
       });
       throw e;
     }
   }
 }
 
 const ConnectedRelationshipListItem: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedRelationshipListItem(
     props: BaseProps,
   ) {
     const removeUserLoadingStatus = useSelector(state =>
       createLoadingStatusSelector(
         updateRelationshipsActionTypes,
         `${updateRelationshipsActionTypes.started}:${props.userInfo.id}`,
       )(state),
     );
     const colors = useColors();
     const styles = useStyles(unboundStyles);
     const dispatchActionPromise = useDispatchActionPromise();
     const boundUpdateRelationships = useServerCall(updateRelationships);
     const overlayContext = React.useContext(OverlayContext);
     const keyboardState = React.useContext(KeyboardContext);
 
     const navigateToUserProfileBottomSheet =
       useNavigateToUserProfileBottomSheet();
 
     return (
       <RelationshipListItem
         {...props}
         removeUserLoadingStatus={removeUserLoadingStatus}
         colors={colors}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         updateRelationships={boundUpdateRelationships}
         overlayContext={overlayContext}
         keyboardState={keyboardState}
         navigateToUserProfileBottomSheet={navigateToUserProfileBottomSheet}
       />
     );
   });
 
 export default ConnectedRelationshipListItem;
diff --git a/native/profile/relationship-list.react.js b/native/profile/relationship-list.react.js
index aba637fdd..1e77f9ac6 100644
--- a/native/profile/relationship-list.react.js
+++ b/native/profile/relationship-list.react.js
@@ -1,486 +1,486 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text, Platform } from 'react-native';
 import { FlatList } from 'react-native-gesture-handler';
 
 import {
   updateRelationshipsActionTypes,
   updateRelationships,
 } from 'lib/actions/relationship-actions.js';
 import { useENSNames } from 'lib/hooks/ens-cache.js';
 import { registerFetchKey } from 'lib/reducers/loading-reducer.js';
 import { userRelationshipsSelector } from 'lib/selectors/relationship-selectors.js';
 import { userStoreSearchIndex as userStoreSearchIndexSelector } from 'lib/selectors/user-selectors.js';
 import { useSearchUsers } from 'lib/shared/search-utils.js';
 import {
   userRelationshipStatus,
   relationshipActions,
 } from 'lib/types/relationship-types.js';
 import type {
   GlobalAccountUserInfo,
   AccountUserInfo,
 } from 'lib/types/user-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import RelationshipListItem from './relationship-list-item.react.js';
 import LinkButton from '../components/link-button.react.js';
 import { createTagInput, BaseTagInput } from '../components/tag-input.react.js';
 import { KeyboardContext } from '../keyboard/keyboard-state.js';
 import { OverlayContext } from '../navigation/overlay-context.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import {
   FriendListRouteName,
   BlockListRouteName,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles, useIndicatorStyle } from '../themes/colors.js';
 import type { VerticalBounds } from '../types/layout-types.js';
 import Alert from '../utils/alert.js';
 
 const TagInput = createTagInput<GlobalAccountUserInfo>();
 
 export type RelationshipListNavigate = $PropertyType<
   ProfileNavigationProp<'FriendList' | 'BlockList'>,
   'navigate',
 >;
 
 const tagInputProps = {
   placeholder: 'username',
   autoFocus: true,
   returnKeyType: 'go',
 };
 
 type ListItem =
   | { +type: 'empty', +because: 'no-relationships' | 'no-results' }
   | { +type: 'header' }
   | { +type: 'footer' }
   | {
       +type: 'user',
       +userInfo: AccountUserInfo,
       +lastListItem: boolean,
       +verticalBounds: ?VerticalBounds,
     };
 
 // ESLint doesn't recognize that invariant always throws
 // eslint-disable-next-line consistent-return
 function keyExtractor(item: ListItem) {
   if (item.userInfo) {
     return item.userInfo.id;
   } else if (item.type === 'empty') {
     return 'empty';
   } else if (item.type === 'header') {
     return 'header';
   } else if (item.type === 'footer') {
     return 'footer';
   }
   invariant(false, 'keyExtractor conditions should be exhaustive');
 }
 
 const tagDataLabelExtractor = (userInfo: GlobalAccountUserInfo) =>
   userInfo.username;
 
 type Props = {
   +navigation: ProfileNavigationProp<'FriendList' | 'BlockList'>,
   +route: NavigationRoute<'FriendList' | 'BlockList'>,
 };
 function RelationshipList(props: Props): React.Node {
   const userInfos = useSelector(state => state.userStore.userInfos);
 
   const [searchInputText, setSearchInputText] = React.useState<string>('');
   const [userStoreSearchResults, setUserStoreSearchResults] = React.useState<
     $ReadOnlySet<string>,
   >(new Set());
 
   const { route } = props;
   const routeName = route.name;
   const excludeStatuses = React.useMemo(
     () =>
       ({
         [FriendListRouteName]: [
           userRelationshipStatus.BLOCKED_VIEWER,
           userRelationshipStatus.BOTH_BLOCKED,
         ],
         [BlockListRouteName]: [],
       }[routeName]),
     [routeName],
   );
 
   const serverSearchResults = useSearchUsers(searchInputText);
   const filteredServerSearchResults = React.useMemo(
     () =>
       serverSearchResults.filter(searchUserInfo => {
         const userInfo = userInfos[searchUserInfo.id];
         return (
           !userInfo || !excludeStatuses.includes(userInfo.relationshipStatus)
         );
       }),
     [serverSearchResults, userInfos, excludeStatuses],
   );
 
   const userStoreSearchIndex = useSelector(userStoreSearchIndexSelector);
   const onChangeSearchText = React.useCallback(
     async (searchText: string) => {
       setSearchInputText(searchText);
 
       const results = userStoreSearchIndex
         .getSearchResults(searchText)
         .filter(userID => {
           const relationship = userInfos[userID].relationshipStatus;
           return !excludeStatuses.includes(relationship);
         });
       setUserStoreSearchResults(new Set(results));
     },
     [userStoreSearchIndex, userInfos, excludeStatuses],
   );
 
   const overlayContext = React.useContext(OverlayContext);
   invariant(overlayContext, 'RelationshipList should have OverlayContext');
   const scrollEnabled = overlayContext.scrollBlockingModalStatus === 'closed';
 
   const tagInputRef = React.useRef<?BaseTagInput<GlobalAccountUserInfo>>();
   const flatListContainerRef = React.useRef<?React.ElementRef<typeof View>>();
 
   const keyboardState = React.useContext(KeyboardContext);
   const keyboardNotShowing = !!(
     keyboardState && !keyboardState.keyboardShowing
   );
   const [verticalBounds, setVerticalBounds] =
     React.useState<?VerticalBounds>(null);
   const onFlatListContainerLayout = React.useCallback(() => {
     if (!flatListContainerRef.current) {
       return;
     }
 
     if (!keyboardNotShowing) {
       return;
     }
 
     flatListContainerRef.current.measure(
       (x, y, width, height, pageX, pageY) => {
         if (
           height === null ||
           height === undefined ||
           pageY === null ||
           pageY === undefined
         ) {
           return;
         }
         setVerticalBounds({ height, y: pageY });
       },
     );
   }, [keyboardNotShowing]);
 
   const [currentTags, setCurrentTags] = React.useState<
     $ReadOnlyArray<GlobalAccountUserInfo>,
   >([]);
 
   const onSelect = React.useCallback(
     (selectedUser: GlobalAccountUserInfo) => {
       if (currentTags.find(o => o.id === selectedUser.id)) {
         return;
       }
       setSearchInputText('');
       setCurrentTags(prevCurrentTags => prevCurrentTags.concat(selectedUser));
     },
     [currentTags],
   );
 
   const onUnknownErrorAlertAcknowledged = React.useCallback(() => {
     setCurrentTags([]);
     setSearchInputText('');
     tagInputRef.current?.focus();
   }, []);
 
   const callUpdateRelationships = useServerCall(updateRelationships);
   const updateRelationshipsOnServer = React.useCallback(async () => {
     const action = {
       [FriendListRouteName]: relationshipActions.FRIEND,
       [BlockListRouteName]: relationshipActions.BLOCK,
     }[routeName];
     const userIDs = currentTags.map(userInfo => userInfo.id);
     try {
       const result = await callUpdateRelationships({
         action,
         userIDs,
       });
       setCurrentTags([]);
       setSearchInputText('');
       return result;
     } catch (e) {
       Alert.alert(
         'Unknown error',
         'Uhh... try again?',
         [{ text: 'OK', onPress: onUnknownErrorAlertAcknowledged }],
         { cancelable: true, onDismiss: onUnknownErrorAlertAcknowledged },
       );
       throw e;
     }
   }, [
     routeName,
     currentTags,
     callUpdateRelationships,
     onUnknownErrorAlertAcknowledged,
   ]);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const noCurrentTags = currentTags.length === 0;
   const onPressAdd = React.useCallback(() => {
     if (noCurrentTags) {
       return;
     }
-    dispatchActionPromise(
+    void dispatchActionPromise(
       updateRelationshipsActionTypes,
       updateRelationshipsOnServer(),
     );
   }, [noCurrentTags, dispatchActionPromise, updateRelationshipsOnServer]);
   const inputProps = React.useMemo(
     () => ({
       ...tagInputProps,
       onSubmitEditing: onPressAdd,
     }),
     [onPressAdd],
   );
 
   const { navigation } = props;
   const { navigate } = navigation;
   const styles = useStyles(unboundStyles);
   const renderItem = React.useCallback(
     // ESLint doesn't recognize that invariant always throws
     // eslint-disable-next-line consistent-return
     ({ item }: { item: ListItem, ... }) => {
       if (item.type === 'empty') {
         const action = {
           [FriendListRouteName]: 'added',
           [BlockListRouteName]: 'blocked',
         }[routeName];
 
         const emptyMessage =
           item.because === 'no-relationships'
             ? `You haven't ${action} any users yet`
             : 'No results';
 
         return <Text style={styles.emptyText}>{emptyMessage}</Text>;
       } else if (item.type === 'header' || item.type === 'footer') {
         return <View style={styles.separator} />;
       } else if (item.type === 'user') {
         return (
           <RelationshipListItem
             userInfo={item.userInfo}
             lastListItem={item.lastListItem}
             verticalBounds={item.verticalBounds}
             navigate={navigate}
             relationshipListRoute={route}
             onSelect={onSelect}
           />
         );
       } else {
         invariant(false, `unexpected RelationshipList item type ${item.type}`);
       }
     },
     [routeName, navigate, route, onSelect, styles.emptyText, styles.separator],
   );
 
   const { setOptions } = navigation;
   const prevNoCurrentTags = React.useRef(noCurrentTags);
   React.useEffect(() => {
     let setSaveButtonDisabled;
     if (!prevNoCurrentTags.current && noCurrentTags) {
       setSaveButtonDisabled = true;
     } else if (prevNoCurrentTags.current && !noCurrentTags) {
       setSaveButtonDisabled = false;
     }
     prevNoCurrentTags.current = noCurrentTags;
     if (setSaveButtonDisabled === undefined) {
       return;
     }
     setOptions({
       // eslint-disable-next-line react/display-name
       headerRight: () => (
         <LinkButton
           text="Save"
           onPress={onPressAdd}
           disabled={setSaveButtonDisabled}
         />
       ),
     });
   }, [setOptions, noCurrentTags, onPressAdd]);
 
   const relationships = useSelector(userRelationshipsSelector);
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const usersWithoutENSNames = React.useMemo(() => {
     if (searchInputText === '') {
       return {
         [FriendListRouteName]: relationships.friends,
         [BlockListRouteName]: relationships.blocked,
       }[routeName];
     }
 
     const mergedUserInfos: { [id: string]: AccountUserInfo } = {};
     for (const userInfo of filteredServerSearchResults) {
       mergedUserInfos[userInfo.id] = userInfo;
     }
     for (const id of userStoreSearchResults) {
       const { username, relationshipStatus } = userInfos[id];
       if (username) {
         mergedUserInfos[id] = { id, username, relationshipStatus };
       }
     }
 
     const excludeUserIDsArray = currentTags
       .map(userInfo => userInfo.id)
       .concat(viewerID || []);
     const excludeUserIDs = new Set(excludeUserIDsArray);
 
     const sortToEnd = [];
     const userSearchResults = [];
     const sortRelationshipTypesToEnd = {
       [FriendListRouteName]: [userRelationshipStatus.FRIEND],
       [BlockListRouteName]: [
         userRelationshipStatus.BLOCKED_BY_VIEWER,
         userRelationshipStatus.BOTH_BLOCKED,
       ],
     }[routeName];
     for (const userID in mergedUserInfos) {
       if (excludeUserIDs.has(userID)) {
         continue;
       }
 
       const userInfo = mergedUserInfos[userID];
       if (sortRelationshipTypesToEnd.includes(userInfo.relationshipStatus)) {
         sortToEnd.push(userInfo);
       } else {
         userSearchResults.push(userInfo);
       }
     }
 
     return userSearchResults.concat(sortToEnd);
   }, [
     searchInputText,
     relationships,
     routeName,
     viewerID,
     currentTags,
     filteredServerSearchResults,
     userStoreSearchResults,
     userInfos,
   ]);
 
   const displayUsers = useENSNames(usersWithoutENSNames);
   const listData = React.useMemo(() => {
     let emptyItem;
     if (displayUsers.length === 0 && searchInputText === '') {
       emptyItem = { type: 'empty', because: 'no-relationships' };
     } else if (displayUsers.length === 0) {
       emptyItem = { type: 'empty', because: 'no-results' };
     }
 
     const mappedUsers = displayUsers.map((userInfo, index) => ({
       type: 'user',
       userInfo,
       lastListItem: displayUsers.length - 1 === index,
       verticalBounds,
     }));
 
     return []
       .concat(emptyItem ? emptyItem : [])
       .concat(emptyItem ? [] : { type: 'header' })
       .concat(mappedUsers)
       .concat(emptyItem ? [] : { type: 'footer' });
   }, [displayUsers, verticalBounds, searchInputText]);
 
   const indicatorStyle = useIndicatorStyle();
   const currentTagsWithENSNames = useENSNames(currentTags);
   return (
     <View style={styles.container}>
       <View style={styles.tagInputContainer}>
         <Text style={styles.tagInputLabel}>Search:</Text>
         <View style={styles.tagInput}>
           <TagInput
             value={currentTagsWithENSNames}
             onChange={setCurrentTags}
             text={searchInputText}
             onChangeText={onChangeSearchText}
             labelExtractor={tagDataLabelExtractor}
             ref={tagInputRef}
             inputProps={inputProps}
             maxHeight={36}
           />
         </View>
       </View>
       <View
         ref={flatListContainerRef}
         onLayout={onFlatListContainerLayout}
         style={styles.container}
       >
         <FlatList
           contentContainerStyle={styles.contentContainer}
           data={listData}
           renderItem={renderItem}
           keyExtractor={keyExtractor}
           scrollEnabled={scrollEnabled}
           indicatorStyle={indicatorStyle}
           keyboardShouldPersistTaps="handled"
         />
       </View>
     </View>
   );
 }
 
 const unboundStyles = {
   container: {
     flex: 1,
     backgroundColor: 'panelBackground',
   },
   contentContainer: {
     paddingTop: 12,
     paddingBottom: 24,
   },
   separator: {
     backgroundColor: 'panelForegroundBorder',
     height: Platform.OS === 'android' ? 1.5 : 1,
   },
   emptyText: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontSize: 16,
     lineHeight: 20,
     textAlign: 'center',
     paddingHorizontal: 12,
     paddingVertical: 10,
     marginHorizontal: 12,
   },
   tagInput: {
     flex: 1,
     marginLeft: 8,
     paddingRight: 12,
   },
   tagInputLabel: {
     color: 'panelForegroundTertiaryLabel',
     fontSize: 16,
     paddingLeft: 12,
   },
   tagInputContainer: {
     alignItems: 'center',
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     flexDirection: 'row',
     paddingVertical: 6,
   },
 };
 
 registerFetchKey(updateRelationshipsActionTypes);
 
 const MemoizedRelationshipList: React.ComponentType<Props> =
   React.memo<Props>(RelationshipList);
 MemoizedRelationshipList.displayName = 'RelationshipList';
 
 export default MemoizedRelationshipList;
diff --git a/native/profile/secondary-device-qr-code-scanner.react.js b/native/profile/secondary-device-qr-code-scanner.react.js
index 43d25bba7..0fae56caa 100644
--- a/native/profile/secondary-device-qr-code-scanner.react.js
+++ b/native/profile/secondary-device-qr-code-scanner.react.js
@@ -1,132 +1,132 @@
 // @flow
 
 import { useNavigation } from '@react-navigation/native';
 import { BarCodeScanner, type BarCodeEvent } from 'expo-barcode-scanner';
 import * as React from 'react';
 import { View } from 'react-native';
 
 import { parseDataFromDeepLink } from 'lib/facts/links.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useStyles } from '../themes/colors.js';
 import Alert from '../utils/alert.js';
 
 const barCodeTypes = [BarCodeScanner.Constants.BarCodeType.qr];
 
 type Props = {
   +navigation: ProfileNavigationProp<'SecondaryDeviceQRCodeScanner'>,
   +route: NavigationRoute<'SecondaryDeviceQRCodeScanner'>,
 };
 // eslint-disable-next-line no-unused-vars
 function SecondaryDeviceQRCodeScanner(props: Props): React.Node {
   const [hasPermission, setHasPermission] = React.useState<?boolean>(null);
   const [scanned, setScanned] = React.useState(false);
 
   const styles = useStyles(unboundStyles);
   const navigation = useNavigation();
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       const { status } = await BarCodeScanner.requestPermissionsAsync();
       setHasPermission(status === 'granted');
 
       if (status !== 'granted') {
         Alert.alert(
           'No access to camera',
           'Please allow Comm to access your camera in order to scan the QR code.',
           [{ text: 'OK' }],
         );
 
         navigation.goBack();
       }
     })();
   }, [navigation]);
 
   const onConnect = React.useCallback((barCodeEvent: BarCodeEvent) => {
     const { data } = barCodeEvent;
     const parsedData = parseDataFromDeepLink(data);
     const keysMatch = parsedData?.data?.keys;
 
     if (!parsedData || !keysMatch) {
       Alert.alert(
         'Scan failed',
         'QR code does not contain a valid pair of keys.',
         [{ text: 'OK' }],
       );
       return;
     }
 
     const keys = JSON.parse(decodeURIComponent(keysMatch));
 
     Alert.alert(
       'Scan successful',
       `QR code contains the following keys: ${JSON.stringify(keys)}`,
       [{ text: 'OK' }],
     );
   }, []);
 
   const onCancelScan = React.useCallback(() => setScanned(false), []);
 
   const handleBarCodeScanned = React.useCallback(
     (barCodeEvent: BarCodeEvent) => {
       setScanned(true);
       Alert.alert(
         'Connect with this device?',
         'Are you sure you want to allow this device to log in to your account?',
         [
           {
             text: 'Cancel',
             style: 'cancel',
             onPress: onCancelScan,
           },
           {
             text: 'Connect',
             onPress: () => onConnect(barCodeEvent),
           },
         ],
         { cancelable: false },
       );
     },
     [onCancelScan, onConnect],
   );
 
   if (hasPermission === null) {
     return <View />;
   }
 
   // Note: According to the BarCodeScanner Expo docs, we should adhere to two
   // guidances when using the BarCodeScanner:
   // 1. We should specify the potential barCodeTypes we want to scan for to
   //    minimize battery usage.
   // 2. We should set the onBarCodeScanned callback to undefined if it scanned
   //    in order to 'pause' the scanner from continuing to scan while we
   //    process the data from the scan.
   // See: https://docs.expo.io/versions/latest/sdk/bar-code-scanner
   return (
     <View style={styles.container}>
       <BarCodeScanner
         onBarCodeScanned={scanned ? undefined : handleBarCodeScanned}
         barCodeTypes={barCodeTypes}
         style={styles.scanner}
       />
     </View>
   );
 }
 
 const unboundStyles = {
   container: {
     flex: 1,
     flexDirection: 'column',
     justifyContent: 'center',
   },
   scanner: {
     position: 'absolute',
     top: 0,
     left: 0,
     right: 0,
     bottom: 0,
   },
 };
 
 export default SecondaryDeviceQRCodeScanner;
diff --git a/native/profile/user-relationship-tooltip-modal.react.js b/native/profile/user-relationship-tooltip-modal.react.js
index 3a2870c2f..eddb48be5 100644
--- a/native/profile/user-relationship-tooltip-modal.react.js
+++ b/native/profile/user-relationship-tooltip-modal.react.js
@@ -1,167 +1,167 @@
 // @flow
 
 import * as React from 'react';
 import { TouchableOpacity } from 'react-native';
 
 import {
   updateRelationshipsActionTypes,
   updateRelationships,
 } from 'lib/actions/relationship-actions.js';
 import { stringForUser } from 'lib/shared/user-utils.js';
 import type { RelativeUserInfo } from 'lib/types/user-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 
 import PencilIcon from '../components/pencil-icon.react.js';
 import SWMansionIcon from '../components/swmansion-icon.react.js';
 import { useColors } from '../themes/colors.js';
 import {
   createTooltip,
   type TooltipParams,
   type BaseTooltipProps,
   type TooltipMenuProps,
   type TooltipRoute,
 } from '../tooltip/tooltip.react.js';
 import type { UserProfileBottomSheetNavigationProp } from '../user-profile/user-profile-bottom-sheet-navigator.react.js';
 import Alert from '../utils/alert.js';
 
 type Action = 'unfriend' | 'block' | 'unblock';
 type TooltipButtonIcon = 'pencil' | 'menu';
 
 export type UserRelationshipTooltipModalParams = TooltipParams<{
   +tooltipButtonIcon: TooltipButtonIcon,
   +relativeUserInfo: RelativeUserInfo,
 }>;
 
 type OnRemoveUserProps = {
   ...UserRelationshipTooltipModalParams,
   +action: Action,
 };
 function useRelationshipAction(input: OnRemoveUserProps) {
   const boundRemoveRelationships = useServerCall(updateRelationships);
   const dispatchActionPromise = useDispatchActionPromise();
   const userText = stringForUser(input.relativeUserInfo);
 
   return React.useCallback(() => {
     const callRemoveRelationships = async () => {
       try {
         return await boundRemoveRelationships({
           action: input.action,
           userIDs: [input.relativeUserInfo.id],
         });
       } catch (e) {
         Alert.alert('Unknown error', 'Uhh... try again?', [{ text: 'OK' }], {
           cancelable: true,
         });
         throw e;
       }
     };
     const onConfirmRemoveUser = () => {
       const customKeyName = `${updateRelationshipsActionTypes.started}:${input.relativeUserInfo.id}`;
-      dispatchActionPromise(
+      void dispatchActionPromise(
         updateRelationshipsActionTypes,
         callRemoveRelationships(),
         { customKeyName },
       );
     };
     const action = {
       unfriend: 'removal',
       block: 'block',
       unblock: 'unblock',
     }[input.action];
     const message = {
       unfriend: `remove ${userText} from friends?`,
       block: `block ${userText}`,
       unblock: `unblock ${userText}?`,
     }[input.action];
     Alert.alert(
       `Confirm ${action}`,
       `Are you sure you want to ${message}`,
       [
         { text: 'Cancel', style: 'cancel' },
         { text: 'OK', onPress: onConfirmRemoveUser },
       ],
       { cancelable: true },
     );
   }, [boundRemoveRelationships, dispatchActionPromise, userText, input]);
 }
 
 function TooltipMenu(
   props: TooltipMenuProps<'UserRelationshipTooltipModal'>,
 ): React.Node {
   const { route, tooltipItem: TooltipItem } = props;
 
   const onRemoveUser = useRelationshipAction({
     ...route.params,
     action: 'unfriend',
   });
 
   const onBlockUser = useRelationshipAction({
     ...route.params,
     action: 'block',
   });
 
   const onUnblockUser = useRelationshipAction({
     ...route.params,
     action: 'unblock',
   });
 
   return (
     <>
       <TooltipItem
         id="unfriend"
         text="Unfriend"
         onPress={onRemoveUser}
         key="unfriend"
       />
       <TooltipItem id="block" text="Block" onPress={onBlockUser} key="block" />
       <TooltipItem
         id="unblock"
         text="Unblock"
         onPress={onUnblockUser}
         key="unblock"
       />
     </>
   );
 }
 
 type Props = {
   +navigation: UserProfileBottomSheetNavigationProp<'UserRelationshipTooltipModal'>,
   +route: TooltipRoute<'UserRelationshipTooltipModal'>,
   ...
 };
 
 function UserRelationshipTooltipButton(props: Props): React.Node {
   const { navigation, route } = props;
 
   const { goBackOnce } = navigation;
   const { tooltipButtonIcon } = route.params;
 
   const colors = useColors();
 
   const icon = React.useMemo(() => {
     if (tooltipButtonIcon === 'pencil') {
       return <PencilIcon />;
     }
     return (
       <SWMansionIcon
         name="menu-vertical"
         size={24}
         color={colors.modalBackgroundLabel}
       />
     );
   }, [colors.modalBackgroundLabel, tooltipButtonIcon]);
 
   return <TouchableOpacity onPress={goBackOnce}>{icon}</TouchableOpacity>;
 }
 
 const UserRelationshipTooltipModal: React.ComponentType<
   BaseTooltipProps<'UserRelationshipTooltipModal'>,
 > = createTooltip<'UserRelationshipTooltipModal'>(
   UserRelationshipTooltipButton,
   TooltipMenu,
 );
 
 export default UserRelationshipTooltipModal;
diff --git a/native/push/push-handler.react.js b/native/push/push-handler.react.js
index fd70ba528..7e85bac1d 100644
--- a/native/push/push-handler.react.js
+++ b/native/push/push-handler.react.js
@@ -1,741 +1,741 @@
 // @flow
 
 import * as Haptics from 'expo-haptics';
 import invariant from 'invariant';
 import * as React from 'react';
 import { Platform, LogBox } from 'react-native';
 import { Notification as InAppNotification } from 'react-native-in-app-message';
 
 import type {
   DeviceTokens,
   SetDeviceTokenActionPayload,
 } from 'lib/actions/device-actions.js';
 import {
   setDeviceTokenActionTypes,
   useSetDeviceToken,
   useSetDeviceTokenFanout,
 } from 'lib/actions/device-actions.js';
 import { saveMessagesActionType } from 'lib/actions/message-actions.js';
 import {
   updatesCurrentAsOfSelector,
   connectionSelector,
   deviceTokensSelector,
 } from 'lib/selectors/keyserver-selectors.js';
 import {
   unreadCount,
   threadInfoSelector,
 } from 'lib/selectors/thread-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { mergePrefixIntoBody } from 'lib/shared/notif-utils.js';
 import type { RawMessageInfo } from 'lib/types/message-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { type ConnectionInfo } from 'lib/types/socket-types.js';
 import type { GlobalTheme } from 'lib/types/theme-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import {
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import {
   convertNotificationMessageInfoToNewIDSchema,
   convertNonPendingIDToNewSchema,
 } from 'lib/utils/migration-utils.js';
 import {
   type NotifPermissionAlertInfo,
   recordNotifPermissionAlertActionType,
   shouldSkipPushPermissionAlert,
 } from 'lib/utils/push-alerts.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import sleep from 'lib/utils/sleep.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   parseAndroidMessage,
   androidNotificationChannelID,
   handleAndroidMessage,
   getCommAndroidNotificationsEventEmitter,
   type AndroidMessage,
   CommAndroidNotifications,
 } from './android.js';
 import {
   CommIOSNotification,
   type CoreIOSNotificationData,
   type CoreIOSNotificationDataWithRequestIdentifier,
 } from './comm-ios-notification.js';
 import InAppNotif from './in-app-notif.react.js';
 import {
   requestIOSPushPermissions,
   iosPushPermissionResponseReceived,
   CommIOSNotifications,
   getCommIOSNotificationsEventEmitter,
   type CoreIOSNotificationBackgroundData,
 } from './ios.js';
 import {
   type MessageListParams,
   useNavigateToThread,
 } from '../chat/message-list-types.js';
 import {
   addLifecycleListener,
   getCurrentLifecycleState,
 } from '../lifecycle/lifecycle.js';
 import { replaceWithThreadActionType } from '../navigation/action-types.js';
 import { activeMessageListSelector } from '../navigation/nav-selectors.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import type { RootNavigationProp } from '../navigation/root-navigator.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { RootContext, type RootContextType } from '../root-context.js';
 import type { EventSubscription } from '../types/react-native.js';
 import Alert from '../utils/alert.js';
 
 LogBox.ignoreLogs([
   // react-native-in-app-message
   'ForceTouchGestureHandler is not available',
 ]);
 
 type BaseProps = {
   +navigation: RootNavigationProp<'App'>,
 };
 type Props = {
   ...BaseProps,
   // Navigation state
   +activeThread: ?string,
   // Redux state
   +unreadCount: number,
   +deviceTokens: {
     +[keyserverID: string]: ?string,
   },
   +threadInfos: { +[id: string]: ThreadInfo },
   +notifPermissionAlertInfo: NotifPermissionAlertInfo,
   +connection: ConnectionInfo,
   +updatesCurrentAsOf: number,
   +activeTheme: ?GlobalTheme,
   +loggedIn: boolean,
   +navigateToThread: (params: MessageListParams) => void,
   // Redux dispatch functions
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +setDeviceToken: (
     input: DeviceTokens,
   ) => Promise<SetDeviceTokenActionPayload>,
   +setDeviceTokenFanout: (
     deviceToken: ?string,
   ) => Promise<SetDeviceTokenActionPayload>,
   // withRootContext
   +rootContext: ?RootContextType,
 };
 type State = {
   +inAppNotifProps: ?{
     +customComponent: React.Node,
     +blurType: ?('xlight' | 'dark'),
     +onPress: () => void,
   },
 };
 
 class PushHandler extends React.PureComponent<Props, State> {
   state: State = {
     inAppNotifProps: null,
   };
   currentState: ?string = getCurrentLifecycleState();
   appStarted = 0;
   androidNotificationsEventSubscriptions: Array<EventSubscription> = [];
   androidNotificationsPermissionPromise: ?Promise<boolean> = undefined;
   initialAndroidNotifHandled = false;
   openThreadOnceReceived: Set<string> = new Set();
   lifecycleSubscription: ?EventSubscription;
   iosNotificationEventSubscriptions: Array<EventSubscription> = [];
 
   componentDidMount() {
     this.appStarted = Date.now();
     this.lifecycleSubscription = addLifecycleListener(
       this.handleAppStateChange,
     );
     this.onForeground();
     if (Platform.OS === 'ios') {
       const commIOSNotificationsEventEmitter =
         getCommIOSNotificationsEventEmitter();
       this.iosNotificationEventSubscriptions.push(
         commIOSNotificationsEventEmitter.addListener(
           CommIOSNotifications.getConstants()
             .REMOTE_NOTIFICATIONS_REGISTERED_EVENT,
           registration =>
             this.registerPushPermissions(registration?.deviceToken),
         ),
         commIOSNotificationsEventEmitter.addListener(
           CommIOSNotifications.getConstants()
             .REMOTE_NOTIFICATIONS_REGISTRATION_FAILED_EVENT,
           this.failedToRegisterPushPermissionsIOS,
         ),
         commIOSNotificationsEventEmitter.addListener(
           CommIOSNotifications.getConstants()
             .NOTIFICATION_RECEIVED_FOREGROUND_EVENT,
           this.iosForegroundNotificationReceived,
         ),
         commIOSNotificationsEventEmitter.addListener(
           CommIOSNotifications.getConstants().NOTIFICATION_OPENED_EVENT,
           this.iosNotificationOpened,
         ),
         commIOSNotificationsEventEmitter.addListener(
           CommIOSNotifications.getConstants()
             .NOTIFICATION_RECEIVED_BACKGROUND_EVENT,
           this.iosBackgroundNotificationReceived,
         ),
       );
     } else if (Platform.OS === 'android') {
       CommAndroidNotifications.createChannel(
         androidNotificationChannelID,
         'Default',
         CommAndroidNotifications.getConstants().NOTIFICATIONS_IMPORTANCE_HIGH,
         'Comm notifications channel',
       );
       const commAndroidNotificationsEventEmitter =
         getCommAndroidNotificationsEventEmitter();
       this.androidNotificationsEventSubscriptions.push(
         commAndroidNotificationsEventEmitter.addListener(
           CommAndroidNotifications.getConstants()
             .COMM_ANDROID_NOTIFICATIONS_TOKEN,
           this.handleAndroidDeviceToken,
         ),
         commAndroidNotificationsEventEmitter.addListener(
           CommAndroidNotifications.getConstants()
             .COMM_ANDROID_NOTIFICATIONS_MESSAGE,
           this.androidMessageReceived,
         ),
         commAndroidNotificationsEventEmitter.addListener(
           CommAndroidNotifications.getConstants()
             .COMM_ANDROID_NOTIFICATIONS_NOTIFICATION_OPENED,
           this.androidNotificationOpened,
         ),
       );
     }
 
     if (this.props.connection.status === 'connected') {
       this.updateBadgeCount();
     }
   }
 
   componentWillUnmount() {
     if (this.lifecycleSubscription) {
       this.lifecycleSubscription.remove();
     }
     if (Platform.OS === 'ios') {
       for (const iosNotificationEventSubscription of this
         .iosNotificationEventSubscriptions) {
         iosNotificationEventSubscription.remove();
       }
     } else if (Platform.OS === 'android') {
       for (const androidNotificationsEventSubscription of this
         .androidNotificationsEventSubscriptions) {
         androidNotificationsEventSubscription.remove();
       }
       this.androidNotificationsEventSubscriptions = [];
     }
   }
 
   handleAppStateChange = (nextState: ?string) => {
     if (!nextState || nextState === 'unknown') {
       return;
     }
     const lastState = this.currentState;
     this.currentState = nextState;
     if (lastState === 'background' && nextState === 'active') {
       this.onForeground();
       this.clearNotifsOfThread();
     }
   };
 
   onForeground() {
     if (this.props.loggedIn) {
-      this.ensurePushNotifsEnabled();
+      void this.ensurePushNotifsEnabled();
     } else {
       // We do this in case there was a crash, so we can clear deviceToken from
       // any other cookies it might be set for
       const deviceTokensMap: { [string]: string } = {};
       for (const keyserverID in this.props.deviceTokens) {
         const deviceToken = this.props.deviceTokens[keyserverID];
         if (deviceToken) {
           deviceTokensMap[keyserverID] = deviceToken;
         }
       }
       this.setDeviceToken(deviceTokensMap);
     }
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (this.props.activeThread !== prevProps.activeThread) {
       this.clearNotifsOfThread();
     }
 
     if (
       this.props.connection.status === 'connected' &&
       (prevProps.connection.status !== 'connected' ||
         this.props.unreadCount !== prevProps.unreadCount)
     ) {
       this.updateBadgeCount();
     }
 
     for (const threadID of this.openThreadOnceReceived) {
       const threadInfo = this.props.threadInfos[threadID];
       if (threadInfo) {
         this.navigateToThread(threadInfo, false);
         this.openThreadOnceReceived.clear();
         break;
       }
     }
 
     if (this.props.loggedIn && !prevProps.loggedIn) {
-      this.ensurePushNotifsEnabled();
+      void this.ensurePushNotifsEnabled();
     } else {
       for (const keyserverID in this.props.deviceTokens) {
         const deviceToken = this.props.deviceTokens[keyserverID];
         const prevDeviceToken = prevProps.deviceTokens[keyserverID];
         if (!deviceToken && prevDeviceToken) {
-          this.ensurePushNotifsEnabled();
+          void this.ensurePushNotifsEnabled();
           break;
         }
       }
     }
 
     if (!this.props.loggedIn && prevProps.loggedIn) {
       this.clearAllNotifs();
       this.resetBadgeCount();
     }
 
     if (
       this.state.inAppNotifProps &&
       this.state.inAppNotifProps !== prevState.inAppNotifProps
     ) {
       Haptics.notificationAsync();
       InAppNotification.show();
     }
   }
 
   updateBadgeCount() {
     const curUnreadCount = this.props.unreadCount;
     if (Platform.OS === 'ios') {
       CommIOSNotifications.setBadgesCount(curUnreadCount);
     } else if (Platform.OS === 'android') {
       CommAndroidNotifications.setBadge(curUnreadCount);
     }
   }
 
   resetBadgeCount() {
     if (Platform.OS === 'ios') {
       CommIOSNotifications.setBadgesCount(0);
     } else if (Platform.OS === 'android') {
       CommAndroidNotifications.setBadge(0);
     }
   }
 
   clearAllNotifs() {
     if (Platform.OS === 'ios') {
       CommIOSNotifications.removeAllDeliveredNotifications();
     } else if (Platform.OS === 'android') {
       CommAndroidNotifications.removeAllDeliveredNotifications();
     }
   }
 
   clearNotifsOfThread() {
     const { activeThread } = this.props;
     if (!activeThread) {
       return;
     }
     if (Platform.OS === 'ios') {
       CommIOSNotifications.getDeliveredNotifications(notifications =>
         PushHandler.clearDeliveredIOSNotificationsForThread(
           activeThread,
           notifications,
         ),
       );
     } else if (Platform.OS === 'android') {
       CommAndroidNotifications.removeAllActiveNotificationsForThread(
         activeThread,
       );
     }
   }
 
   static clearDeliveredIOSNotificationsForThread(
     threadID: string,
     notifications: $ReadOnlyArray<CoreIOSNotificationDataWithRequestIdentifier>,
   ) {
     const identifiersToClear = [];
     for (const notification of notifications) {
       if (notification.threadID === threadID) {
         identifiersToClear.push(notification.identifier);
       }
     }
     if (identifiersToClear) {
       CommIOSNotifications.removeDeliveredNotifications(identifiersToClear);
     }
   }
 
   async ensurePushNotifsEnabled() {
     if (!this.props.loggedIn) {
       return;
     }
     if (Platform.OS === 'ios') {
       let missingDeviceToken = false;
       for (const keyserverID in this.props.deviceTokens) {
         const deviceToken = this.props.deviceTokens[keyserverID];
         if (deviceToken === null || deviceToken === undefined) {
           missingDeviceToken = true;
           break;
         }
       }
       await requestIOSPushPermissions(missingDeviceToken);
     } else if (Platform.OS === 'android') {
       await this.ensureAndroidPushNotifsEnabled();
     }
   }
 
   async ensureAndroidPushNotifsEnabled() {
     const permissionPromisesResult = await Promise.all([
       CommAndroidNotifications.hasPermission(),
       CommAndroidNotifications.canRequestNotificationsPermissionFromUser(),
     ]);
 
     let [hasPermission] = permissionPromisesResult;
     const [, canRequestPermission] = permissionPromisesResult;
 
     if (!hasPermission && canRequestPermission) {
       const permissionResponse = await (async () => {
         // We issue a call to sleep to match iOS behavior where prompt
         // doesn't appear immediately but after logged-out modal disappears
         await sleep(10);
         return await this.requestAndroidNotificationsPermission();
       })();
       hasPermission = permissionResponse;
     }
 
     if (!hasPermission) {
       this.failedToRegisterPushPermissionsAndroid(!canRequestPermission);
       return;
     }
 
     try {
       const fcmToken = await CommAndroidNotifications.getToken();
       await this.handleAndroidDeviceToken(fcmToken);
     } catch (e) {
       this.failedToRegisterPushPermissionsAndroid(!canRequestPermission);
     }
   }
 
   requestAndroidNotificationsPermission = (): Promise<boolean> => {
     if (!this.androidNotificationsPermissionPromise) {
       this.androidNotificationsPermissionPromise = (async () => {
         const notifPermission =
           await CommAndroidNotifications.requestNotificationsPermission();
         this.androidNotificationsPermissionPromise = undefined;
         return notifPermission;
       })();
     }
     return this.androidNotificationsPermissionPromise;
   };
 
   handleAndroidDeviceToken = async (deviceToken: string) => {
     this.registerPushPermissions(deviceToken);
     await this.handleInitialAndroidNotification();
   };
 
   async handleInitialAndroidNotification() {
     if (this.initialAndroidNotifHandled) {
       return;
     }
     this.initialAndroidNotifHandled = true;
     const initialNotifThreadID =
       await CommAndroidNotifications.getInitialNotificationThreadID();
     if (initialNotifThreadID) {
       await this.androidNotificationOpened(initialNotifThreadID);
     }
   }
 
   registerPushPermissions = (deviceToken: ?string) => {
     const deviceType = Platform.OS;
     if (deviceType !== 'android' && deviceType !== 'ios') {
       return;
     }
     if (deviceType === 'ios') {
       iosPushPermissionResponseReceived();
     }
     const deviceTokensMap: { [string]: ?string } = {};
     for (const keyserverID in this.props.deviceTokens) {
       const keyserverDeviceToken = this.props.deviceTokens[keyserverID];
       if (deviceToken !== keyserverDeviceToken) {
         deviceTokensMap[keyserverID] = deviceToken;
       }
     }
     this.setDeviceToken(deviceTokensMap);
   };
 
   setDeviceToken(deviceTokens: DeviceTokens) {
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       setDeviceTokenActionTypes,
       this.props.setDeviceToken(deviceTokens),
     );
   }
 
   setAllDeviceTokensNull = () => {
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       setDeviceTokenActionTypes,
       this.props.setDeviceTokenFanout(null),
     );
   };
 
   failedToRegisterPushPermissionsIOS = () => {
     this.setAllDeviceTokensNull();
     if (!this.props.loggedIn) {
       return;
     }
     iosPushPermissionResponseReceived();
   };
 
   failedToRegisterPushPermissionsAndroid = (
     shouldShowAlertOnAndroid: boolean,
   ) => {
     this.setAllDeviceTokensNull();
     if (!this.props.loggedIn) {
       return;
     }
     if (shouldShowAlertOnAndroid) {
       this.showNotifAlertOnAndroid();
     }
   };
 
   showNotifAlertOnAndroid() {
     const alertInfo = this.props.notifPermissionAlertInfo;
     if (shouldSkipPushPermissionAlert(alertInfo)) {
       return;
     }
     this.props.dispatch({
       type: recordNotifPermissionAlertActionType,
       payload: { time: Date.now() },
     });
 
     Alert.alert(
       'Unable to initialize notifs!',
       '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.',
       undefined,
       { cancelable: true },
     );
   }
 
   navigateToThread(threadInfo: ThreadInfo, clearChatRoutes: boolean) {
     if (clearChatRoutes) {
       this.props.navigation.dispatch({
         type: replaceWithThreadActionType,
         payload: { threadInfo },
       });
     } else {
       this.props.navigateToThread({ threadInfo });
     }
   }
 
   onPressNotificationForThread(threadID: string, clearChatRoutes: boolean) {
     const threadInfo = this.props.threadInfos[threadID];
     if (threadInfo) {
       this.navigateToThread(threadInfo, clearChatRoutes);
     } else {
       this.openThreadOnceReceived.add(threadID);
     }
   }
 
   saveMessageInfos(rawMessageInfos: ?$ReadOnlyArray<RawMessageInfo>) {
     if (!rawMessageInfos) {
       return;
     }
     const { updatesCurrentAsOf } = this.props;
     this.props.dispatch({
       type: saveMessagesActionType,
       payload: { rawMessageInfos, updatesCurrentAsOf },
     });
   }
 
   iosForegroundNotificationReceived = (
     rawNotification: CoreIOSNotificationData,
   ) => {
     const notification = new CommIOSNotification(rawNotification);
     if (Date.now() < this.appStarted + 1500) {
       // On iOS, when the app is opened from a notif press, for some reason this
       // callback gets triggered before iosNotificationOpened. In fact this
       // callback shouldn't be triggered at all. To avoid weirdness we are
       // ignoring any foreground notification received within the first second
       // of the app being started, since they are most likely to be erroneous.
       notification.finish(
         CommIOSNotifications.getConstants().FETCH_RESULT_NO_DATA,
       );
       return;
     }
     const threadID = notification.getData().threadID;
     const messageInfos = notification.getData().messageInfos;
     this.saveMessageInfos(messageInfos);
 
     let title = notification.getData().title;
     let body = notification.getData().body;
 
     if (title && body) {
       ({ title, body } = mergePrefixIntoBody({ title, body }));
     } else {
       body = notification.getMessage();
     }
 
     if (body) {
       this.showInAppNotification(threadID, body, title);
     } else {
       console.log(
         'Non-rescind foreground notification without alert received!',
       );
     }
     notification.finish(
       CommIOSNotifications.getConstants().FETCH_RESULT_NEW_DATA,
     );
   };
 
   iosBackgroundNotificationReceived = (
     backgroundData: CoreIOSNotificationBackgroundData,
   ) => {
     const convertedMessageInfos = backgroundData.messageInfosArray
       .flatMap(convertNotificationMessageInfoToNewIDSchema)
       .filter(Boolean);
 
     if (!convertedMessageInfos.length) {
       return;
     }
 
     this.saveMessageInfos(convertedMessageInfos);
   };
 
   onPushNotifBootsApp() {
     if (
       this.props.rootContext &&
       this.props.rootContext.detectUnsupervisedBackground
     ) {
       this.props.rootContext.detectUnsupervisedBackground(false);
     }
   }
 
   iosNotificationOpened = (rawNotification: CoreIOSNotificationData) => {
     const notification = new CommIOSNotification(rawNotification);
     this.onPushNotifBootsApp();
     const threadID = notification.getData().threadID;
     const messageInfos = notification.getData().messageInfos;
     this.saveMessageInfos(messageInfos);
     this.onPressNotificationForThread(threadID, true);
     notification.finish(
       CommIOSNotifications.getConstants().FETCH_RESULT_NEW_DATA,
     );
   };
 
   showInAppNotification(threadID: string, message: string, title?: ?string) {
     if (threadID === this.props.activeThread) {
       return;
     }
     this.setState({
       inAppNotifProps: {
         customComponent: (
           <InAppNotif
             title={title}
             message={message}
             activeTheme={this.props.activeTheme}
           />
         ),
         blurType: this.props.activeTheme === 'dark' ? 'xlight' : 'dark',
         onPress: () => {
           InAppNotification.hide();
           this.onPressNotificationForThread(threadID, false);
         },
       },
     });
   }
 
   androidNotificationOpened = async (threadID: string) => {
     const convertedThreadID = convertNonPendingIDToNewSchema(
       threadID,
       ashoatKeyserverID,
     );
     this.onPushNotifBootsApp();
     this.onPressNotificationForThread(convertedThreadID, true);
   };
 
   androidMessageReceived = async (message: AndroidMessage) => {
     const parsedMessage = parseAndroidMessage(message);
     this.onPushNotifBootsApp();
 
     const { messageInfos } = parsedMessage;
     this.saveMessageInfos(messageInfos);
 
     handleAndroidMessage(
       parsedMessage,
       this.props.updatesCurrentAsOf,
       this.handleAndroidNotificationIfActive,
     );
   };
 
   handleAndroidNotificationIfActive = (
     threadID: string,
     texts: { body: string, title: ?string },
   ): boolean => {
     if (this.currentState !== 'active') {
       return false;
     }
     this.showInAppNotification(threadID, texts.body, texts.title);
     return true;
   };
 
   render(): React.Node {
     return (
       <InAppNotification
         {...this.state.inAppNotifProps}
         hideStatusBar={false}
       />
     );
   }
 }
 
 const ConnectedPushHandler: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedPushHandler(props: BaseProps) {
     const navContext = React.useContext(NavContext);
     const activeThread = activeMessageListSelector(navContext);
     const boundUnreadCount = useSelector(unreadCount);
     const deviceTokens = useSelector(deviceTokensSelector);
     const threadInfos = useSelector(threadInfoSelector);
     const notifPermissionAlertInfo = useSelector(
       state => state.notifPermissionAlertInfo,
     );
     const connection = useSelector(connectionSelector(ashoatKeyserverID));
     invariant(connection, 'keyserver missing from keyserverStore');
     const updatesCurrentAsOf = useSelector(
       updatesCurrentAsOfSelector(ashoatKeyserverID),
     );
     const activeTheme = useSelector(state => state.globalThemeInfo.activeTheme);
     const loggedIn = useSelector(isLoggedIn);
     const navigateToThread = useNavigateToThread();
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const callSetDeviceToken = useSetDeviceToken();
     const callSetDeviceTokenFanout = useSetDeviceTokenFanout();
     const rootContext = React.useContext(RootContext);
     return (
       <PushHandler
         {...props}
         activeThread={activeThread}
         unreadCount={boundUnreadCount}
         deviceTokens={deviceTokens}
         threadInfos={threadInfos}
         notifPermissionAlertInfo={notifPermissionAlertInfo}
         connection={connection}
         updatesCurrentAsOf={updatesCurrentAsOf}
         activeTheme={activeTheme}
         loggedIn={loggedIn}
         navigateToThread={navigateToThread}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         setDeviceToken={callSetDeviceToken}
         setDeviceTokenFanout={callSetDeviceTokenFanout}
         rootContext={rootContext}
       />
     );
   });
 
 export default ConnectedPushHandler;
diff --git a/native/qr-code/qr-code-screen.react.js b/native/qr-code/qr-code-screen.react.js
index be198da30..59f6b20b8 100644
--- a/native/qr-code/qr-code-screen.react.js
+++ b/native/qr-code/qr-code-screen.react.js
@@ -1,111 +1,111 @@
 // @flow
 
 import * as React from 'react';
 import { View, Text } from 'react-native';
 import QRCode from 'react-native-qrcode-svg';
 
 import { qrCodeLinkURL } from 'lib/facts/links.js';
 import { uintArrayToHexString } from 'lib/media/data-utils.js';
 
 import type { QRCodeSignInNavigationProp } from './qr-code-sign-in-navigator.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useStyles } from '../themes/colors.js';
 import * as AES from '../utils/aes-crypto-module.js';
 import { getContentSigningKey } from '../utils/crypto-utils.js';
 
 type QRCodeScreenProps = {
   +navigation: QRCodeSignInNavigationProp<'QRCodeScreen'>,
   +route: NavigationRoute<'QRCodeScreen'>,
 };
 
 // eslint-disable-next-line no-unused-vars
 function QRCodeScreen(props: QRCodeScreenProps): React.Node {
   const [qrCodeValue, setQrCodeValue] = React.useState<?string>();
 
   const generateQRCode = React.useCallback(async () => {
     try {
       const rawAESKey: Uint8Array = await AES.generateKey();
       const aesKeyAsHexString: string = uintArrayToHexString(rawAESKey);
 
       const ed25519Key: string = await getContentSigningKey();
 
       const url = qrCodeLinkURL(aesKeyAsHexString, ed25519Key);
       setQrCodeValue(url);
     } catch (err) {
       console.error('Failed to generate QR Code:', err);
     }
   }, []);
 
   React.useEffect(() => {
-    generateQRCode();
+    void generateQRCode();
   }, [generateQRCode]);
 
   const styles = useStyles(unboundStyles);
   return (
     <View style={styles.container}>
       <Text style={styles.heading}>Log in to Comm</Text>
       <Text style={styles.headingSubtext}>
         Open the Comm app on your phone and scan the QR code below
       </Text>
       <QRCode value={qrCodeValue} size={200} />
       <View style={styles.instructionsBox}>
         <Text style={styles.instructionsTitle}>How to find the scanner:</Text>
         <Text style={styles.instructionsStep}>
           <Text>Go to </Text>
           <Text style={styles.instructionsBold}>Profile</Text>
         </Text>
         <Text style={styles.instructionsStep}>
           <Text>Select </Text>
           <Text style={styles.instructionsBold}>Linked devices </Text>
         </Text>
         <Text style={styles.instructionsStep}>
           <Text>Click </Text>
           <Text style={styles.instructionsBold}>Add </Text>
           <Text>on the top right</Text>
         </Text>
       </View>
     </View>
   );
 }
 
 const unboundStyles = {
   container: {
     flex: 1,
     alignItems: 'center',
     marginTop: 125,
   },
   heading: {
     fontSize: 24,
     color: 'panelForegroundLabel',
     paddingBottom: 12,
   },
   headingSubtext: {
     fontSize: 12,
     color: 'panelForegroundLabel',
     paddingBottom: 30,
   },
   instructionsBox: {
     alignItems: 'center',
     width: 300,
     marginTop: 40,
     padding: 15,
     borderColor: 'panelForegroundLabel',
     borderWidth: 2,
     borderRadius: 8,
   },
   instructionsTitle: {
     fontSize: 12,
     color: 'panelForegroundLabel',
     paddingBottom: 15,
   },
   instructionsStep: {
     fontSize: 12,
     padding: 1,
     color: 'panelForegroundLabel',
   },
   instructionsBold: {
     fontWeight: 'bold',
   },
 };
 
 export default QRCodeScreen;
diff --git a/native/redux/persist.js b/native/redux/persist.js
index 2c9da0278..fa9e607fa 100644
--- a/native/redux/persist.js
+++ b/native/redux/persist.js
@@ -1,1116 +1,1116 @@
 // @flow
 
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import invariant from 'invariant';
 import { Platform } from 'react-native';
 import Orientation from 'react-native-orientation-locker';
 import { createTransform } from 'redux-persist';
 import type { Transform } from 'redux-persist/es/types.js';
 
 import {
   convertEntryStoreToNewIDSchema,
   convertInviteLinksStoreToNewIDSchema,
   convertMessageStoreToNewIDSchema,
   convertRawMessageInfoToNewIDSchema,
   convertCalendarFilterToNewIDSchema,
   convertConnectionInfoToNewIDSchema,
 } from 'lib/_generated/migration-utils.js';
 import {
   type ClientDBMessageStoreOperation,
   messageStoreOpsHandlers,
 } from 'lib/ops/message-store-ops.js';
 import {
   type ReportStoreOperation,
   type ClientDBReportStoreOperation,
   convertReportsToReplaceReportOps,
   reportStoreOpsHandlers,
 } from 'lib/ops/report-store-ops.js';
 import type { ClientDBThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import {
   type ClientDBUserStoreOperation,
   type UserStoreOperation,
   convertUserInfosToReplaceUserOps,
   userStoreOpsHandlers,
 } from 'lib/ops/user-store-ops.js';
 import { highestLocalIDSelector } from 'lib/selectors/local-id-selectors.js';
 import { createAsyncMigrate } from 'lib/shared/create-async-migrate.js';
 import { inconsistencyResponsesToReports } from 'lib/shared/report-utils.js';
 import {
   getContainingThreadID,
   getCommunity,
 } from 'lib/shared/thread-utils.js';
 import {
   DEPRECATED_unshimMessageStore,
   unshimFunc,
 } from 'lib/shared/unshim-utils.js';
 import { defaultEnabledApps } from 'lib/types/enabled-apps.js';
 import { defaultCalendarQuery } from 'lib/types/entry-types.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.js';
 import type {
   KeyserverStore,
   KeyserverInfo,
 } from 'lib/types/keyserver-types.js';
 import {
   messageTypes,
   type MessageType,
 } from 'lib/types/message-types-enum.js';
 import {
   type LocalMessageInfo,
   type MessageStore,
   type MessageStoreThreads,
   type RawMessageInfo,
 } from 'lib/types/message-types.js';
 import type {
   ReportStore,
   ClientReportCreationRequest,
 } from 'lib/types/report-types.js';
 import {
   defaultConnectionInfo,
   type ConnectionInfo,
 } from 'lib/types/socket-types.js';
 import { defaultGlobalThemeInfo } from 'lib/types/theme-types.js';
 import type {
   ClientDBThreadInfo,
   LegacyRawThreadInfo,
 } from 'lib/types/thread-types.js';
 import {
   translateClientDBMessageInfoToRawMessageInfo,
   translateRawMessageInfoToClientDBMessageInfo,
 } from 'lib/utils/message-ops-utils.js';
 import {
   generateIDSchemaMigrationOpsForDrafts,
   convertMessageStoreThreadsToNewIDSchema,
   convertThreadStoreThreadInfosToNewIDSchema,
 } from 'lib/utils/migration-utils.js';
 import { defaultNotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import {
   convertClientDBThreadInfoToRawThreadInfo,
   convertRawThreadInfoToClientDBThreadInfo,
 } from 'lib/utils/thread-ops-utils.js';
 import { getUUID } from 'lib/utils/uuid.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   updateClientDBThreadStoreThreadInfos,
   createUpdateDBOpsForThreadStoreThreadInfos,
   createUpdateDBOpsForMessageStoreMessages,
   createUpdateDBOpsForMessageStoreThreads,
 } from './client-db-utils.js';
 import { defaultState } from './default-state.js';
 import { migrateThreadStoreForEditThreadPermissions } from './edit-thread-permission-migration.js';
 import { persistMigrationForManagePinsThreadPermission } from './manage-pins-permission-migration.js';
 import { persistMigrationToRemoveSelectRolePermissions } from './remove-select-role-permissions.js';
 import type { AppState } from './state-types.js';
 import { unshimClientDB } from './unshim-utils.js';
 import { updateRolesAndPermissions } from './update-roles-and-permissions.js';
 import { commCoreModule } from '../native-modules.js';
 import { defaultDeviceCameraInfo } from '../types/camera.js';
 import { isTaskCancelledError } from '../utils/error-handling.js';
 import { defaultURLPrefix } from '../utils/url-utils.js';
 
 const migrations = {
   [1]: (state: AppState) => ({
     ...state,
     notifPermissionAlertInfo: defaultNotifPermissionAlertInfo,
   }),
   [2]: (state: AppState) => ({
     ...state,
     messageSentFromRoute: [],
   }),
   [3]: (state: any) => ({
     currentUserInfo: state.currentUserInfo,
     entryStore: state.entryStore,
     threadInfos: state.threadInfos,
     userInfos: state.userInfos,
     messageStore: {
       ...state.messageStore,
       currentAsOf: state.currentAsOf,
     },
     updatesCurrentAsOf: state.currentAsOf,
     cookie: state.cookie,
     deviceToken: state.deviceToken,
     urlPrefix: state.urlPrefix,
     customServer: state.customServer,
     notifPermissionAlertInfo: state.notifPermissionAlertInfo,
     messageSentFromRoute: state.messageSentFromRoute,
     _persist: state._persist,
   }),
   [4]: (state: AppState) => ({
     ...state,
     pingTimestamps: undefined,
     activeServerRequests: undefined,
   }),
   [5]: (state: AppState) => ({
     ...state,
     calendarFilters: defaultCalendarFilters,
   }),
   [6]: (state: any) => ({
     ...state,
     threadInfos: undefined,
     threadStore: {
       threadInfos: state.threadInfos,
       inconsistencyResponses: [],
     },
   }),
   [7]: (state: AppState) => ({
     ...state,
     lastUserInteraction: undefined,
     sessionID: undefined,
     entryStore: {
       ...state.entryStore,
       inconsistencyResponses: [],
     },
   }),
   [8]: (state: AppState) => ({
     ...state,
     pingTimestamps: undefined,
     activeServerRequests: undefined,
     connection: {
       ...defaultConnectionInfo,
       actualizedCalendarQuery: defaultCalendarQuery(Platform.OS),
     },
     watchedThreadIDs: [],
     entryStore: {
       ...state.entryStore,
       actualizedCalendarQuery: undefined,
     },
   }),
   [9]: (state: any) => ({
     ...state,
     connection: {
       ...state.connection,
       lateResponses: [],
     },
   }),
   [10]: (state: any) => ({
     ...state,
     nextLocalID: highestLocalIDSelector(state) + 1,
     connection: {
       ...state.connection,
       showDisconnectedBar: false,
     },
     messageStore: {
       ...state.messageStore,
       local: {},
     },
   }),
   [11]: (state: AppState) => ({
     ...state,
     messageStore: DEPRECATED_unshimMessageStore(state.messageStore, [
       messageTypes.IMAGES,
     ]),
   }),
   [12]: (state: AppState) => ({
     ...state,
     globalThemeInfo: defaultGlobalThemeInfo,
   }),
   [13]: (state: AppState) => ({
     ...state,
     deviceCameraInfo: defaultDeviceCameraInfo,
     deviceOrientation: Orientation.getInitialOrientation(),
   }),
   [14]: (state: AppState) => state,
   [15]: (state: any) => ({
     ...state,
     threadStore: {
       ...state.threadStore,
       inconsistencyReports: inconsistencyResponsesToReports(
         state.threadStore.inconsistencyResponses,
       ),
       inconsistencyResponses: undefined,
     },
     entryStore: {
       ...state.entryStore,
       inconsistencyReports: inconsistencyResponsesToReports(
         state.entryStore.inconsistencyResponses,
       ),
       inconsistencyResponses: undefined,
     },
     queuedReports: [],
   }),
   [16]: (state: any) => {
     const result = {
       ...state,
       messageSentFromRoute: undefined,
       dataLoaded: !!state.currentUserInfo && !state.currentUserInfo.anonymous,
     };
     if (state.navInfo) {
       result.navInfo = {
         ...state.navInfo,
         navigationState: undefined,
       };
     }
     return result;
   },
   [17]: (state: any) => ({
     ...state,
     userInfos: undefined,
     userStore: {
       userInfos: state.userInfos,
       inconsistencyResponses: [],
     },
   }),
   [18]: (state: AppState) => ({
     ...state,
     userStore: {
       userInfos: state.userStore.userInfos,
       inconsistencyReports: [],
     },
   }),
   [19]: (state: any) => {
     const threadInfos: { [string]: LegacyRawThreadInfo } = {};
     for (const threadID in state.threadStore.threadInfos) {
       const threadInfo = state.threadStore.threadInfos[threadID];
       const { visibilityRules, ...rest } = threadInfo;
       threadInfos[threadID] = rest;
     }
     return {
       ...state,
       threadStore: {
         ...state.threadStore,
         threadInfos,
       },
     };
   },
   [20]: (state: AppState) => ({
     ...state,
     messageStore: DEPRECATED_unshimMessageStore(state.messageStore, [
       messageTypes.UPDATE_RELATIONSHIP,
     ]),
   }),
   [21]: (state: AppState) => ({
     ...state,
     messageStore: DEPRECATED_unshimMessageStore(state.messageStore, [
       messageTypes.CREATE_SIDEBAR,
       messageTypes.SIDEBAR_SOURCE,
     ]),
   }),
   [22]: (state: any) => {
     for (const key in state.drafts) {
       const value = state.drafts[key];
       try {
-        commCoreModule.updateDraft(key, value);
+        void commCoreModule.updateDraft(key, value);
       } catch (e) {
         if (!isTaskCancelledError(e)) {
           throw e;
         }
       }
     }
     return {
       ...state,
       drafts: undefined,
     };
   },
   [23]: (state: AppState) => ({
     ...state,
     globalThemeInfo: defaultGlobalThemeInfo,
   }),
   [24]: (state: AppState) => ({
     ...state,
     enabledApps: defaultEnabledApps,
   }),
   [25]: (state: AppState) => ({
     ...state,
     crashReportsEnabled: __DEV__,
   }),
   [26]: (state: any) => {
     const { currentUserInfo } = state;
     if (currentUserInfo.anonymous) {
       return state;
     }
     return {
       ...state,
       crashReportsEnabled: undefined,
       currentUserInfo: {
         id: currentUserInfo.id,
         username: currentUserInfo.username,
       },
       enabledReports: {
         crashReports: __DEV__,
         inconsistencyReports: __DEV__,
         mediaReports: __DEV__,
       },
     };
   },
   [27]: (state: any) => ({
     ...state,
     queuedReports: undefined,
     enabledReports: undefined,
     threadStore: {
       ...state.threadStore,
       inconsistencyReports: undefined,
     },
     entryStore: {
       ...state.entryStore,
       inconsistencyReports: undefined,
     },
     reportStore: {
       enabledReports: {
         crashReports: __DEV__,
         inconsistencyReports: __DEV__,
         mediaReports: __DEV__,
       },
       queuedReports: [
         ...state.entryStore.inconsistencyReports,
         ...state.threadStore.inconsistencyReports,
         ...state.queuedReports,
       ],
     },
   }),
   [28]: (state: AppState) => {
     const threadParentToChildren: { [string]: string[] } = {};
     for (const threadID in state.threadStore.threadInfos) {
       const threadInfo = state.threadStore.threadInfos[threadID];
       const parentThreadInfo = threadInfo.parentThreadID
         ? state.threadStore.threadInfos[threadInfo.parentThreadID]
         : null;
       const parentIndex = parentThreadInfo ? parentThreadInfo.id : '-1';
       if (!threadParentToChildren[parentIndex]) {
         threadParentToChildren[parentIndex] = [];
       }
       threadParentToChildren[parentIndex].push(threadID);
     }
 
     const rootIDs = threadParentToChildren['-1'];
     if (!rootIDs) {
       // This should never happen, but if it somehow does we'll let the state
       // check mechanism resolve it...
       return state;
     }
 
     const threadInfos: { [string]: LegacyRawThreadInfo } = {};
     const stack = [...rootIDs];
     while (stack.length > 0) {
       const threadID = stack.shift();
       const threadInfo = state.threadStore.threadInfos[threadID];
       const parentThreadInfo = threadInfo.parentThreadID
         ? threadInfos[threadInfo.parentThreadID]
         : null;
       threadInfos[threadID] = {
         ...threadInfo,
         containingThreadID: getContainingThreadID(
           parentThreadInfo,
           threadInfo.type,
         ),
         community: getCommunity(parentThreadInfo),
       };
       const children = threadParentToChildren[threadID];
       if (children) {
         stack.push(...children);
       }
     }
     return { ...state, threadStore: { ...state.threadStore, threadInfos } };
   },
   [29]: (state: AppState) => {
     const updatedThreadInfos = migrateThreadStoreForEditThreadPermissions(
       state.threadStore.threadInfos,
     );
 
     return {
       ...state,
       threadStore: {
         ...state.threadStore,
         threadInfos: updatedThreadInfos,
       },
     };
   },
   [30]: (state: AppState) => {
     const threadInfos = state.threadStore.threadInfos;
     const operations = [
       {
         type: 'remove_all',
       },
       ...Object.keys(threadInfos).map((id: string) => ({
         type: 'replace',
         payload: { id, threadInfo: threadInfos[id] },
       })),
     ];
     try {
       commCoreModule.processThreadStoreOperationsSync(
         threadStoreOpsHandlers.convertOpsToClientDBOps(operations),
       );
     } catch (exception) {
       console.log(exception);
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
     return state;
   },
   [31]: (state: AppState) => {
     const messages = state.messageStore.messages;
     const operations: $ReadOnlyArray<ClientDBMessageStoreOperation> = [
       {
         type: 'remove_all',
       },
       ...Object.keys(messages).map((id: string) => ({
         type: 'replace',
         payload: translateRawMessageInfoToClientDBMessageInfo(messages[id]),
       })),
     ];
     try {
       commCoreModule.processMessageStoreOperationsSync(operations);
     } catch (exception) {
       console.log(exception);
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
     return state;
   },
   [32]: (state: AppState) => unshimClientDB(state, [messageTypes.MULTIMEDIA]),
   [33]: (state: AppState) => unshimClientDB(state, [messageTypes.REACTION]),
   [34]: (state: any) => {
     const { threadIDsToNotifIDs, ...stateSansThreadIDsToNotifIDs } = state;
     return stateSansThreadIDsToNotifIDs;
   },
   [35]: (state: AppState) => unshimClientDB(state, [messageTypes.MULTIMEDIA]),
   [36]: (state: AppState) => {
     // 1. Get threads and messages from SQLite `threads` and `messages` tables.
     const clientDBThreadInfos = commCoreModule.getAllThreadsSync();
     const clientDBMessageInfos = commCoreModule.getAllMessagesSync();
 
     // 2. Translate `ClientDBThreadInfo`s to `RawThreadInfo`s and
     //    `ClientDBMessageInfo`s to `RawMessageInfo`s.
     const rawThreadInfos = clientDBThreadInfos.map(
       convertClientDBThreadInfoToRawThreadInfo,
     );
     const rawMessageInfos = clientDBMessageInfos.map(
       translateClientDBMessageInfoToRawMessageInfo,
     );
 
     // 3. Unshim translated `RawMessageInfos` to get the TOGGLE_PIN messages
     const unshimmedRawMessageInfos = rawMessageInfos.map(messageInfo =>
       unshimFunc(messageInfo, new Set<MessageType>([messageTypes.TOGGLE_PIN])),
     );
 
     // 4. Filter out non-TOGGLE_PIN messages
     const filteredRawMessageInfos = unshimmedRawMessageInfos
       .map(messageInfo =>
         messageInfo.type === messageTypes.TOGGLE_PIN ? messageInfo : null,
       )
       .filter(Boolean);
 
     // 5. We want only the last TOGGLE_PIN message for each message ID,
     // so 'pin', 'unpin', 'pin' don't count as 3 pins, but only 1.
     const lastMessageIDToRawMessageInfoMap = new Map<string, RawMessageInfo>();
     for (const messageInfo of filteredRawMessageInfos) {
       const { targetMessageID } = messageInfo;
       lastMessageIDToRawMessageInfoMap.set(targetMessageID, messageInfo);
     }
     const lastMessageIDToRawMessageInfos = Array.from(
       lastMessageIDToRawMessageInfoMap.values(),
     );
 
     // 6. Create a Map of threadIDs to pinnedCount
     const threadIDsToPinnedCount = new Map<string, number>();
     for (const messageInfo of lastMessageIDToRawMessageInfos) {
       const { threadID, type } = messageInfo;
       if (type === messageTypes.TOGGLE_PIN) {
         const pinnedCount = threadIDsToPinnedCount.get(threadID) || 0;
         threadIDsToPinnedCount.set(threadID, pinnedCount + 1);
       }
     }
 
     // 7. Include a pinnedCount for each rawThreadInfo
     const rawThreadInfosWithPinnedCount = rawThreadInfos.map(threadInfo => ({
       ...threadInfo,
       pinnedCount: threadIDsToPinnedCount.get(threadInfo.id) || 0,
     }));
 
     // 8. Convert rawThreadInfos to a map of threadID to threadInfo
     const threadIDToThreadInfo = rawThreadInfosWithPinnedCount.reduce(
       (
         acc: { [string]: LegacyRawThreadInfo },
         threadInfo: LegacyRawThreadInfo,
       ) => {
         acc[threadInfo.id] = threadInfo;
         return acc;
       },
       {},
     );
 
     // 9. Add threadPermission to each threadInfo
     const rawThreadInfosWithThreadPermission =
       persistMigrationForManagePinsThreadPermission(threadIDToThreadInfo);
 
     // 10. Convert the new threadInfos back into an array
     const rawThreadInfosWithCountAndPermission = Object.keys(
       rawThreadInfosWithThreadPermission,
     ).map(id => rawThreadInfosWithThreadPermission[id]);
 
     // 11. Translate `RawThreadInfo`s to `ClientDBThreadInfo`s.
     const convertedClientDBThreadInfos =
       rawThreadInfosWithCountAndPermission.map(
         convertRawThreadInfoToClientDBThreadInfo,
       );
 
     // 12. Construct `ClientDBThreadStoreOperation`s to clear SQLite `threads`
     //    table and repopulate with `ClientDBThreadInfo`s.
     const operations: $ReadOnlyArray<ClientDBThreadStoreOperation> = [
       {
         type: 'remove_all',
       },
       ...convertedClientDBThreadInfos.map((thread: ClientDBThreadInfo) => ({
         type: 'replace',
         payload: thread,
       })),
     ];
 
     // 13. Try processing `ClientDBThreadStoreOperation`s and log out if
     //    `processThreadStoreOperationsSync(...)` throws an exception.
     try {
       commCoreModule.processThreadStoreOperationsSync(operations);
     } catch (exception) {
       console.log(exception);
       return { ...state, cookie: null };
     }
 
     return state;
   },
   [37]: (state: AppState) => {
     const operations = messageStoreOpsHandlers.convertOpsToClientDBOps([
       {
         type: 'remove_all_threads',
       },
       {
         type: 'replace_threads',
         payload: { threads: state.messageStore.threads },
       },
     ]);
 
     try {
       commCoreModule.processMessageStoreOperationsSync(operations);
     } catch (exception) {
       console.error(exception);
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
 
     return state;
   },
   [38]: (state: AppState) =>
     updateClientDBThreadStoreThreadInfos(state, updateRolesAndPermissions),
   [39]: (state: AppState) => unshimClientDB(state, [messageTypes.EDIT_MESSAGE]),
   [40]: (state: AppState) =>
     updateClientDBThreadStoreThreadInfos(state, updateRolesAndPermissions),
   [41]: (state: AppState) => {
     const queuedReports = state.reportStore.queuedReports.map(report => ({
       ...report,
       id: getUUID(),
     }));
     return {
       ...state,
       reportStore: { ...state.reportStore, queuedReports },
     };
   },
   [42]: (state: AppState) => {
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> = [
       { type: 'remove_all_reports' },
       ...convertReportsToReplaceReportOps(state.reportStore.queuedReports),
     ];
     const dbOperations: $ReadOnlyArray<ClientDBReportStoreOperation> =
       reportStoreOpsHandlers.convertOpsToClientDBOps(reportStoreOperations);
 
     try {
       commCoreModule.processReportStoreOperationsSync(dbOperations);
     } catch (exception) {
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
     return state;
   },
   [43]: async (state: any) => {
     const { messages, drafts, threads, messageStoreThreads } =
       await commCoreModule.getClientDBStore();
 
     const messageStoreThreadsOperations =
       createUpdateDBOpsForMessageStoreThreads(
         messageStoreThreads,
         convertMessageStoreThreadsToNewIDSchema,
       );
 
     const messageStoreMessagesOperations =
       createUpdateDBOpsForMessageStoreMessages(messages, messageInfos =>
         messageInfos.map(convertRawMessageInfoToNewIDSchema),
       );
 
     const threadOperations = createUpdateDBOpsForThreadStoreThreadInfos(
       threads,
       convertThreadStoreThreadInfosToNewIDSchema,
     );
 
     const draftOperations = generateIDSchemaMigrationOpsForDrafts(drafts);
 
     try {
       await Promise.all([
         commCoreModule.processMessageStoreOperations([
           ...messageStoreMessagesOperations,
           ...messageStoreThreadsOperations,
         ]),
         commCoreModule.processThreadStoreOperations(threadOperations),
         commCoreModule.processDraftStoreOperations(draftOperations),
       ]);
     } catch (exception) {
       console.log(exception);
       return { ...state, cookie: null };
     }
 
     const inviteLinksStore =
       state.inviteLinksStore ?? defaultState.inviteLinksStore;
 
     return {
       ...state,
       entryStore: convertEntryStoreToNewIDSchema(state.entryStore),
       messageStore: convertMessageStoreToNewIDSchema(state.messageStore),
       calendarFilters: state.calendarFilters.map(
         convertCalendarFilterToNewIDSchema,
       ),
       connection: convertConnectionInfoToNewIDSchema(state.connection),
       watchedThreadIDs: state.watchedThreadIDs.map(
         id => `${ashoatKeyserverID}|${id}`,
       ),
       inviteLinksStore: convertInviteLinksStoreToNewIDSchema(inviteLinksStore),
     };
   },
   [44]: async (state: any) => {
     const { cookie, ...rest } = state;
 
     return {
       ...rest,
       keyserverStore: { keyserverInfos: { [ashoatKeyserverID]: { cookie } } },
     };
   },
   [45]: async (state: any) => {
     const { updatesCurrentAsOf, keyserverStore, ...rest } = state;
 
     return {
       ...rest,
       keyserverStore: {
         ...keyserverStore,
         keyserverInfos: {
           ...keyserverStore.keyserverInfos,
           [ashoatKeyserverID]: {
             ...keyserverStore.keyserverInfos[ashoatKeyserverID],
             updatesCurrentAsOf,
           },
         },
       },
     };
   },
   [46]: async (state: AppState) => {
     const { currentAsOf } = state.messageStore;
 
     return {
       ...state,
       messageStore: {
         ...state.messageStore,
         currentAsOf: { [ashoatKeyserverID]: currentAsOf },
       },
     };
   },
   [47]: async (state: any) => {
     const { urlPrefix, keyserverStore, ...rest } = state;
 
     return {
       ...rest,
       keyserverStore: {
         ...keyserverStore,
         keyserverInfos: {
           ...keyserverStore.keyserverInfos,
           [ashoatKeyserverID]: {
             ...keyserverStore.keyserverInfos[ashoatKeyserverID],
             urlPrefix,
           },
         },
       },
     };
   },
   [48]: async (state: any) => {
     const { connection, keyserverStore, ...rest } = state;
 
     return {
       ...rest,
       keyserverStore: {
         ...keyserverStore,
         keyserverInfos: {
           ...keyserverStore.keyserverInfos,
           [ashoatKeyserverID]: {
             ...keyserverStore.keyserverInfos[ashoatKeyserverID],
             connection,
           },
         },
       },
     };
   },
   [49]: async (state: AppState) => {
     const { keyserverStore, ...rest } = state;
 
     const { connection, ...keyserverRest } =
       keyserverStore.keyserverInfos[ashoatKeyserverID];
 
     return {
       ...rest,
       keyserverStore: {
         ...keyserverStore,
         keyserverInfos: {
           ...keyserverStore.keyserverInfos,
           [ashoatKeyserverID]: {
             ...keyserverRest,
           },
         },
       },
       connection,
     };
   },
   [50]: async (state: any) => {
     const { connection, ...rest } = state;
     const { actualizedCalendarQuery, ...connectionRest } = connection;
 
     return {
       ...rest,
       connection: connectionRest,
       actualizedCalendarQuery,
     };
   },
   [51]: async (state: any) => {
     const { lastCommunicatedPlatformDetails, keyserverStore, ...rest } = state;
 
     return {
       ...rest,
       keyserverStore: {
         ...keyserverStore,
         keyserverInfos: {
           ...keyserverStore.keyserverInfos,
           [ashoatKeyserverID]: {
             ...keyserverStore.keyserverInfos[ashoatKeyserverID],
             lastCommunicatedPlatformDetails,
           },
         },
       },
     };
   },
   [52]: async (state: AppState) => ({
     ...state,
     integrityStore: {
       threadHashes: {},
       threadHashingStatus: 'data_not_loaded',
     },
   }),
   [53]: (state: any) => {
     if (!state.userStore.inconsistencyReports) {
       return state;
     }
     const reportStoreOperations = convertReportsToReplaceReportOps(
       state.userStore.inconsistencyReports,
     );
     const dbOperations: $ReadOnlyArray<ClientDBReportStoreOperation> =
       reportStoreOpsHandlers.convertOpsToClientDBOps(reportStoreOperations);
     try {
       commCoreModule.processReportStoreOperationsSync(dbOperations);
     } catch (exception) {
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
 
     const { inconsistencyReports, ...newUserStore } = state.userStore;
     const queuedReports = reportStoreOpsHandlers.processStoreOperations(
       state.reportStore.queuedReports,
       reportStoreOperations,
     );
     return {
       ...state,
       userStore: newUserStore,
       reportStore: {
         ...state.reportStore,
         queuedReports,
       },
     };
   },
   [54]: (state: any) => {
     let updatedMessageStoreThreads: MessageStoreThreads = {};
     for (const threadID: string in state.messageStore.threads) {
       const { lastNavigatedTo, lastPruned, ...rest } =
         state.messageStore.threads[threadID];
 
       updatedMessageStoreThreads = {
         ...updatedMessageStoreThreads,
         [threadID]: rest,
       };
     }
 
     return {
       ...state,
       messageStore: {
         ...state.messageStore,
         threads: updatedMessageStoreThreads,
       },
     };
   },
   [55]: async (state: AppState) =>
     __DEV__
       ? {
           ...state,
           keyserverStore: {
             ...state.keyserverStore,
             keyserverInfos: {
               ...state.keyserverStore.keyserverInfos,
               [ashoatKeyserverID]: {
                 ...state.keyserverStore.keyserverInfos[ashoatKeyserverID],
                 urlPrefix: defaultURLPrefix,
               },
             },
           },
         }
       : state,
   [56]: (state: any) => {
     const { deviceToken, keyserverStore, ...rest } = state;
 
     return {
       ...rest,
       keyserverStore: {
         ...keyserverStore,
         keyserverInfos: {
           ...keyserverStore.keyserverInfos,
           [ashoatKeyserverID]: {
             ...keyserverStore.keyserverInfos[ashoatKeyserverID],
             deviceToken,
           },
         },
       },
     };
   },
   [57]: async (state: any) => {
     const {
       // eslint-disable-next-line no-unused-vars
       connection,
       keyserverStore: { keyserverInfos },
       ...rest
     } = state;
     const newKeyserverInfos: { [string]: KeyserverInfo } = {};
     for (const key in keyserverInfos) {
       newKeyserverInfos[key] = {
         ...keyserverInfos[key],
         connection: { ...defaultConnectionInfo },
       };
     }
     return {
       ...rest,
       keyserverStore: {
         ...state.keyserverStore,
         keyserverInfos: newKeyserverInfos,
       },
     };
   },
   [58]: async (state: AppState) => {
     const userStoreOperations: $ReadOnlyArray<UserStoreOperation> = [
       { type: 'remove_all_users' },
       ...convertUserInfosToReplaceUserOps(state.userStore.userInfos),
     ];
     const dbOperations: $ReadOnlyArray<ClientDBUserStoreOperation> =
       userStoreOpsHandlers.convertOpsToClientDBOps(userStoreOperations);
 
     try {
       await commCoreModule.processUserStoreOperations(dbOperations);
     } catch (exception) {
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
     return state;
   },
   [59]: (state: AppState) => {
     const clientDBThreadInfos = commCoreModule.getAllThreadsSync();
     const rawThreadInfos = clientDBThreadInfos.map(
       convertClientDBThreadInfoToRawThreadInfo,
     );
     const rawThreadInfosObject = rawThreadInfos.reduce(
       (
         acc: { [string]: LegacyRawThreadInfo },
         threadInfo: LegacyRawThreadInfo,
       ) => {
         acc[threadInfo.id] = threadInfo;
         return acc;
       },
       {},
     );
 
     const migratedRawThreadInfos =
       persistMigrationToRemoveSelectRolePermissions(rawThreadInfosObject);
 
     const migratedThreadInfosArray = Object.keys(migratedRawThreadInfos).map(
       id => migratedRawThreadInfos[id],
     );
     const convertedClientDBThreadInfos = migratedThreadInfosArray.map(
       convertRawThreadInfoToClientDBThreadInfo,
     );
     const operations: $ReadOnlyArray<ClientDBThreadStoreOperation> = [
       {
         type: 'remove_all',
       },
       ...convertedClientDBThreadInfos.map((thread: ClientDBThreadInfo) => ({
         type: 'replace',
         payload: thread,
       })),
     ];
 
     try {
       commCoreModule.processThreadStoreOperationsSync(operations);
     } catch (exception) {
       console.log(exception);
       return { ...state, cookie: null };
     }
 
     return state;
   },
   [60]: (state: AppState) =>
     updateClientDBThreadStoreThreadInfos(state, updateRolesAndPermissions),
 };
 
 // After migration 31, we'll no longer want to persist `messageStore.messages`
 // via redux-persist. However, we DO want to continue persisting everything in
 // `messageStore` EXCEPT for `messages`. The `blacklist` property in
 // `persistConfig` allows us to specify top-level keys that shouldn't be
 // persisted. However, we aren't able to specify nested keys in `blacklist`.
 // As a result, if we want to prevent nested keys from being persisted we'll
 // need to use `createTransform(...)` to specify an `inbound` function that
 // allows us to modify the `state` object before it's passed through
 // `JSON.stringify(...)` and written to disk. We specify the keys for which
 // this transformation should be executed in the `whitelist` property of the
 // `config` object that's passed to `createTransform(...)`.
 // eslint-disable-next-line no-unused-vars
 type PersistedMessageStore = {
   +local: { +[id: string]: LocalMessageInfo },
   +currentAsOf: { +[keyserverID: string]: number },
 };
 const messageStoreMessagesBlocklistTransform: Transform = createTransform(
   (state: MessageStore): PersistedMessageStore => {
     const { messages, threads, ...messageStoreSansMessages } = state;
     return { ...messageStoreSansMessages };
   },
   (state: MessageStore): MessageStore => {
     // We typically expect `messageStore.messages` to be `undefined` because
     // messages are persisted in the SQLite `messages` table rather than via
     // `redux-persist`. In this case we want to set `messageStore.messages`
     // to {} so we don't run into issues with `messageStore.messages` being
     // `undefined` (https://phab.comm.dev/D5545).
     //
     // However, in the case that a user is upgrading from a client where
     // `persistConfig.version` < 31, we expect `messageStore.messages` to
     // contain messages stored via `redux-persist` that we need in order
     // to correctly populate the SQLite `messages` table in migration 31
     // (https://phab.comm.dev/D2600).
     //
     // However, because `messageStoreMessagesBlocklistTransform` modifies
     // `messageStore` before migrations are run, we need to make sure we aren't
     // inadvertently clearing `messageStore.messages` (by setting to {}) before
     // messages are stored in SQLite (https://linear.app/comm/issue/ENG-2377).
     return {
       ...state,
       threads: state.threads ?? {},
       messages: state.messages ?? {},
     };
   },
   { whitelist: ['messageStore'] },
 );
 
 type PersistedReportStore = $Diff<
   ReportStore,
   { +queuedReports: $ReadOnlyArray<ClientReportCreationRequest> },
 >;
 const reportStoreTransform: Transform = createTransform(
   (state: ReportStore): PersistedReportStore => {
     return { enabledReports: state.enabledReports };
   },
   (state: PersistedReportStore): ReportStore => {
     return { ...state, queuedReports: [] };
   },
   { whitelist: ['reportStore'] },
 );
 
 type PersistedKeyserverInfo = $Diff<
   KeyserverInfo,
   { +connection: ConnectionInfo },
 >;
 type PersistedKeyserverStore = {
   +keyserverInfos: { +[key: string]: PersistedKeyserverInfo },
 };
 const keyserverStoreTransform: Transform = createTransform(
   (state: KeyserverStore): PersistedKeyserverStore => {
     const keyserverInfos: { [string]: PersistedKeyserverInfo } = {};
     for (const key in state.keyserverInfos) {
       const { connection, ...rest } = state.keyserverInfos[key];
       keyserverInfos[key] = rest;
     }
     return {
       ...state,
       keyserverInfos,
     };
   },
   (state: PersistedKeyserverStore): KeyserverStore => {
     const keyserverInfos: { [string]: KeyserverInfo } = {};
     for (const key in state.keyserverInfos) {
       keyserverInfos[key] = {
         ...state.keyserverInfos[key],
         connection: { ...defaultConnectionInfo },
       };
     }
     return {
       ...state,
       keyserverInfos,
     };
   },
   { whitelist: ['keyserverStore'] },
 );
 
 const persistConfig = {
   key: 'root',
   storage: AsyncStorage,
   blacklist: [
     'loadingStatuses',
     'lifecycleState',
     'dimensions',
     'draftStore',
     'connectivity',
     'deviceOrientation',
     'frozen',
     'threadStore',
     'storeLoaded',
     'connection',
   ],
   debug: __DEV__,
   version: 60,
   transforms: [
     messageStoreMessagesBlocklistTransform,
     reportStoreTransform,
     keyserverStoreTransform,
   ],
   migrate: (createAsyncMigrate(migrations, { debug: __DEV__ }): any),
   timeout: ((__DEV__ ? 0 : undefined): number | void),
 };
 
 const codeVersion: number = commCoreModule.getCodeVersion();
 
 // This local exists to avoid a circular dependency where redux-setup needs to
 // import all the navigation and screen stuff, but some of those screens want to
 // access the persistor to purge its state.
 let storedPersistor = null;
 function setPersistor(persistor: *) {
   storedPersistor = persistor;
 }
 function getPersistor(): empty {
   invariant(storedPersistor, 'should be set');
   return storedPersistor;
 }
 
 export { persistConfig, codeVersion, setPersistor, getPersistor };
diff --git a/native/redux/redux-setup.js b/native/redux/redux-setup.js
index 878f599f9..f86933d69 100644
--- a/native/redux/redux-setup.js
+++ b/native/redux/redux-setup.js
@@ -1,387 +1,387 @@
 // @flow
 
 import { AppState as NativeAppState, Alert } from 'react-native';
 import { createStore, applyMiddleware, type Store, compose } from 'redux';
 import { persistStore, persistReducer } from 'redux-persist';
 import thunk from 'redux-thunk';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import { siweAuthActionTypes } from 'lib/actions/siwe-actions.js';
 import {
   logOutActionTypes,
   deleteKeyserverAccountActionTypes,
   logInActionTypes,
 } from 'lib/actions/user-actions.js';
 import type { ThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import baseReducer from 'lib/reducers/master-reducer.js';
 import {
   invalidSessionDowngrade,
   invalidSessionRecovery,
 } from 'lib/shared/session-utils.js';
 import { isStaff } from 'lib/shared/staff-utils.js';
 import type { Dispatch, BaseAction } from 'lib/types/redux-types.js';
 import { rehydrateActionType } from 'lib/types/redux-types.js';
 import type { SetSessionPayload } from 'lib/types/session-types.js';
 import { reduxLoggerMiddleware } from 'lib/utils/action-logger.js';
 import { setNewSessionActionType } from 'lib/utils/action-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   updateDimensionsActiveType,
   updateConnectivityActiveType,
   updateDeviceCameraInfoActionType,
   updateDeviceOrientationActionType,
   backgroundActionTypes,
   setReduxStateActionType,
   setStoreLoadedActionType,
   type Action,
   setLocalSettingsActionType,
 } from './action-types.js';
 import { defaultState } from './default-state.js';
 import { remoteReduxDevServerConfig } from './dev-tools.js';
 import { persistConfig, setPersistor } from './persist.js';
 import { onStateDifference } from './redux-debug-utils.js';
 import { processDBStoreOperations } from './redux-utils.js';
 import type { AppState } from './state-types.js';
 import { getGlobalNavContext } from '../navigation/icky-global.js';
 import { activeMessageListSelector } from '../navigation/nav-selectors.js';
 import reactotron from '../reactotron.js';
 import { AppOutOfDateAlertDetails } from '../utils/alert-messages.js';
 import { isStaffRelease } from '../utils/staff-utils.js';
 import { getDevServerHostname } from '../utils/url-utils.js';
 
 function reducer(state: AppState = defaultState, action: Action) {
   if (action.type === setReduxStateActionType) {
     return action.payload.state;
   }
 
   // We want to alert staff/developers if there's a difference between the keys
   // we expect to see REHYDRATED and the keys that are actually REHYDRATED.
   // Context: https://linear.app/comm/issue/ENG-2127/
   if (
     action.type === rehydrateActionType &&
     (__DEV__ ||
       isStaffRelease ||
       (state.currentUserInfo &&
         state.currentUserInfo.id &&
         isStaff(state.currentUserInfo.id)))
   ) {
     // 1. Construct set of keys expected to be REHYDRATED
     const defaultKeys: $ReadOnlyArray<string> = Object.keys(defaultState);
     const expectedKeys = defaultKeys.filter(
       each => !persistConfig.blacklist.includes(each),
     );
     const expectedKeysSet = new Set(expectedKeys);
 
     // 2. Construct set of keys actually REHYDRATED
     const rehydratedKeys: $ReadOnlyArray<string> = Object.keys(
       action.payload ?? {},
     );
     const rehydratedKeysSet = new Set(rehydratedKeys);
 
     // 3. Determine the difference between the two sets
     const expectedKeysNotRehydrated = expectedKeys.filter(
       each => !rehydratedKeysSet.has(each),
     );
     const rehydratedKeysNotExpected = rehydratedKeys.filter(
       each => !expectedKeysSet.has(each),
     );
 
     // 4. Display alerts with the differences between the two sets
     if (expectedKeysNotRehydrated.length > 0) {
       Alert.alert(
         `EXPECTED KEYS NOT REHYDRATED: ${JSON.stringify(
           expectedKeysNotRehydrated,
         )}`,
       );
     }
     if (rehydratedKeysNotExpected.length > 0) {
       Alert.alert(
         `REHYDRATED KEYS NOT EXPECTED: ${JSON.stringify(
           rehydratedKeysNotExpected,
         )}`,
       );
     }
   }
 
   if (
     (action.type === setNewSessionActionType &&
       invalidSessionDowngrade(
         state,
         action.payload.sessionChange.currentUserInfo,
         action.payload.preRequestUserState,
         action.payload.keyserverID,
       )) ||
     (action.type === logOutActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       )) ||
     (action.type === deleteKeyserverAccountActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       ))
   ) {
     return state;
   }
   if (
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.currentUserInfo &&
       invalidSessionRecovery(
         state,
         action.payload.sessionChange.currentUserInfo,
         action.payload.logInActionSource,
       )) ||
     ((action.type === logInActionTypes.success ||
       action.type === siweAuthActionTypes.success) &&
       invalidSessionRecovery(
         state,
         action.payload.currentUserInfo,
         action.payload.logInActionSource,
       ))
   ) {
     return state;
   }
 
   if (action.type === updateDimensionsActiveType) {
     return {
       ...state,
       dimensions: {
         ...state.dimensions,
         ...action.payload,
       },
     };
   } else if (action.type === updateConnectivityActiveType) {
     return {
       ...state,
       connectivity: action.payload,
     };
   } else if (action.type === updateDeviceCameraInfoActionType) {
     return {
       ...state,
       deviceCameraInfo: {
         ...state.deviceCameraInfo,
         ...action.payload,
       },
     };
   } else if (action.type === updateDeviceOrientationActionType) {
     return {
       ...state,
       deviceOrientation: action.payload,
     };
   } else if (action.type === setLocalSettingsActionType) {
     return {
       ...state,
       localSettings: { ...state.localSettings, ...action.payload },
     };
   } else if (
     action.type === logOutActionTypes.started ||
     action.type === logOutActionTypes.success ||
     action.type === deleteKeyserverAccountActionTypes.success
   ) {
     state = {
       ...state,
       localSettings: {
         isBackupEnabled: false,
       },
     };
   }
 
   if (action.type === setNewSessionActionType) {
     sessionInvalidationAlert(action.payload);
   }
   if (action.type === setStoreLoadedActionType) {
     return {
       ...state,
       storeLoaded: true,
     };
   }
   if (action.type === setClientDBStoreActionType) {
     state = {
       ...state,
       storeLoaded: true,
     };
     const currentLoggedInUserID = state.currentUserInfo?.anonymous
       ? undefined
       : state.currentUserInfo?.id;
     const actionCurrentLoggedInUserID = action.payload.currentUserID;
     if (
       !currentLoggedInUserID ||
       !actionCurrentLoggedInUserID ||
       actionCurrentLoggedInUserID !== currentLoggedInUserID
     ) {
       // If user is logged out now, was logged out at the time action was
       // dispatched or their ID changed between action dispatch and a
       // call to reducer we ignore the SQLite data since it is not valid
       return state;
     }
   }
 
   const baseReducerResult = baseReducer(
     state,
     (action: BaseAction),
     onStateDifference,
   );
   state = baseReducerResult.state;
 
   const { storeOperations } = baseReducerResult;
   const {
     draftStoreOperations,
     threadStoreOperations,
     messageStoreOperations,
     reportStoreOperations,
     userStoreOperations,
   } = storeOperations;
 
   const fixUnreadActiveThreadResult = fixUnreadActiveThread(state, action);
   state = fixUnreadActiveThreadResult.state;
 
   const threadStoreOperationsWithUnreadFix = [
     ...threadStoreOperations,
     ...fixUnreadActiveThreadResult.threadStoreOperations,
   ];
 
-  processDBStoreOperations({
+  void processDBStoreOperations({
     draftStoreOperations,
     messageStoreOperations,
     threadStoreOperations: threadStoreOperationsWithUnreadFix,
     reportStoreOperations,
     userStoreOperations,
   });
 
   return state;
 }
 
 function sessionInvalidationAlert(payload: SetSessionPayload) {
   if (
     !payload.sessionChange.cookieInvalidated ||
     !payload.preRequestUserState ||
     !payload.preRequestUserState.currentUserInfo ||
     payload.preRequestUserState.currentUserInfo.anonymous
   ) {
     return;
   }
   if (payload.error === 'client_version_unsupported') {
     Alert.alert(
       AppOutOfDateAlertDetails.title,
       AppOutOfDateAlertDetails.message,
       [{ text: 'OK' }],
       {
         cancelable: true,
       },
     );
   } else {
     Alert.alert(
       'Session invalidated',
       'We’re sorry, but your session was invalidated by the server. ' +
         'Please log in again.',
       [{ text: 'OK' }],
       { cancelable: true },
     );
   }
 }
 
 // Makes sure a currently focused thread is never unread. Note that we consider
 // a backgrounded NativeAppState to actually be active if it last changed to
 // inactive more than 10 seconds ago. This is because there is a delay when
 // NativeAppState is updating in response to a foreground, and actions don't get
 // processed more than 10 seconds after a backgrounding anyways. However we
 // don't consider this for action types that can be expected to happen while the
 // app is backgrounded.
 type FixUnreadActiveThreadResult = {
   +state: AppState,
   +threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 };
 
 function fixUnreadActiveThread(
   state: AppState,
   action: *,
 ): FixUnreadActiveThreadResult {
   const navContext = getGlobalNavContext();
   const activeThread = activeMessageListSelector(navContext);
   if (
     !activeThread ||
     !state.threadStore.threadInfos[activeThread]?.currentUser.unread ||
     (NativeAppState.currentState !== 'active' &&
       (appLastBecameInactive + 10000 >= Date.now() ||
         backgroundActionTypes.has(action.type)))
   ) {
     return { state, threadStoreOperations: [] };
   }
 
   const updatedActiveThreadInfo = {
     ...state.threadStore.threadInfos[activeThread],
     currentUser: {
       ...state.threadStore.threadInfos[activeThread].currentUser,
       unread: false,
     },
   };
 
   const threadStoreOperations = [
     {
       type: 'replace',
       payload: {
         id: activeThread,
         threadInfo: updatedActiveThreadInfo,
       },
     },
   ];
 
   const updatedThreadStore = threadStoreOpsHandlers.processStoreOperations(
     state.threadStore,
     threadStoreOperations,
   );
 
   return {
     state: { ...state, threadStore: updatedThreadStore },
     threadStoreOperations,
   };
 }
 
 let appLastBecameInactive = 0;
 
 function appBecameInactive() {
   appLastBecameInactive = Date.now();
 }
 
 const middleware = applyMiddleware(thunk, reduxLoggerMiddleware);
 
 let composeFunc = compose;
 if (__DEV__ && global.HermesInternal) {
   const { composeWithDevTools } = require('remote-redux-devtools/src/index.js');
   composeFunc = composeWithDevTools({
     name: 'Redux',
     hostname: getDevServerHostname(),
     ...remoteReduxDevServerConfig,
   });
 } else if (global.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) {
   composeFunc = global.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
     name: 'Redux',
   });
 }
 
 let enhancers;
 if (reactotron) {
   enhancers = composeFunc(middleware, reactotron.createEnhancer());
 } else {
   enhancers = composeFunc(middleware);
 }
 
 const store: Store<AppState, *> = createStore(
   persistReducer(persistConfig, reducer),
   defaultState,
   enhancers,
 );
 const persistor = persistStore(store);
 setPersistor(persistor);
 
 const unsafeDispatch: any = store.dispatch;
 const dispatch: Dispatch = unsafeDispatch;
 
 export { store, dispatch, appBecameInactive };
diff --git a/native/roles/change-roles-header-right-button.react.js b/native/roles/change-roles-header-right-button.react.js
index d701fa4fc..a3182ef90 100644
--- a/native/roles/change-roles-header-right-button.react.js
+++ b/native/roles/change-roles-header-right-button.react.js
@@ -1,88 +1,88 @@
 // @flow
 
 import { useNavigation } from '@react-navigation/native';
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, View } from 'react-native';
 import { TouchableOpacity } from 'react-native-gesture-handler';
 
 import {
   useChangeThreadMemberRoles,
   changeThreadMemberRolesActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import type { NavigationRoute } from '../navigation/route-names';
 import { useColors } from '../themes/colors.js';
 
 type Props = {
   +route: NavigationRoute<'ChangeRolesScreen'>,
   +shouldRoleChangeBeDisabled: boolean,
 };
 
 function ChangeRolesHeaderRightButton(props: Props): React.Node {
   const { threadInfo, memberInfo, role: selectedRole } = props.route.params;
   const { shouldRoleChangeBeDisabled } = props;
   const { role: initialRole } = memberInfo;
   invariant(initialRole, 'Expected initial role to be defined');
   invariant(selectedRole, 'Expected selected role to be defined');
   const navigation = useNavigation();
 
   const callChangeThreadMemberRoles = useChangeThreadMemberRoles();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const { disabledButton, purpleLink } = useColors();
   const textStyle = React.useMemo(
     () => ({
       color: shouldRoleChangeBeDisabled ? disabledButton : purpleLink,
       marginRight: 10,
     }),
     [disabledButton, purpleLink, shouldRoleChangeBeDisabled],
   );
 
   const handleSave = React.useCallback(() => {
     if (selectedRole === initialRole) {
       navigation.goBack();
       return;
     }
 
-    dispatchActionPromise(
+    void dispatchActionPromise(
       changeThreadMemberRolesActionTypes,
       callChangeThreadMemberRoles({
         threadID: threadInfo.id,
         memberIDs: [memberInfo.id],
         newRole: selectedRole,
       }),
     );
 
     navigation.goBack();
   }, [
     callChangeThreadMemberRoles,
     dispatchActionPromise,
     initialRole,
     memberInfo.id,
     navigation,
     selectedRole,
     threadInfo.id,
   ]);
 
   const saveButton = React.useMemo(() => {
     if (shouldRoleChangeBeDisabled) {
       return (
         <View>
           <Text style={textStyle}>Save</Text>
         </View>
       );
     }
 
     return (
       <TouchableOpacity onPress={handleSave}>
         <Text style={textStyle}>Save</Text>
       </TouchableOpacity>
     );
   }, [shouldRoleChangeBeDisabled, textStyle, handleSave]);
 
   return saveButton;
 }
 
 export default ChangeRolesHeaderRightButton;
diff --git a/native/roles/create-roles-header-right-button.react.js b/native/roles/create-roles-header-right-button.react.js
index 0d4d5db99..adcd5cc27 100644
--- a/native/roles/create-roles-header-right-button.react.js
+++ b/native/roles/create-roles-header-right-button.react.js
@@ -1,119 +1,119 @@
 // @flow
 
 import { useNavigation } from '@react-navigation/native';
 import invariant from 'invariant';
 import * as React from 'react';
 import { TouchableOpacity, Text } from 'react-native';
 
 import {
   useModifyCommunityRole,
   modifyCommunityRoleActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { values } from 'lib/utils/objects.js';
 
 import type { NavigationRoute } from '../navigation/route-names';
 import { useStyles } from '../themes/colors.js';
 
 type Props = {
   +route: NavigationRoute<'CreateRolesScreen'>,
   +setRoleCreationFailed: boolean => mixed,
 };
 
 function CreateRolesHeaderRightButton(props: Props): React.Node {
   const { threadInfo, action, existingRoleID, roleName, rolePermissions } =
     props.route.params;
   const { setRoleCreationFailed } = props;
   const navigation = useNavigation();
   const styles = useStyles(unboundStyles);
 
   const callModifyCommunityRole = useModifyCommunityRole();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const threadRoleNames = React.useMemo(
     () => values(threadInfo.roles).map(role => role.name),
     [threadInfo.roles],
   );
 
   const onPressCreate = React.useCallback(() => {
     if (threadRoleNames.includes(roleName) && action === 'create_role') {
       setRoleCreationFailed(true);
       return;
     }
 
     let callModifyCommunityRoleParams = {};
     if (action === 'create_role') {
       callModifyCommunityRoleParams = {
         community: threadInfo.id,
         action,
         name: roleName,
         permissions: [...rolePermissions],
       };
     } else {
       invariant(existingRoleID, 'existingRoleID should be set');
       callModifyCommunityRoleParams = {
         community: threadInfo.id,
         action,
         existingRoleID,
         name: roleName,
         permissions: [...rolePermissions],
       };
     }
 
-    dispatchActionPromise(
+    void dispatchActionPromise(
       modifyCommunityRoleActionTypes,
       callModifyCommunityRole(callModifyCommunityRoleParams),
     );
 
     navigation.goBack();
   }, [
     callModifyCommunityRole,
     dispatchActionPromise,
     threadInfo,
     action,
     existingRoleID,
     roleName,
     rolePermissions,
     navigation,
     setRoleCreationFailed,
     threadRoleNames,
   ]);
 
   const headerRightText = action === 'create_role' ? 'Create' : 'Save';
   const shouldHeaderRightBeDisabled = roleName.length === 0;
   const createButton = React.useMemo(() => {
     const textStyle = shouldHeaderRightBeDisabled
       ? styles.createButtonDisabled
       : styles.createButton;
 
     return (
       <TouchableOpacity
         onPress={onPressCreate}
         disabled={shouldHeaderRightBeDisabled}
       >
         <Text style={textStyle}>{headerRightText}</Text>
       </TouchableOpacity>
     );
   }, [
     shouldHeaderRightBeDisabled,
     headerRightText,
     styles.createButtonDisabled,
     styles.createButton,
     onPressCreate,
   ]);
 
   return createButton;
 }
 
 const unboundStyles = {
   createButtonDisabled: {
     color: 'disabledButton',
     marginRight: 10,
   },
   createButton: {
     color: 'purpleLink',
     marginRight: 10,
   },
 };
 
 export default CreateRolesHeaderRightButton;
diff --git a/native/roles/role-utils.react.js b/native/roles/role-utils.react.js
index 0b775ef4d..bc960a104 100644
--- a/native/roles/role-utils.react.js
+++ b/native/roles/role-utils.react.js
@@ -1,62 +1,62 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useDeleteCommunityRole,
   deleteCommunityRoleActionTypes,
 } from 'lib/actions/thread-actions.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { constructRoleDeletionMessagePrompt } from 'lib/utils/role-utils.js';
 
 import Alert from '../utils/alert.js';
 
 function useDisplayDeleteRoleAlert(
   threadInfo: ThreadInfo,
   existingRoleID: string,
   defaultRoleID: string,
   memberCount: number,
 ): () => void {
   const defaultRoleName = threadInfo.roles[defaultRoleID].name;
   const callDeleteCommunityRole = useDeleteCommunityRole();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const onDeleteRole = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       deleteCommunityRoleActionTypes,
       callDeleteCommunityRole({
         community: threadInfo.id,
         roleID: existingRoleID,
       }),
     );
   }, [
     callDeleteCommunityRole,
     dispatchActionPromise,
     existingRoleID,
     threadInfo.id,
   ]);
 
   const message = constructRoleDeletionMessagePrompt(
     defaultRoleName,
     memberCount,
   );
 
   return React.useCallback(
     () =>
       Alert.alert('Delete role', message, [
         {
           text: 'Yes, delete role',
           style: 'destructive',
           onPress: onDeleteRole,
         },
         {
           text: 'Cancel',
           style: 'cancel',
         },
       ]),
     [message, onDeleteRole],
   );
 }
 
 export { useDisplayDeleteRoleAlert };
diff --git a/native/root.react.js b/native/root.react.js
index 2204ac200..b53e86dbb 100644
--- a/native/root.react.js
+++ b/native/root.react.js
@@ -1,368 +1,368 @@
 // @flow
 
 import { ActionSheetProvider } from '@expo/react-native-action-sheet';
 import { BottomSheetModalProvider } from '@gorhom/bottom-sheet';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import type {
   PossiblyStaleNavigationState,
   UnsafeContainerActionEvent,
   GenericNavigationAction,
 } from '@react-navigation/core';
 import { useReduxDevToolsExtension } from '@react-navigation/devtools';
 import { NavigationContainer } from '@react-navigation/native';
 import * as SplashScreen from 'expo-splash-screen';
 import invariant from 'invariant';
 import * as React from 'react';
 import { Platform, UIManager, StyleSheet } from 'react-native';
 import { GestureHandlerRootView } from 'react-native-gesture-handler';
 import Orientation from 'react-native-orientation-locker';
 import {
   SafeAreaProvider,
   initialWindowMetrics,
 } from 'react-native-safe-area-context';
 import { Provider } from 'react-redux';
 import { PersistGate as ReduxPersistGate } from 'redux-persist/es/integration/react.js';
 
 import { ChatMentionContextProvider } from 'lib/components/chat-mention-provider.react.js';
 import { EditUserAvatarProvider } from 'lib/components/edit-user-avatar-provider.react.js';
 import { ENSCacheProvider } from 'lib/components/ens-cache-provider.react.js';
 import IntegrityHandler from 'lib/components/integrity-handler.react.js';
 import { MediaCacheProvider } from 'lib/components/media-cache-provider.react.js';
 import { TunnelbrokerProvider } from 'lib/tunnelbroker/tunnelbroker-context.js';
 import { actionLogger } from 'lib/utils/action-logger.js';
 
 import { RegistrationContextProvider } from './account/registration/registration-context-provider.react.js';
 import NativeEditThreadAvatarProvider from './avatars/native-edit-thread-avatar-provider.react.js';
 import BackupHandler from './backup/backup-handler.js';
 import { BottomSheetProvider } from './bottom-sheet/bottom-sheet-provider.react.js';
 import ChatContextProvider from './chat/chat-context-provider.react.js';
 import MessageEditingContextProvider from './chat/message-editing-context-provider.react.js';
 import { FeatureFlagsProvider } from './components/feature-flags-provider.react.js';
 import PersistedStateGate from './components/persisted-state-gate.js';
 import VersionSupportedChecker from './components/version-supported.react.js';
 import ConnectedStatusBar from './connected-status-bar.react.js';
 import { SQLiteDataHandler } from './data/sqlite-data-handler.js';
 import ErrorBoundary from './error-boundary.react.js';
 import InputStateContainer from './input/input-state-container.react.js';
 import LifecycleHandler from './lifecycle/lifecycle-handler.react.js';
 import MarkdownContextProvider from './markdown/markdown-context-provider.react.js';
 import { filesystemMediaCache } from './media/media-cache.js';
 import { DeepLinksContextProvider } from './navigation/deep-links-context-provider.react.js';
 import { defaultNavigationState } from './navigation/default-state.js';
 import DisconnectedBarVisibilityHandler from './navigation/disconnected-bar-visibility-handler.react.js';
 import { setGlobalNavContext } from './navigation/icky-global.js';
 import {
   NavContext,
   type NavContextType,
 } from './navigation/navigation-context.js';
 import NavigationHandler from './navigation/navigation-handler.react.js';
 import { validNavState } from './navigation/navigation-utils.js';
 import OrientationHandler from './navigation/orientation-handler.react.js';
 import { navStateAsyncStorageKey } from './navigation/persistance.js';
 import RootNavigator from './navigation/root-navigator.react.js';
 import ConnectivityUpdater from './redux/connectivity-updater.react.js';
 import { DimensionsUpdater } from './redux/dimensions-updater.react.js';
 import { getPersistor } from './redux/persist.js';
 import { store } from './redux/redux-setup.js';
 import { useSelector } from './redux/redux-utils.js';
 import { RootContext } from './root-context.js';
 import { MessageSearchProvider } from './search/search-provider.react.js';
 import Socket from './socket.react.js';
 import { StaffContextProvider } from './staff/staff-context.provider.react.js';
 import { useLoadCommFonts } from './themes/fonts.js';
 import { DarkTheme, LightTheme } from './themes/navigation.js';
 import ThemeHandler from './themes/theme-handler.react.js';
 import { provider } from './utils/ethers-utils.js';
 import { useTunnelbrokerInitMessage } from './utils/tunnelbroker-utils.js';
 
 // Add custom items to expo-dev-menu
 import './dev-menu.js';
 import './types/message-types-validator.js';
 
 if (Platform.OS === 'android') {
   UIManager.setLayoutAnimationEnabledExperimental &&
     UIManager.setLayoutAnimationEnabledExperimental(true);
 }
 
 const navInitAction = Object.freeze({ type: 'NAV/@@INIT' });
 const navUnknownAction = Object.freeze({ type: 'NAV/@@UNKNOWN' });
 
 SplashScreen.preventAutoHideAsync().catch(console.log);
 
 function Root() {
   const navStateRef = React.useRef<?PossiblyStaleNavigationState>();
   const navDispatchRef =
     React.useRef<?(
       action:
         | GenericNavigationAction
         | (PossiblyStaleNavigationState => GenericNavigationAction),
     ) => void>();
   const navStateInitializedRef = React.useRef(false);
 
   // We call this here to start the loading process
   // We gate the UI on the fonts loading in AppNavigator
   useLoadCommFonts();
 
   const [navContext, setNavContext] = React.useState<?NavContextType>(null);
   const updateNavContext = React.useCallback(() => {
     if (
       !navStateRef.current ||
       !navDispatchRef.current ||
       !navStateInitializedRef.current
     ) {
       return;
     }
     const updatedNavContext = {
       state: navStateRef.current,
       dispatch: navDispatchRef.current,
     };
     setNavContext(updatedNavContext);
     setGlobalNavContext(updatedNavContext);
   }, []);
 
   const [initialState, setInitialState] = React.useState(
     __DEV__ ? undefined : defaultNavigationState,
   );
 
   React.useEffect(() => {
     Orientation.lockToPortrait();
-    (async () => {
+    void (async () => {
       let loadedState = initialState;
       if (__DEV__) {
         try {
           const navStateString = await AsyncStorage.getItem(
             navStateAsyncStorageKey,
           );
           if (navStateString) {
             const savedState = JSON.parse(navStateString);
             if (validNavState(savedState)) {
               loadedState = savedState;
             }
           }
         } catch {}
       }
       if (!loadedState) {
         loadedState = defaultNavigationState;
       }
       if (loadedState !== initialState) {
         setInitialState(loadedState);
       }
       navStateRef.current = loadedState;
       updateNavContext();
       actionLogger.addOtherAction('navState', navInitAction, null, loadedState);
     })();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [updateNavContext]);
 
   const setNavStateInitialized = React.useCallback(() => {
     navStateInitializedRef.current = true;
     updateNavContext();
   }, [updateNavContext]);
 
   const [rootContext, setRootContext] = React.useState(() => ({
     setNavStateInitialized,
   }));
 
   const detectUnsupervisedBackgroundRef = React.useCallback(
     (detectUnsupervisedBackground: ?(alreadyClosed: boolean) => boolean) => {
       setRootContext(prevRootContext => ({
         ...prevRootContext,
         detectUnsupervisedBackground,
       }));
     },
     [],
   );
 
   const frozen = useSelector(state => state.frozen);
   const queuedActionsRef = React.useRef<Array<GenericNavigationAction>>([]);
   const onNavigationStateChange = React.useCallback(
     (state: ?PossiblyStaleNavigationState) => {
       invariant(state, 'nav state should be non-null');
       const prevState = navStateRef.current;
       navStateRef.current = state;
       updateNavContext();
 
       const queuedActions = queuedActionsRef.current;
       queuedActionsRef.current = [];
       if (queuedActions.length === 0) {
         queuedActions.push(navUnknownAction);
       }
       for (const action of queuedActions) {
         actionLogger.addOtherAction('navState', action, prevState, state);
       }
 
       if (!__DEV__ || frozen) {
         return;
       }
 
-      (async () => {
+      void (async () => {
         try {
           await AsyncStorage.setItem(
             navStateAsyncStorageKey,
             JSON.stringify(state),
           );
         } catch (e) {
           console.log('AsyncStorage threw while trying to persist navState', e);
         }
       })();
     },
     [updateNavContext, frozen],
   );
 
   const navContainerRef =
     React.useRef<?React.ElementRef<typeof NavigationContainer>>();
   const containerRef = React.useCallback(
     (navContainer: ?React.ElementRef<typeof NavigationContainer>) => {
       navContainerRef.current = navContainer;
       if (navContainer && !navDispatchRef.current) {
         navDispatchRef.current = navContainer.dispatch;
         updateNavContext();
       }
     },
     [updateNavContext],
   );
   useReduxDevToolsExtension(navContainerRef);
 
   const navContainer = navContainerRef.current;
   React.useEffect(() => {
     if (!navContainer) {
       return undefined;
     }
     return navContainer.addListener(
       '__unsafe_action__',
       (event: { +data: UnsafeContainerActionEvent, ... }) => {
         const { action, noop } = event.data;
         const navState = navStateRef.current;
         if (noop) {
           actionLogger.addOtherAction('navState', action, navState, navState);
           return;
         }
         queuedActionsRef.current.push({
           ...action,
           type: `NAV/${action.type}`,
         });
       },
     );
   }, [navContainer]);
 
   const activeTheme = useSelector(state => state.globalThemeInfo.activeTheme);
   const theme = (() => {
     if (activeTheme === 'light') {
       return LightTheme;
     } else if (activeTheme === 'dark') {
       return DarkTheme;
     }
     return undefined;
   })();
 
   const tunnelbrokerInitMessage = useTunnelbrokerInitMessage();
 
   const gated: React.Node = (
     <>
       <LifecycleHandler />
       <DisconnectedBarVisibilityHandler />
       <DimensionsUpdater />
       <ConnectivityUpdater />
       <ThemeHandler />
       <OrientationHandler />
       <BackupHandler />
       <IntegrityHandler />
     </>
   );
   let navigation;
   if (initialState) {
     navigation = (
       <NavigationContainer
         initialState={initialState}
         onStateChange={onNavigationStateChange}
         theme={theme}
         ref={containerRef}
       >
         <BottomSheetModalProvider>
           <ChatContextProvider>
             <DeepLinksContextProvider>
               <ChatMentionContextProvider>
                 <RootNavigator />
               </ChatMentionContextProvider>
             </DeepLinksContextProvider>
           </ChatContextProvider>
           <NavigationHandler />
         </BottomSheetModalProvider>
       </NavigationContainer>
     );
   }
   return (
     <GestureHandlerRootView style={styles.app}>
       <StaffContextProvider>
         <TunnelbrokerProvider initMessage={tunnelbrokerInitMessage}>
           <FeatureFlagsProvider>
             <NavContext.Provider value={navContext}>
               <RootContext.Provider value={rootContext}>
                 <InputStateContainer>
                   <MessageEditingContextProvider>
                     <SafeAreaProvider initialMetrics={initialWindowMetrics}>
                       <ActionSheetProvider>
                         <ENSCacheProvider provider={provider}>
                           <MediaCacheProvider
                             persistence={filesystemMediaCache}
                           >
                             <EditUserAvatarProvider>
                               <NativeEditThreadAvatarProvider>
                                 <MarkdownContextProvider>
                                   <MessageSearchProvider>
                                     <BottomSheetProvider>
                                       <RegistrationContextProvider>
                                         <SQLiteDataHandler />
                                         <ConnectedStatusBar />
                                         <ReduxPersistGate
                                           persistor={getPersistor()}
                                         >
                                           {gated}
                                         </ReduxPersistGate>
                                         <PersistedStateGate>
                                           <Socket
                                             detectUnsupervisedBackgroundRef={
                                               detectUnsupervisedBackgroundRef
                                             }
                                           />
                                           <VersionSupportedChecker />
                                         </PersistedStateGate>
                                         {navigation}
                                       </RegistrationContextProvider>
                                     </BottomSheetProvider>
                                   </MessageSearchProvider>
                                 </MarkdownContextProvider>
                               </NativeEditThreadAvatarProvider>
                             </EditUserAvatarProvider>
                           </MediaCacheProvider>
                         </ENSCacheProvider>
                       </ActionSheetProvider>
                     </SafeAreaProvider>
                   </MessageEditingContextProvider>
                 </InputStateContainer>
               </RootContext.Provider>
             </NavContext.Provider>
           </FeatureFlagsProvider>
         </TunnelbrokerProvider>
       </StaffContextProvider>
     </GestureHandlerRootView>
   );
 }
 
 const styles = StyleSheet.create({
   app: {
     flex: 1,
   },
 });
 
 function AppRoot(): React.Node {
   return (
     <Provider store={store}>
       <ErrorBoundary>
         <Root />
       </ErrorBoundary>
     </Provider>
   );
 }
 
 export default AppRoot;
diff --git a/native/socket.react.js b/native/socket.react.js
index 199d5889e..eddcba78e 100644
--- a/native/socket.react.js
+++ b/native/socket.react.js
@@ -1,182 +1,182 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { useLogOut, logOutActionTypes } from 'lib/actions/user-actions.js';
 import { preRequestUserStateForSingleKeyserverSelector } from 'lib/selectors/account-selectors.js';
 import {
   cookieSelector,
   urlPrefixSelector,
   connectionSelector,
   lastCommunicatedPlatformDetailsSelector,
 } from 'lib/selectors/keyserver-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { accountHasPassword } from 'lib/shared/account-utils.js';
 import { useInitialNotificationsEncryptedMessage } from 'lib/shared/crypto-utils.js';
 import Socket, { type BaseSocketProps } from 'lib/socket/socket.react.js';
 import { logInActionSources } from 'lib/types/account-types.js';
 import {
   useDispatchActionPromise,
   fetchNewCookieFromNativeCredentials,
 } from 'lib/utils/action-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import { InputStateContext } from './input/input-state.js';
 import {
   activeMessageListSelector,
   nativeCalendarQuery,
 } from './navigation/nav-selectors.js';
 import { NavContext } from './navigation/navigation-context.js';
 import { useSelector } from './redux/redux-utils.js';
 import { noDataAfterPolicyAcknowledgmentSelector } from './selectors/account-selectors.js';
 import {
   openSocketSelector,
   sessionIdentificationSelector,
   nativeGetClientResponsesSelector,
   nativeSessionStateFuncSelector,
 } from './selectors/socket-selectors.js';
 import Alert from './utils/alert.js';
 import { nativeNotificationsSessionCreator } from './utils/crypto-utils.js';
 import { decompressMessage } from './utils/decompress.js';
 
 const NativeSocket: React.ComponentType<BaseSocketProps> =
   React.memo<BaseSocketProps>(function NativeSocket(props: BaseSocketProps) {
     const inputState = React.useContext(InputStateContext);
     const navContext = React.useContext(NavContext);
 
     const cookie = useSelector(cookieSelector(ashoatKeyserverID));
     const urlPrefix = useSelector(urlPrefixSelector(ashoatKeyserverID));
     invariant(urlPrefix, 'missing urlPrefix for given keyserver id');
     const connection = useSelector(connectionSelector(ashoatKeyserverID));
     invariant(connection, 'keyserver missing from keyserverStore');
     const frozen = useSelector(state => state.frozen);
     const active = useSelector(
       state => isLoggedIn(state) && state.lifecycleState !== 'background',
     );
     const noDataAfterPolicyAcknowledgment = useSelector(
       noDataAfterPolicyAcknowledgmentSelector(ashoatKeyserverID),
     );
     const currentUserInfo = useSelector(state => state.currentUserInfo);
 
     const openSocket = useSelector(openSocketSelector(ashoatKeyserverID));
     invariant(openSocket, 'openSocket failed to be created');
     const sessionIdentification = useSelector(
       sessionIdentificationSelector(ashoatKeyserverID),
     );
     const preRequestUserState = useSelector(
       preRequestUserStateForSingleKeyserverSelector(ashoatKeyserverID),
     );
 
     const getInitialNotificationsEncryptedMessage =
       useInitialNotificationsEncryptedMessage(
         nativeNotificationsSessionCreator,
       );
 
     const getClientResponses = useSelector(state =>
       nativeGetClientResponsesSelector({
         redux: state,
         navContext,
         getInitialNotificationsEncryptedMessage,
       }),
     );
     const sessionStateFunc = useSelector(state =>
       nativeSessionStateFuncSelector(ashoatKeyserverID)({
         redux: state,
         navContext,
       }),
     );
     const currentCalendarQuery = useSelector(state =>
       nativeCalendarQuery({
         redux: state,
         navContext,
       }),
     );
 
     const canSendReports = useSelector(
       state =>
         !state.frozen &&
         state.connectivity.hasWiFi &&
         (!inputState || !inputState.uploadInProgress()),
     );
 
     const activeThread = React.useMemo(() => {
       if (!active) {
         return null;
       }
       return activeMessageListSelector(navContext);
     }, [active, navContext]);
 
     const lastCommunicatedPlatformDetails = useSelector(
       lastCommunicatedPlatformDetailsSelector(ashoatKeyserverID),
     );
 
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const callLogOut = useLogOut();
 
     const socketCrashLoopRecovery = React.useCallback(async () => {
       if (!accountHasPassword(currentUserInfo)) {
-        dispatchActionPromise(
+        void dispatchActionPromise(
           logOutActionTypes,
           callLogOut(preRequestUserState),
         );
         Alert.alert(
           'Log in needed',
           'After acknowledging the policies, we need you to log in to your account again',
           [{ text: 'OK' }],
         );
         return;
       }
 
       await fetchNewCookieFromNativeCredentials(
         dispatch,
         cookie,
         urlPrefix,
         logInActionSources.refetchUserDataAfterAcknowledgment,
         ashoatKeyserverID,
         getInitialNotificationsEncryptedMessage,
       );
     }, [
       callLogOut,
       cookie,
       currentUserInfo,
       dispatch,
       dispatchActionPromise,
       preRequestUserState,
       urlPrefix,
       getInitialNotificationsEncryptedMessage,
     ]);
 
     return (
       <Socket
         {...props}
         active={active}
         openSocket={openSocket}
         getClientResponses={getClientResponses}
         activeThread={activeThread}
         sessionStateFunc={sessionStateFunc}
         sessionIdentification={sessionIdentification}
         cookie={cookie}
         urlPrefix={urlPrefix}
         connection={connection}
         currentCalendarQuery={currentCalendarQuery}
         canSendReports={canSendReports}
         frozen={frozen}
         preRequestUserState={preRequestUserState}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         logOut={callLogOut}
         noDataAfterPolicyAcknowledgment={noDataAfterPolicyAcknowledgment}
         socketCrashLoopRecovery={socketCrashLoopRecovery}
         getInitialNotificationsEncryptedMessage={
           getInitialNotificationsEncryptedMessage
         }
         lastCommunicatedPlatformDetails={lastCommunicatedPlatformDetails}
         decompressSocketMessage={decompressMessage}
       />
     );
   });
 
 export default NativeSocket;
diff --git a/native/utils/hooks.js b/native/utils/hooks.js
index 332464835..2cbf034f0 100644
--- a/native/utils/hooks.js
+++ b/native/utils/hooks.js
@@ -1,29 +1,29 @@
 // @flow
 
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import * as React from 'react';
 
 function useOnFirstLaunchEffect(uniqueKey: string, effect: () => mixed) {
   const [started, setStarted] = React.useState(false);
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       if (started) {
         return;
       }
       setStarted(true);
       const hasBeenExecuted = await AsyncStorage.getItem(uniqueKey);
       if (hasBeenExecuted) {
         return;
       }
 
       try {
         await effect();
       } finally {
         await AsyncStorage.setItem(uniqueKey, 'true');
       }
     })();
   }, [effect, started, uniqueKey]);
 }
 
 export { useOnFirstLaunchEffect };
diff --git a/native/utils/tunnelbroker-utils.js b/native/utils/tunnelbroker-utils.js
index a15879470..a201131a6 100644
--- a/native/utils/tunnelbroker-utils.js
+++ b/native/utils/tunnelbroker-utils.js
@@ -1,36 +1,36 @@
 // @flow
 
 import * as React from 'react';
 
 import type { ConnectionInitializationMessage } from 'lib/types/tunnelbroker/session-types.js';
 
 import { getContentSigningKey } from './crypto-utils.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 function useTunnelbrokerInitMessage(): ?ConnectionInitializationMessage {
   const [deviceID, setDeviceID] = React.useState<?string>();
   const userID = useSelector(state => state.currentUserInfo?.id);
   const accessToken = useSelector(state => state.commServicesAccessToken);
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       const contentSigningKey = await getContentSigningKey();
       setDeviceID(contentSigningKey);
     })();
   }, []);
 
   return React.useMemo(() => {
     if (!deviceID || !accessToken || !userID) {
       return null;
     }
     return ({
       type: 'ConnectionInitializationMessage',
       deviceID,
       accessToken,
       userID,
       deviceType: 'mobile',
     }: ConnectionInitializationMessage);
   }, [accessToken, deviceID, userID]);
 }
 
 export { useTunnelbrokerInitMessage };
diff --git a/web/account/log-in-form.react.js b/web/account/log-in-form.react.js
index 39e1556bf..0f1b8e24e 100644
--- a/web/account/log-in-form.react.js
+++ b/web/account/log-in-form.react.js
@@ -1,87 +1,87 @@
 // @flow
 
 import { useConnectModal } from '@rainbow-me/rainbowkit';
 import * as React from 'react';
 import { useWalletClient } from 'wagmi';
 
 import { isDev } from 'lib/utils/dev-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import { useGetOrCreateCryptoStore } from './account-hooks.js';
 import css from './log-in-form.css';
 import SIWEButton from './siwe-button.react.js';
 import SIWELoginForm from './siwe-login-form.react.js';
 import TraditionalLoginForm from './traditional-login-form.react.js';
 import Button from '../components/button.react.js';
 import OrBreak from '../components/or-break.react.js';
 import { updateNavInfoActionType } from '../redux/action-types.js';
 
 function LoginForm(): React.Node {
   const { openConnectModal } = useConnectModal();
   const { data: signer } = useWalletClient();
   const dispatch = useDispatch();
 
   const getOrCreateCryptoStore = useGetOrCreateCryptoStore();
 
   React.useEffect(() => {
-    getOrCreateCryptoStore();
+    void getOrCreateCryptoStore();
   }, [getOrCreateCryptoStore]);
 
   const onQRCodeLoginButtonClick = React.useCallback(() => {
     dispatch({
       type: updateNavInfoActionType,
       payload: {
         loginMethod: 'qr-code',
       },
     });
   }, [dispatch]);
 
   const qrCodeLoginButton = React.useMemo(() => {
     if (!isDev) {
       return null;
     }
 
     return (
       <div className={css.form_qrcode_login}>
         <Button
           variant="outline"
           type="submit"
           onClick={onQRCodeLoginButtonClick}
         >
           Sign in via QR Code
         </Button>
       </div>
     );
   }, [onQRCodeLoginButtonClick]);
 
   const [siweAuthFlowSelected, setSIWEAuthFlowSelected] =
     React.useState<boolean>(false);
 
   const onSIWEButtonClick = React.useCallback(() => {
     setSIWEAuthFlowSelected(true);
     openConnectModal && openConnectModal();
   }, [openConnectModal]);
 
   const cancelSIWEAuthFlow = React.useCallback(() => {
     setSIWEAuthFlowSelected(false);
   }, []);
 
   if (siweAuthFlowSelected && signer) {
     return (
       <div className={css.modal_body}>
         <SIWELoginForm cancelSIWEAuthFlow={cancelSIWEAuthFlow} />
       </div>
     );
   }
 
   return (
     <div className={css.modal_body}>
       <TraditionalLoginForm />
       <OrBreak />
       <SIWEButton onSIWEButtonClick={onSIWEButtonClick} />
       {qrCodeLoginButton}
     </div>
   );
 }
 
 export default LoginForm;
diff --git a/web/account/qr-code-login.react.js b/web/account/qr-code-login.react.js
index ae9da49b4..04bc1d86d 100644
--- a/web/account/qr-code-login.react.js
+++ b/web/account/qr-code-login.react.js
@@ -1,62 +1,62 @@
 // @flow
 
 import { QRCodeSVG } from 'qrcode.react';
 import * as React from 'react';
 
 import { qrCodeLinkURL } from 'lib/facts/links.js';
 import { generateKeyCommon } from 'lib/media/aes-crypto-utils-common.js';
 import { uintArrayToHexString } from 'lib/media/data-utils.js';
 
 import css from './qr-code-login.css';
 import { useSelector } from '../redux/redux-utils.js';
 
 function QrCodeLogin(): React.Node {
   const [qrCodeValue, setQrCodeValue] = React.useState<?string>();
   const ed25519Key = useSelector(
     state => state.cryptoStore?.primaryIdentityKeys.ed25519,
   );
 
   const generateQRCode = React.useCallback(async () => {
     try {
       if (!ed25519Key) {
         return;
       }
 
       const rawAESKey: Uint8Array = await generateKeyCommon(crypto);
       const aesKeyAsHexString: string = uintArrayToHexString(rawAESKey);
 
       const url = qrCodeLinkURL(aesKeyAsHexString, ed25519Key);
       setQrCodeValue(url);
     } catch (err) {
       console.error('Failed to generate QR Code:', err);
     }
   }, [ed25519Key]);
 
   React.useEffect(() => {
-    generateQRCode();
+    void generateQRCode();
   }, [generateQRCode]);
 
   return (
     <div className={css.qrContainer}>
       <div className={css.title}>Log in to Comm</div>
       <div className={css.scanInstructions}>
         Open the Comm app on your phone and scan the QR code below
       </div>
       <QRCodeSVG value={qrCodeValue} size={300} marginSize={4} level="L" />
       <div className={css.instructionsContainer}>
         <div className={css.instructionsTitle}>How to find the scanner:</div>
         <div className={css.instructionsStep}>
           Go to <strong>Profile</strong>
         </div>
         <div className={css.instructionsStep}>
           Select <strong>Linked devices</strong>
         </div>
         <div className={css.instructionsStep}>
           Click <strong>Add</strong> on the top right
         </div>
       </div>
     </div>
   );
 }
 
 export default QrCodeLogin;
diff --git a/web/account/siwe-login-form.react.js b/web/account/siwe-login-form.react.js
index ba0f3dea3..5164280ca 100644
--- a/web/account/siwe-login-form.react.js
+++ b/web/account/siwe-login-form.react.js
@@ -1,268 +1,268 @@
 // @flow
 
 import '@rainbow-me/rainbowkit/styles.css';
 import classNames from 'classnames';
 import invariant from 'invariant';
 import * as React from 'react';
 import { useAccount, useWalletClient } from 'wagmi';
 
 import { setDataLoadedActionType } from 'lib/actions/client-db-store-actions.js';
 import {
   getSIWENonce,
   getSIWENonceActionTypes,
   siweAuth,
   siweAuthActionTypes,
 } from 'lib/actions/siwe-actions.js';
 import ConnectedWalletInfo from 'lib/components/connected-wallet-info.react.js';
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import stores from 'lib/facts/stores.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type {
   LogInStartingPayload,
   LogInExtraInfo,
 } from 'lib/types/account-types.js';
 import type { OLMIdentityKeys } from 'lib/types/crypto-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import {
   createSIWEMessage,
   getSIWEStatementForPublicKey,
   siweMessageSigningExplanationStatements,
 } from 'lib/utils/siwe-utils.js';
 
 import { useGetSignedIdentityKeysBlob } from './account-hooks.js';
 import HeaderSeparator from './header-separator.react.js';
 import css from './siwe.css';
 import Button from '../components/button.react.js';
 import OrBreak from '../components/or-break.react.js';
 import LoadingIndicator from '../loading-indicator.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { webLogInExtraInfoSelector } from '../selectors/account-selectors.js';
 
 type SIWELogInError = 'account_does_not_exist';
 
 type SIWELoginFormProps = {
   +cancelSIWEAuthFlow: () => void,
 };
 
 const getSIWENonceLoadingStatusSelector = createLoadingStatusSelector(
   getSIWENonceActionTypes,
 );
 const siweAuthLoadingStatusSelector =
   createLoadingStatusSelector(siweAuthActionTypes);
 function SIWELoginForm(props: SIWELoginFormProps): React.Node {
   const { address } = useAccount();
   const { data: signer } = useWalletClient();
   const dispatchActionPromise = useDispatchActionPromise();
   const getSIWENonceCall = useServerCall(getSIWENonce);
   const getSIWENonceCallLoadingStatus = useSelector(
     getSIWENonceLoadingStatusSelector,
   );
   const siweAuthLoadingStatus = useSelector(siweAuthLoadingStatusSelector);
   const siweAuthCall = useServerCall(siweAuth);
   const logInExtraInfo = useSelector(webLogInExtraInfoSelector);
 
   const [siweNonce, setSIWENonce] = React.useState<?string>(null);
 
   const siweNonceShouldBeFetched =
     !siweNonce && getSIWENonceCallLoadingStatus !== 'loading';
 
   React.useEffect(() => {
     if (!siweNonceShouldBeFetched) {
       return;
     }
-    dispatchActionPromise(
+    void dispatchActionPromise(
       getSIWENonceActionTypes,
       (async () => {
         const response = await getSIWENonceCall();
         setSIWENonce(response);
       })(),
     );
   }, [dispatchActionPromise, getSIWENonceCall, siweNonceShouldBeFetched]);
 
   const primaryIdentityPublicKeys: ?OLMIdentityKeys = useSelector(
     state => state.cryptoStore?.primaryIdentityKeys,
   );
 
   const getSignedIdentityKeysBlob = useGetSignedIdentityKeysBlob();
 
   const callSIWEAuthEndpoint = React.useCallback(
     async (message: string, signature: string, extraInfo: LogInExtraInfo) => {
       const signedIdentityKeysBlob = await getSignedIdentityKeysBlob();
       invariant(
         signedIdentityKeysBlob,
         'signedIdentityKeysBlob must be set in attemptSIWEAuth',
       );
       try {
         return await siweAuthCall({
           message,
           signature,
           signedIdentityKeysBlob,
           doNotRegister: true,
           ...extraInfo,
         });
       } catch (e) {
         if (
           e instanceof ServerError &&
           e.message === 'account_does_not_exist'
         ) {
           setError('account_does_not_exist');
         }
         throw e;
       }
     },
     [getSignedIdentityKeysBlob, siweAuthCall],
   );
 
   const attemptSIWEAuth = React.useCallback(
     (message: string, signature: string) => {
       const extraInfo = logInExtraInfo();
       return dispatchActionPromise(
         siweAuthActionTypes,
         callSIWEAuthEndpoint(message, signature, extraInfo),
         undefined,
         ({ calendarQuery: extraInfo.calendarQuery }: LogInStartingPayload),
       );
     },
     [callSIWEAuthEndpoint, dispatchActionPromise, logInExtraInfo],
   );
 
   const dispatch = useDispatch();
   const onSignInButtonClick = React.useCallback(async () => {
     invariant(signer, 'signer must be present during SIWE attempt');
     invariant(siweNonce, 'nonce must be present during SIWE attempt');
     invariant(
       primaryIdentityPublicKeys,
       'primaryIdentityPublicKeys must be present during SIWE attempt',
     );
     const statement = getSIWEStatementForPublicKey(
       primaryIdentityPublicKeys.ed25519,
     );
     const message = createSIWEMessage(address, statement, siweNonce);
     const signature = await signer.signMessage({ message });
     await attemptSIWEAuth(message, signature);
     dispatch({
       type: setDataLoadedActionType,
       payload: {
         dataLoaded: true,
       },
     });
   }, [
     address,
     attemptSIWEAuth,
     primaryIdentityPublicKeys,
     signer,
     siweNonce,
     dispatch,
   ]);
 
   const { cancelSIWEAuthFlow } = props;
 
   const backButtonColor = React.useMemo(
     () => ({ backgroundColor: '#211E2D' }),
     [],
   );
 
   const signInButtonColor = React.useMemo(
     () => ({ backgroundColor: '#6A20E3' }),
     [],
   );
 
   const [error, setError] = React.useState<?SIWELogInError>();
 
   const mainMiddleAreaClassName = classNames({
     [css.mainMiddleArea]: true,
     [css.hidden]: !!error,
   });
   const errorOverlayClassNames = classNames({
     [css.errorOverlay]: true,
     [css.hidden]: !error,
   });
 
   if (
     siweAuthLoadingStatus === 'loading' ||
     !siweNonce ||
     !primaryIdentityPublicKeys
   ) {
     return (
       <div className={css.loadingIndicator}>
         <LoadingIndicator status="loading" size="large" />
       </div>
     );
   }
 
   let errorText;
   if (error === 'account_does_not_exist') {
     errorText = (
       <>
         <p className={css.redText}>
           No Comm account found for that Ethereum wallet!
         </p>
         <p>
           We require that users register on their mobile devices. Comm relies on
           a primary device capable of scanning QR codes in order to authorize
           secondary devices.
         </p>
         <p>
           You can install our iOS app&nbsp;
           <a href={stores.appStoreUrl} target="_blank" rel="noreferrer">
             here
           </a>
           , or our Android app&nbsp;
           <a href={stores.googlePlayUrl} target="_blank" rel="noreferrer">
             here
           </a>
           .
         </p>
       </>
     );
   }
 
   return (
     <div className={css.siweLoginFormContainer}>
       <h4>Sign in with Ethereum</h4>
       <HeaderSeparator />
       <div className={css.walletConnectedText}>
         <p>Wallet Connected</p>
       </div>
       <div className={css.connectButtonContainer}>
         <ConnectedWalletInfo />
       </div>
       <div className={css.middleArea}>
         <div className={mainMiddleAreaClassName}>
           <div className={css.messageSigningStatements}>
             <p>{siweMessageSigningExplanationStatements}</p>
             <p>
               By signing up, you agree to our{' '}
               <a href="https://comm.app/terms">Terms of Use</a> &{' '}
               <a href="https://comm.app/privacy">Privacy Policy</a>.
             </p>
           </div>
           <Button
             variant="filled"
             onClick={onSignInButtonClick}
             buttonColor={signInButtonColor}
           >
             Sign in using this wallet
           </Button>
         </div>
         <div className={errorOverlayClassNames}>{errorText}</div>
       </div>
       <OrBreak />
       <Button
         variant="filled"
         onClick={cancelSIWEAuthFlow}
         buttonColor={backButtonColor}
       >
         <SWMansionIcon icon="chevron-left" size={18} />
         Back to sign in with username
       </Button>
     </div>
   );
 }
 
 export default SIWELoginForm;
diff --git a/web/account/traditional-login-form.react.js b/web/account/traditional-login-form.react.js
index 15142e4ff..aa9ad2f18 100644
--- a/web/account/traditional-login-form.react.js
+++ b/web/account/traditional-login-form.react.js
@@ -1,191 +1,191 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { useLogIn, logInActionTypes } from 'lib/actions/user-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import {
   oldValidUsernameRegex,
   validEmailRegex,
 } from 'lib/shared/account-utils.js';
 import type {
   LogInExtraInfo,
   LogInStartingPayload,
 } from 'lib/types/account-types.js';
 import { logInActionSources } from 'lib/types/account-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import { useGetSignedIdentityKeysBlob } from './account-hooks.js';
 import HeaderSeparator from './header-separator.react.js';
 import css from './log-in-form.css';
 import PasswordInput from './password-input.react.js';
 import Button from '../components/button.react.js';
 import LoadingIndicator from '../loading-indicator.react.js';
 import Input from '../modals/input.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { webLogInExtraInfoSelector } from '../selectors/account-selectors.js';
 
 const loadingStatusSelector = createLoadingStatusSelector(logInActionTypes);
 function TraditionalLoginForm(): React.Node {
   const inputDisabled = useSelector(loadingStatusSelector) === 'loading';
   const loginExtraInfo = useSelector(webLogInExtraInfoSelector);
   const callLogIn = useLogIn();
   const dispatchActionPromise = useDispatchActionPromise();
   const modalContext = useModalContext();
 
   const getSignedIdentityKeysBlob = useGetSignedIdentityKeysBlob();
 
   const usernameInputRef = React.useRef<?HTMLInputElement>();
   React.useEffect(() => {
     usernameInputRef.current?.focus();
   }, []);
 
   const [username, setUsername] = React.useState<string>('');
   const onUsernameChange = React.useCallback(
     (e: SyntheticEvent<HTMLInputElement>) => {
       invariant(e.target instanceof HTMLInputElement, 'target not input');
       setUsername(e.target.value);
     },
     [],
   );
 
   const onUsernameBlur = React.useCallback(() => {
     setUsername(untrimmedUsername => untrimmedUsername.trim());
   }, []);
 
   const [password, setPassword] = React.useState<string>('');
   const onPasswordChange = React.useCallback(
     (e: SyntheticEvent<HTMLInputElement>) => {
       invariant(e.target instanceof HTMLInputElement, 'target not input');
       setPassword(e.target.value);
     },
     [],
   );
 
   const [errorMessage, setErrorMessage] = React.useState<string>('');
 
   const logInAction = React.useCallback(
     async (extraInfo: LogInExtraInfo) => {
       const signedIdentityKeysBlob = await getSignedIdentityKeysBlob();
       try {
         invariant(
           signedIdentityKeysBlob,
           'signedIdentityKeysBlob must be set in logInAction',
         );
 
         const result = await callLogIn({
           ...extraInfo,
           username,
           password,
           logInActionSource: logInActionSources.logInFromWebForm,
           signedIdentityKeysBlob,
         });
         modalContext.popModal();
         return result;
       } catch (e) {
         setUsername('');
         setPassword('');
         if (e.message === 'invalid_credentials') {
           setErrorMessage('incorrect username or password');
         } else {
           setErrorMessage('unknown error');
         }
         usernameInputRef.current?.focus();
         throw e;
       }
     },
     [callLogIn, modalContext, password, getSignedIdentityKeysBlob, username],
   );
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
 
       if (username.search(validEmailRegex) > -1) {
         setUsername('');
         setErrorMessage('usernames only, not emails');
         usernameInputRef.current?.focus();
         return;
       } else if (username.search(oldValidUsernameRegex) === -1) {
         setUsername('');
         setErrorMessage('alphanumeric usernames only');
         usernameInputRef.current?.focus();
         return;
       } else if (password === '') {
         setErrorMessage('password is empty');
         usernameInputRef.current?.focus();
         return;
       }
 
       const extraInfo = loginExtraInfo();
-      dispatchActionPromise(
+      void dispatchActionPromise(
         logInActionTypes,
         logInAction(extraInfo),
         undefined,
         ({ calendarQuery: extraInfo.calendarQuery }: LogInStartingPayload),
       );
     },
     [dispatchActionPromise, logInAction, loginExtraInfo, username, password],
   );
 
   const loginButtonContent = React.useMemo(() => {
     if (inputDisabled) {
       return <LoadingIndicator status="loading" />;
     }
     return 'Sign in';
   }, [inputDisabled]);
 
   const signInButtonColor = React.useMemo(
     () => ({ backgroundColor: '#6A20E3' }),
     [],
   );
 
   return (
     <form method="POST">
       <div>
         <h4>Sign in to Comm</h4>
         <HeaderSeparator />
         <div className={css.form_title}>Username</div>
         <div className={css.form_content}>
           <Input
             className={css.input}
             type="text"
             placeholder="Username"
             value={username}
             onChange={onUsernameChange}
             onBlur={onUsernameBlur}
             ref={usernameInputRef}
             disabled={inputDisabled}
           />
         </div>
       </div>
       <div>
         <div className={css.form_title}>Password</div>
         <div className={css.form_content}>
           <PasswordInput
             className={css.input}
             value={password}
             onChange={onPasswordChange}
             disabled={inputDisabled}
           />
         </div>
       </div>
       <div className={css.form_footer}>
         <Button
           variant="filled"
           type="submit"
           disabled={inputDisabled}
           onClick={onSubmit}
           buttonColor={signInButtonColor}
         >
           {loginButtonContent}
         </Button>
         <div className={css.modal_form_error}>{errorMessage}</div>
       </div>
     </form>
   );
 }
 
 export default TraditionalLoginForm;
diff --git a/web/app.react.js b/web/app.react.js
index 053bc2117..209cf6516 100644
--- a/web/app.react.js
+++ b/web/app.react.js
@@ -1,407 +1,407 @@
 // @flow
 
 import 'basscss/css/basscss.min.css';
 import './theme.css';
 import { config as faConfig } from '@fortawesome/fontawesome-svg-core';
 import classnames from 'classnames';
 import _isEqual from 'lodash/fp/isEqual.js';
 import * as React from 'react';
 import { DndProvider } from 'react-dnd';
 import { HTML5Backend } from 'react-dnd-html5-backend';
 import { WagmiConfig } from 'wagmi';
 
 import {
   fetchEntriesActionTypes,
   updateCalendarQueryActionTypes,
 } from 'lib/actions/entry-actions.js';
 import { ChatMentionContextProvider } from 'lib/components/chat-mention-provider.react.js';
 import { EditUserAvatarProvider } from 'lib/components/edit-user-avatar-provider.react.js';
 import {
   ModalProvider,
   useModalContext,
 } from 'lib/components/modal-provider.react.js';
 import {
   createLoadingStatusSelector,
   combineLoadingStatuses,
 } from 'lib/selectors/loading-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { extractMajorDesktopVersion } from 'lib/shared/version-utils.js';
 import { TunnelbrokerProvider } from 'lib/tunnelbroker/tunnelbroker-context.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { registerConfig } from 'lib/utils/config.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { infoFromURL } from 'lib/utils/url-utils.js';
 import { AlchemyENSCacheProvider, wagmiConfig } from 'lib/utils/wagmi-utils.js';
 
 import QrCodeLogin from './account/qr-code-login.react.js';
 import AppThemeWrapper from './app-theme-wrapper.react.js';
 import WebEditThreadAvatarProvider from './avatars/web-edit-thread-avatar-provider.react.js';
 import Calendar from './calendar/calendar.react.js';
 import Chat from './chat/chat.react.js';
 import { EditModalProvider } from './chat/edit-message-provider.js';
 import { TooltipProvider } from './chat/tooltip-provider.js';
 import NavigationArrows from './components/navigation-arrows.react.js';
 import { initOpaque } from './crypto/opaque-utils.js';
 import electron from './electron.js';
 import InputStateContainer from './input/input-state-container.react.js';
 import InviteLinkHandler from './invite-links/invite-link-handler.react.js';
 import InviteLinksRefresher from './invite-links/invite-links-refresher.react.js';
 import LoadingIndicator from './loading-indicator.react.js';
 import { MenuProvider } from './menu-provider.react.js';
 import UpdateModalHandler from './modals/update-modal.react.js';
 import SettingsSwitcher from './navigation-panels/settings-switcher.react.js';
 import Topbar from './navigation-panels/topbar.react.js';
 import useBadgeHandler from './push-notif/badge-handler.react.js';
 import { PushNotificationsHandler } from './push-notif/push-notifs-handler.js';
 import { updateNavInfoActionType } from './redux/action-types.js';
 import DisconnectedBarVisibilityHandler from './redux/disconnected-bar-visibility-handler.js';
 import DisconnectedBar from './redux/disconnected-bar.js';
 import FocusHandler from './redux/focus-handler.react.js';
 import { persistConfig } from './redux/persist.js';
 import PolicyAcknowledgmentHandler from './redux/policy-acknowledgment-handler.js';
 import { useSelector } from './redux/redux-utils.js';
 import VisibilityHandler from './redux/visibility-handler.react.js';
 import history from './router-history.js';
 import { MessageSearchStateProvider } from './search/message-search-state-provider.react.js';
 import { createTunnelbrokerInitMessage } from './selectors/tunnelbroker-selectors.js';
 import AccountSettings from './settings/account-settings.react.js';
 import DangerZone from './settings/danger-zone.react.js';
 import KeyserverSelectionList from './settings/keyserver-selection-list.react.js';
 import CommunityPicker from './sidebar/community-picker.react.js';
 import Splash from './splash/splash.react.js';
 import './typography.css';
 import css from './style.css';
 import { type NavInfo } from './types/nav-types.js';
 import { canonicalURLFromReduxState, navInfoFromURL } from './url-utils.js';
 
-initOpaque();
+void initOpaque();
 
 // We want Webpack's css-loader and style-loader to handle the Fontawesome CSS,
 // so we disable the autoAddCss logic and import the CSS file. Otherwise every
 // icon flashes huge for a second before the CSS is loaded.
 import '@fortawesome/fontawesome-svg-core/styles.css';
 
 faConfig.autoAddCss = false;
 const desktopDetails = electron?.version
   ? { majorDesktopVersion: extractMajorDesktopVersion(electron?.version) }
   : null;
 
 registerConfig({
   // We can't securely cache credentials on web, so we have no way to recover
   // from a cookie invalidation
   resolveInvalidatedCookie: null,
   setSessionIDOnRequest: true,
   // Never reset the calendar range
   calendarRangeInactivityLimit: null,
   platformDetails: {
     platform: electron?.platform ?? 'web',
     codeVersion: 49,
     stateVersion: persistConfig.version,
     ...desktopDetails,
   },
 });
 
 type BaseProps = {
   +location: {
     +pathname: string,
     ...
   },
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +navInfo: NavInfo,
   +entriesLoadingStatus: LoadingStatus,
   +loggedIn: boolean,
   +activeThreadCurrentlyUnread: boolean,
   // Redux dispatch functions
   +dispatch: Dispatch,
   +modals: $ReadOnlyArray<React.Node>,
 };
 
 class App extends React.PureComponent<Props> {
   componentDidMount() {
     const {
       navInfo,
       location: { pathname },
       loggedIn,
     } = this.props;
     const newURL = canonicalURLFromReduxState(navInfo, pathname, loggedIn);
     if (pathname !== newURL) {
       history.replace(newURL);
     }
   }
 
   componentDidUpdate(prevProps: Props) {
     const {
       navInfo,
       location: { pathname },
       loggedIn,
     } = this.props;
     if (!_isEqual(navInfo)(prevProps.navInfo)) {
       const newURL = canonicalURLFromReduxState(navInfo, pathname, loggedIn);
       if (newURL !== pathname) {
         history.push(newURL);
       }
     } else if (pathname !== prevProps.location.pathname) {
       const urlInfo = infoFromURL(pathname);
       const newNavInfo = navInfoFromURL(urlInfo, { navInfo });
       if (!_isEqual(newNavInfo)(navInfo)) {
         this.props.dispatch({
           type: updateNavInfoActionType,
           payload: newNavInfo,
         });
       }
     } else if (loggedIn !== prevProps.loggedIn) {
       const newURL = canonicalURLFromReduxState(navInfo, pathname, loggedIn);
       if (newURL !== pathname) {
         history.replace(newURL);
       }
     }
     if (loggedIn !== prevProps.loggedIn) {
       electron?.clearHistory();
     }
   }
 
   onWordmarkClicked = () => {
     this.props.dispatch({
       type: updateNavInfoActionType,
       payload: { tab: 'chat' },
     });
   };
 
   render(): React.Node {
     let content;
     if (this.props.loggedIn) {
       content = (
         <>
           <WebEditThreadAvatarProvider>
             <EditUserAvatarProvider>
               {this.renderMainContent()}
               {this.props.modals}
             </EditUserAvatarProvider>
           </WebEditThreadAvatarProvider>
         </>
       );
     } else {
       content = (
         <>
           {this.renderLoginPage()}
           {this.props.modals}
         </>
       );
     }
     return (
       <DndProvider backend={HTML5Backend}>
         <EditModalProvider>
           <TooltipProvider>
             <MenuProvider>
               <WagmiConfig config={wagmiConfig}>
                 <AlchemyENSCacheProvider>
                   <MessageSearchStateProvider>
                     <ChatMentionContextProvider>
                       <FocusHandler />
                       <VisibilityHandler />
                       <PolicyAcknowledgmentHandler />
                       <PushNotificationsHandler />
                       <InviteLinkHandler />
                       <InviteLinksRefresher />
                       {content}
                     </ChatMentionContextProvider>
                   </MessageSearchStateProvider>
                 </AlchemyENSCacheProvider>
               </WagmiConfig>
             </MenuProvider>
           </TooltipProvider>
         </EditModalProvider>
       </DndProvider>
     );
   }
 
   onHeaderDoubleClick = (): void => electron?.doubleClickTopBar();
   stopDoubleClickPropagation: ?(SyntheticEvent<HTMLAnchorElement>) => void =
     electron ? e => e.stopPropagation() : null;
 
   renderLoginPage(): React.Node {
     const { loginMethod } = this.props.navInfo;
 
     if (loginMethod === 'qr-code') {
       return <QrCodeLogin />;
     }
 
     return <Splash />;
   }
 
   renderMainContent(): React.Node {
     const mainContent = this.getMainContentWithSwitcher();
 
     let navigationArrows = null;
     if (electron) {
       navigationArrows = <NavigationArrows />;
     }
 
     const headerClasses = classnames({
       [css.header]: true,
       [css['electron-draggable']]: electron,
     });
 
     const wordmarkClasses = classnames({
       [css.wordmark]: true,
       [css['electron-non-draggable']]: electron,
       [css['wordmark-macos']]: electron?.platform === 'macos',
     });
 
     return (
       <div className={css.layout}>
         <DisconnectedBarVisibilityHandler />
         <DisconnectedBar />
         <UpdateModalHandler />
         <header
           className={headerClasses}
           onDoubleClick={this.onHeaderDoubleClick}
         >
           <div className={css['main-header']}>
             <h1 className={wordmarkClasses}>
               <a
                 title="Comm Home"
                 aria-label="Go to Comm Home"
                 onClick={this.onWordmarkClicked}
                 onDoubleClick={this.stopDoubleClickPropagation}
               >
                 Comm
               </a>
             </h1>
             {navigationArrows}
             <div className={css['upper-right']}>
               <LoadingIndicator
                 status={this.props.entriesLoadingStatus}
                 size="medium"
                 loadingClassName={css['page-loading']}
                 errorClassName={css['page-error']}
               />
             </div>
           </div>
         </header>
         <InputStateContainer>{mainContent}</InputStateContainer>
         <div className={css.sidebar}>
           <CommunityPicker />
         </div>
       </div>
     );
   }
 
   getMainContentWithSwitcher(): React.Node {
     const { tab, settingsSection } = this.props.navInfo;
     let mainContent: React.Node;
 
     if (tab === 'settings') {
       if (settingsSection === 'account') {
         mainContent = <AccountSettings />;
       } else if (settingsSection === 'keyservers') {
         mainContent = <KeyserverSelectionList />;
       } else if (settingsSection === 'danger-zone') {
         mainContent = <DangerZone />;
       }
       return (
         <div className={css['main-content-container']}>
           <div className={css.switcher}>
             <SettingsSwitcher />
           </div>
           <div className={css['main-content']}>{mainContent}</div>
         </div>
       );
     }
 
     if (tab === 'calendar') {
       mainContent = <Calendar url={this.props.location.pathname} />;
     } else if (tab === 'chat') {
       mainContent = <Chat />;
     }
 
     const mainContentClass = classnames(
       css['main-content-container'],
       css['main-content-container-column'],
     );
     return (
       <div className={mainContentClass}>
         <Topbar />
         <div className={css['main-content']}>{mainContent}</div>
       </div>
     );
   }
 }
 
 const fetchEntriesLoadingStatusSelector = createLoadingStatusSelector(
   fetchEntriesActionTypes,
 );
 const updateCalendarQueryLoadingStatusSelector = createLoadingStatusSelector(
   updateCalendarQueryActionTypes,
 );
 
 const ConnectedApp: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedApp(props) {
     const activeChatThreadID = useSelector(
       state => state.navInfo.activeChatThreadID,
     );
     const navInfo = useSelector(state => state.navInfo);
 
     const fetchEntriesLoadingStatus = useSelector(
       fetchEntriesLoadingStatusSelector,
     );
     const updateCalendarQueryLoadingStatus = useSelector(
       updateCalendarQueryLoadingStatusSelector,
     );
     const entriesLoadingStatus = combineLoadingStatuses(
       fetchEntriesLoadingStatus,
       updateCalendarQueryLoadingStatus,
     );
 
     const loggedIn = useSelector(isLoggedIn);
     const activeThreadCurrentlyUnread = useSelector(
       state =>
         !activeChatThreadID ||
         !!state.threadStore.threadInfos[activeChatThreadID]?.currentUser.unread,
     );
 
     useBadgeHandler();
 
     const dispatch = useDispatch();
     const modalContext = useModalContext();
     const modals = React.useMemo(
       () =>
         modalContext.modals.map(([modal, key]) => (
           <React.Fragment key={key}>{modal}</React.Fragment>
         )),
       [modalContext.modals],
     );
 
     const tunnelbrokerInitMessage = useSelector(createTunnelbrokerInitMessage);
 
     return (
       <AppThemeWrapper>
         <TunnelbrokerProvider initMessage={tunnelbrokerInitMessage}>
           <App
             {...props}
             navInfo={navInfo}
             entriesLoadingStatus={entriesLoadingStatus}
             loggedIn={loggedIn}
             activeThreadCurrentlyUnread={activeThreadCurrentlyUnread}
             dispatch={dispatch}
             modals={modals}
           />
         </TunnelbrokerProvider>
       </AppThemeWrapper>
     );
   },
 );
 
 function AppWithProvider(props: BaseProps): React.Node {
   return (
     <ModalProvider>
       <ConnectedApp {...props} />
     </ModalProvider>
   );
 }
 
 export default AppWithProvider;
diff --git a/web/calendar/calendar.react.js b/web/calendar/calendar.react.js
index 7c0f7b6c4..f057a3dee 100644
--- a/web/calendar/calendar.react.js
+++ b/web/calendar/calendar.react.js
@@ -1,292 +1,292 @@
 // @flow
 
 import dateFormat from 'dateformat';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   updateCalendarQueryActionTypes,
   useUpdateCalendarQuery,
 } from 'lib/actions/entry-actions.js';
 import type { UpdateCalendarQueryInput } from 'lib/actions/entry-actions.js';
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import { currentDaysToEntries } from 'lib/selectors/thread-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import {
   type EntryInfo,
   type CalendarQuery,
   type CalendarQueryUpdateResult,
   type CalendarQueryUpdateStartingPayload,
 } from 'lib/types/entry-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import {
   getDate,
   dateString,
   startDateForYearAndMonth,
   endDateForYearAndMonth,
 } from 'lib/utils/date-utils.js';
 
 import css from './calendar.css';
 import Day from './day.react.js';
 import FilterPanel from './filter-panel.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import {
   yearAssertingSelector,
   monthAssertingSelector,
   webCalendarQuery,
 } from '../selectors/nav-selectors.js';
 import type { NavInfo } from '../types/nav-types.js';
 import { canonicalURLFromReduxState } from '../url-utils.js';
 
 type StartAndEndDates = {
   +startDate: string,
   +endDate: string,
 };
 
 type BaseProps = {
   +url: string,
 };
 type Props = {
   ...BaseProps,
   +year: number,
   +month: number,
   +daysToEntries: { +[dayString: string]: EntryInfo[] },
   +navInfo: NavInfo,
   +currentCalendarQuery: () => CalendarQuery,
   +loggedIn: boolean,
   +dispatchActionPromise: DispatchActionPromise,
   +updateCalendarQuery: (
     input: UpdateCalendarQueryInput,
   ) => Promise<CalendarQueryUpdateResult>,
 };
 type State = {
   +filterPanelOpen: boolean,
 };
 class Calendar extends React.PureComponent<Props, State> {
   state: State = {
     filterPanelOpen: false,
   };
 
   getDate(
     dayOfMonth: number,
     monthInput: ?number = undefined,
     yearInput: ?number = undefined,
   ): Date {
     return getDate(
       yearInput ? yearInput : this.props.year,
       monthInput ? monthInput : this.props.month,
       dayOfMonth,
     );
   }
 
   prevMonthDates(): StartAndEndDates {
     const { year, month } = this.props;
     const lastMonthDate = getDate(year, month - 1, 1);
     const prevYear = lastMonthDate.getFullYear();
     const prevMonth = lastMonthDate.getMonth() + 1;
     return {
       startDate: startDateForYearAndMonth(prevYear, prevMonth),
       endDate: endDateForYearAndMonth(prevYear, prevMonth),
     };
   }
 
   nextMonthDates(): StartAndEndDates {
     const { year, month } = this.props;
     const nextMonthDate = getDate(year, month + 1, 1);
     const nextYear = nextMonthDate.getFullYear();
     const nextMonth = nextMonthDate.getMonth() + 1;
     return {
       startDate: startDateForYearAndMonth(nextYear, nextMonth),
       endDate: endDateForYearAndMonth(nextYear, nextMonth),
     };
   }
 
   render(): React.Node {
     const { year, month } = this.props;
     const monthName = dateFormat(getDate(year, month, 1), 'mmmm');
     const prevURL = canonicalURLFromReduxState(
       { ...this.props.navInfo, ...this.prevMonthDates() },
       this.props.url,
       this.props.loggedIn,
     );
     const nextURL = canonicalURLFromReduxState(
       { ...this.props.navInfo, ...this.nextMonthDates() },
       this.props.url,
       this.props.loggedIn,
     );
 
     const lastDayOfMonth = this.getDate(0, this.props.month + 1);
     const totalDaysInMonth = lastDayOfMonth.getDate();
     const firstDayToPrint = 1 - this.getDate(1).getDay();
     const lastDayToPrint = totalDaysInMonth + 6 - lastDayOfMonth.getDay();
 
     const rows = [];
     let columns = [];
     let week = 1;
     let tabIndex = 1;
     for (
       let curDayOfMonth = firstDayToPrint;
       curDayOfMonth <= lastDayToPrint;
       curDayOfMonth++
     ) {
       if (curDayOfMonth < 1 || curDayOfMonth > totalDaysInMonth) {
         columns.push(<td key={curDayOfMonth} />);
       } else {
         const dayString = dateString(
           this.props.year,
           this.props.month,
           curDayOfMonth,
         );
         const entries = this.props.daysToEntries[dayString];
         invariant(
           entries,
           'the currentDaysToEntries selector should make sure all dayStrings ' +
             `in the current range have entries, but ${dayString} did not`,
         );
         columns.push(
           <Day
             dayString={dayString}
             entryInfos={entries}
             key={curDayOfMonth}
             startingTabIndex={tabIndex}
           />,
         );
         tabIndex += entries.length;
       }
       if (columns.length === 7) {
         rows.push(<tr key={week++}>{columns}</tr>);
         columns = [];
       }
     }
 
     let filterPanel = null;
     let filterButton = null;
     if (this.state.filterPanelOpen) {
       filterPanel = <FilterPanel toggleFilters={this.toggleFilters} />;
     } else {
       filterButton = (
         <a className={css.filtersButton} onClick={this.toggleFilters}>
           <SWMansionIcon icon="filters-2" size={16} />
         </a>
       );
     }
 
     return (
       <div className={css.container}>
         {filterPanel}
         <div className={css.content}>
           <div>
             {filterButton}
             <nav className={css.nav}>
               <a
                 className={css.monthLink}
                 href={prevURL}
                 onClick={this.onClickPrevURL}
               >
                 <SWMansionIcon icon="chevron-left" size={24} />
               </a>
               <h2 className={css.monthName}>
                 {' '}
                 {monthName} {year}{' '}
               </h2>
               <a
                 className={css.monthLink}
                 href={nextURL}
                 onClick={this.onClickNextURL}
               >
                 <SWMansionIcon icon="chevron-right" size={24} />
               </a>
             </nav>
           </div>
           <table className={css.calendar}>
             <thead>
               <tr>
                 <th>Sunday</th>
                 <th>Monday</th>
                 <th>Tuesday</th>
                 <th>Wednesday</th>
                 <th>Thursday</th>
                 <th>Friday</th>
                 <th>Saturday</th>
               </tr>
             </thead>
             <tbody>{rows}</tbody>
           </table>
         </div>
       </div>
     );
   }
 
   toggleFilters = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     this.setState({ filterPanelOpen: !this.state.filterPanelOpen });
   };
 
   onClickPrevURL = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     const currentCalendarQuery = this.props.currentCalendarQuery();
     const newCalendarQuery = {
       ...currentCalendarQuery,
       ...this.prevMonthDates(),
     };
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       updateCalendarQueryActionTypes,
       this.props.updateCalendarQuery({
         calendarQuery: newCalendarQuery,
         reduxAlreadyUpdated: true,
       }),
       undefined,
       ({ calendarQuery: newCalendarQuery }: CalendarQueryUpdateStartingPayload),
     );
   };
 
   onClickNextURL = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     const currentCalendarQuery = this.props.currentCalendarQuery();
     const newCalendarQuery = {
       ...currentCalendarQuery,
       ...this.nextMonthDates(),
     };
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       updateCalendarQueryActionTypes,
       this.props.updateCalendarQuery({
         calendarQuery: newCalendarQuery,
         reduxAlreadyUpdated: true,
       }),
       undefined,
       ({ calendarQuery: newCalendarQuery }: CalendarQueryUpdateStartingPayload),
     );
   };
 }
 
 const ConnectedCalendar: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedCalendar(props) {
     const year = useSelector(yearAssertingSelector);
     const month = useSelector(monthAssertingSelector);
     const daysToEntries = useSelector(currentDaysToEntries);
     const navInfo = useSelector(state => state.navInfo);
     const currentCalendarQuery = useSelector(webCalendarQuery);
     const loggedIn = useSelector(isLoggedIn);
     const callUpdateCalendarQuery = useUpdateCalendarQuery();
     const dispatchActionPromise = useDispatchActionPromise();
 
     return (
       <Calendar
         {...props}
         year={year}
         month={month}
         daysToEntries={daysToEntries}
         navInfo={navInfo}
         currentCalendarQuery={currentCalendarQuery}
         loggedIn={loggedIn}
         dispatchActionPromise={dispatchActionPromise}
         updateCalendarQuery={callUpdateCalendarQuery}
       />
     );
   },
 );
 
 export default ConnectedCalendar;
diff --git a/web/calendar/entry.react.js b/web/calendar/entry.react.js
index 4c0fb94b2..7d60f3056 100644
--- a/web/calendar/entry.react.js
+++ b/web/calendar/entry.react.js
@@ -1,505 +1,505 @@
 // @flow
 
 import classNames from 'classnames';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   createEntryActionTypes,
   useCreateEntry,
   saveEntryActionTypes,
   useSaveEntry,
   deleteEntryActionTypes,
   useDeleteEntry,
   concurrentModificationResetActionType,
 } from 'lib/actions/entry-actions.js';
 import {
   useModalContext,
   type PushModal,
 } from 'lib/components/modal-provider.react.js';
 import { connectionSelector } from 'lib/selectors/keyserver-selectors.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { colorIsDark } from 'lib/shared/color-utils.js';
 import { entryKey } from 'lib/shared/entry-utils.js';
 import { threadHasPermission } from 'lib/shared/thread-utils.js';
 import {
   type EntryInfo,
   type CreateEntryInfo,
   type SaveEntryInfo,
   type SaveEntryResult,
   type SaveEntryPayload,
   type CreateEntryPayload,
   type DeleteEntryInfo,
   type DeleteEntryResult,
   type CalendarQuery,
 } from 'lib/types/entry-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import type { ResolvedThreadInfo } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { dateString } from 'lib/utils/date-utils.js';
 import { useResolvedThreadInfo } from 'lib/utils/entity-helpers.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import css from './calendar.css';
 import LoadingIndicator from '../loading-indicator.react.js';
 import LogInFirstModal from '../modals/account/log-in-first-modal.react.js';
 import ConcurrentModificationModal from '../modals/concurrent-modification-modal.react.js';
 import HistoryModal from '../modals/history/history-modal.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { nonThreadCalendarQuery } from '../selectors/nav-selectors.js';
 import { HistoryVector, DeleteVector } from '../vectors.react.js';
 
 type BaseProps = {
   +innerRef: (key: string, me: Entry) => void,
   +entryInfo: EntryInfo,
   +focusOnFirstEntryNewerThan: (time: number) => void,
   +tabIndex: number,
 };
 type Props = {
   ...BaseProps,
   +threadInfo: ResolvedThreadInfo,
   +loggedIn: boolean,
   +calendarQuery: () => CalendarQuery,
   +online: boolean,
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   +createEntry: (info: CreateEntryInfo) => Promise<CreateEntryPayload>,
   +saveEntry: (info: SaveEntryInfo) => Promise<SaveEntryResult>,
   +deleteEntry: (info: DeleteEntryInfo) => Promise<DeleteEntryResult>,
   +pushModal: PushModal,
   +popModal: () => void,
 };
 type State = {
   +focused: boolean,
   +loadingStatus: LoadingStatus,
   +text: string,
 };
 class Entry extends React.PureComponent<Props, State> {
   textarea: ?HTMLTextAreaElement;
   creating: boolean;
   needsUpdateAfterCreation: boolean;
   needsDeleteAfterCreation: boolean;
   nextSaveAttemptIndex: number;
   mounted: boolean;
   currentlySaving: ?string;
 
   constructor(props: Props) {
     super(props);
     this.state = {
       focused: false,
       loadingStatus: 'inactive',
       text: props.entryInfo.text,
     };
     this.creating = false;
     this.needsUpdateAfterCreation = false;
     this.needsDeleteAfterCreation = false;
     this.nextSaveAttemptIndex = 0;
   }
 
   guardedSetState(input: Partial<State>) {
     if (this.mounted) {
       this.setState(input);
     }
   }
 
   componentDidMount() {
     this.mounted = true;
     this.props.innerRef(entryKey(this.props.entryInfo), this);
     this.updateHeight();
     // Whenever a new Entry is created, focus on it
     if (!this.props.entryInfo.id) {
       this.focus();
     }
   }
 
   componentDidUpdate(prevProps: Props) {
     if (
       !this.state.focused &&
       this.props.entryInfo.text !== this.state.text &&
       this.props.entryInfo.text !== prevProps.entryInfo.text
     ) {
       this.setState({ text: this.props.entryInfo.text });
       this.currentlySaving = null;
     }
 
     if (
       this.props.online &&
       !prevProps.online &&
       this.state.loadingStatus === 'error'
     ) {
       this.save();
     }
   }
 
   focus() {
     invariant(
       this.textarea instanceof HTMLTextAreaElement,
       'textarea ref not set',
     );
     this.textarea.focus();
   }
 
   onMouseDown: (event: SyntheticEvent<HTMLDivElement>) => void = event => {
     if (this.state.focused && event.target !== this.textarea) {
       // Don't lose focus when some non-textarea part is clicked
       event.preventDefault();
     }
   };
 
   componentWillUnmount() {
     this.mounted = false;
   }
 
   updateHeight: () => void = () => {
     invariant(
       this.textarea instanceof HTMLTextAreaElement,
       'textarea ref not set',
     );
     this.textarea.style.height = 'auto';
     this.textarea.style.height = this.textarea.scrollHeight + 'px';
   };
 
   render(): React.Node {
     let actionLinks = null;
     if (this.state.focused) {
       let historyButton = null;
       if (this.props.entryInfo.id) {
         historyButton = (
           <a href="#" onClick={this.onHistory}>
             <HistoryVector className={css.history} />
             <span className={css.actionLinksText}>History</span>
           </a>
         );
       }
       const rightActionLinksClassName = `${css.rightActionLinks} ${css.actionLinksText}`;
       actionLinks = (
         <div className={css.actionLinks}>
           <a href="#" onClick={this.onDelete}>
             <DeleteVector />
             <span className={css.actionLinksText}>Delete</span>
           </a>
           {historyButton}
           <span className={rightActionLinksClassName}>
             {this.props.threadInfo.uiName}
           </span>
           <div className={css.clear}></div>
         </div>
       );
     }
 
     const darkColor = colorIsDark(this.props.threadInfo.color);
     const entryClasses = classNames({
       [css.entry]: true,
       [css.darkEntry]: darkColor,
       [css.focusedEntry]: this.state.focused,
     });
     const style = { backgroundColor: `#${this.props.threadInfo.color}` };
     const loadingIndicatorColor = darkColor ? 'white' : 'black';
     const canEditEntry = threadHasPermission(
       this.props.threadInfo,
       threadPermissions.EDIT_ENTRIES,
     );
     return (
       <div
         className={entryClasses}
         style={style}
         onMouseDown={this.onMouseDown}
       >
         <textarea
           rows="1"
           className={css.entryText}
           onChange={this.onChange}
           onKeyDown={this.onKeyDown}
           value={this.state.text}
           onFocus={this.onFocus}
           onBlur={this.onBlur}
           tabIndex={this.props.tabIndex}
           ref={this.textareaRef}
           disabled={!canEditEntry}
         />
         <LoadingIndicator
           status={this.state.loadingStatus}
           color={loadingIndicatorColor}
           loadingClassName={css.entryLoading}
           errorClassName={css.entryError}
         />
         {actionLinks}
       </div>
     );
   }
 
   textareaRef: (textarea: ?HTMLTextAreaElement) => void = textarea => {
     this.textarea = textarea;
   };
 
   onFocus: () => void = () => {
     if (!this.state.focused) {
       this.setState({ focused: true });
     }
   };
 
   onBlur: () => void = () => {
     this.setState({ focused: false });
     if (this.state.text.trim() === '') {
       this.delete();
     } else if (this.props.entryInfo.text !== this.state.text) {
       this.save();
     }
   };
 
   delete() {
     this.dispatchDelete(this.props.entryInfo.id, false);
   }
 
   save() {
     this.dispatchSave(this.props.entryInfo.id, this.state.text);
   }
 
   onChange: (event: SyntheticEvent<HTMLTextAreaElement>) => void = event => {
     if (!this.props.loggedIn) {
       this.props.pushModal(<LogInFirstModal inOrderTo="edit this calendar" />);
       return;
     }
     const target = event.target;
     invariant(target instanceof HTMLTextAreaElement, 'target not textarea');
     this.setState({ text: target.value }, this.updateHeight);
   };
 
   onKeyDown: (event: SyntheticKeyboardEvent<HTMLTextAreaElement>) => void =
     event => {
       if (event.key === 'Escape') {
         invariant(
           this.textarea instanceof HTMLTextAreaElement,
           'textarea ref not set',
         );
         this.textarea.blur();
       }
     };
 
   dispatchSave(serverID: ?string, newText: string) {
     if (this.currentlySaving === newText) {
       return;
     }
     this.currentlySaving = newText;
 
     if (newText.trim() === '') {
       // We don't save the empty string, since as soon as the element loses
       // focus it'll get deleted
       return;
     }
 
     if (!serverID) {
       if (this.creating) {
         // We need the first save call to return so we know the ID of the entry
         // we're updating, so we'll need to handle this save later
         this.needsUpdateAfterCreation = true;
         return;
       } else {
         this.creating = true;
       }
     }
 
     if (!serverID) {
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         createEntryActionTypes,
         this.createAction(newText),
       );
     } else {
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         saveEntryActionTypes,
         this.saveAction(serverID, newText),
       );
     }
   }
 
   async createAction(text: string): Promise<CreateEntryPayload> {
     const localID = this.props.entryInfo.localID;
     invariant(localID, "if there's no serverID, there should be a localID");
     const curSaveAttempt = this.nextSaveAttemptIndex++;
     this.guardedSetState({ loadingStatus: 'loading' });
     try {
       const response = await this.props.createEntry({
         text,
         timestamp: this.props.entryInfo.creationTime,
         date: dateString(
           this.props.entryInfo.year,
           this.props.entryInfo.month,
           this.props.entryInfo.day,
         ),
         threadID: this.props.entryInfo.threadID,
         localID,
         calendarQuery: this.props.calendarQuery(),
       });
       if (curSaveAttempt + 1 === this.nextSaveAttemptIndex) {
         this.guardedSetState({ loadingStatus: 'inactive' });
       }
       this.creating = false;
       if (this.needsUpdateAfterCreation) {
         this.needsUpdateAfterCreation = false;
         this.dispatchSave(response.entryID, this.state.text);
       }
       if (this.needsDeleteAfterCreation) {
         this.needsDeleteAfterCreation = false;
         this.dispatchDelete(response.entryID, false);
       }
       return response;
     } catch (e) {
       if (curSaveAttempt + 1 === this.nextSaveAttemptIndex) {
         this.guardedSetState({ loadingStatus: 'error' });
       }
       this.currentlySaving = null;
       this.creating = false;
       throw e;
     }
   }
 
   async saveAction(
     entryID: string,
     newText: string,
   ): Promise<SaveEntryPayload> {
     const curSaveAttempt = this.nextSaveAttemptIndex++;
     this.guardedSetState({ loadingStatus: 'loading' });
     try {
       const response = await this.props.saveEntry({
         entryID,
         text: newText,
         prevText: this.props.entryInfo.text,
         timestamp: Date.now(),
         calendarQuery: this.props.calendarQuery(),
       });
       if (curSaveAttempt + 1 === this.nextSaveAttemptIndex) {
         this.guardedSetState({ loadingStatus: 'inactive' });
       }
       return { ...response, threadID: this.props.entryInfo.threadID };
     } catch (e) {
       if (curSaveAttempt + 1 === this.nextSaveAttemptIndex) {
         this.guardedSetState({ loadingStatus: 'error' });
       }
       this.currentlySaving = null;
       if (e instanceof ServerError && e.message === 'concurrent_modification') {
         const onRefresh = () => {
           this.setState({ loadingStatus: 'inactive' }, this.updateHeight);
           this.props.dispatch({
             type: concurrentModificationResetActionType,
             payload: { id: entryID, dbText: e.payload?.db },
           });
           this.props.popModal();
         };
         this.props.pushModal(
           <ConcurrentModificationModal onRefresh={onRefresh} />,
         );
       }
       throw e;
     }
   }
 
   onDelete: (event: SyntheticEvent<HTMLAnchorElement>) => void = event => {
     event.preventDefault();
     if (!this.props.loggedIn) {
       this.props.pushModal(<LogInFirstModal inOrderTo="edit this calendar" />);
       return;
     }
     this.dispatchDelete(this.props.entryInfo.id, true);
   };
 
   dispatchDelete(serverID: ?string, focusOnNextEntry: boolean) {
     const { localID } = this.props.entryInfo;
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       deleteEntryActionTypes,
       this.deleteAction(serverID, focusOnNextEntry),
       undefined,
       { localID, serverID },
     );
   }
 
   async deleteAction(
     serverID: ?string,
     focusOnNextEntry: boolean,
   ): Promise<?DeleteEntryResult> {
     invariant(
       this.props.loggedIn,
       'user should be logged in if delete triggered',
     );
     if (focusOnNextEntry) {
       this.props.focusOnFirstEntryNewerThan(this.props.entryInfo.creationTime);
     }
     if (serverID) {
       return await this.props.deleteEntry({
         entryID: serverID,
         prevText: this.props.entryInfo.text,
         calendarQuery: this.props.calendarQuery(),
       });
     } else if (this.creating) {
       this.needsDeleteAfterCreation = true;
     }
     return null;
   }
 
   onHistory: (event: SyntheticEvent<HTMLAnchorElement>) => void = event => {
     event.preventDefault();
     this.props.pushModal(
       <HistoryModal
         mode="entry"
         dayString={dateString(
           this.props.entryInfo.year,
           this.props.entryInfo.month,
           this.props.entryInfo.day,
         )}
         currentEntryID={this.props.entryInfo.id}
       />,
     );
   };
 }
 
 export type InnerEntry = Entry;
 
 const ConnectedEntry: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedEntry(props) {
     const { threadID } = props.entryInfo;
     const unresolvedThreadInfo = useSelector(
       state => threadInfoSelector(state)[threadID],
     );
     const threadInfo = useResolvedThreadInfo(unresolvedThreadInfo);
     const loggedIn = useSelector(
       state =>
         !!(state.currentUserInfo && !state.currentUserInfo.anonymous && true),
     );
     const calendarQuery = useSelector(nonThreadCalendarQuery);
     const connection = useSelector(connectionSelector(ashoatKeyserverID));
     invariant(connection, 'keyserver missing from keyserverStore');
     const online = connection.status === 'connected';
     const callCreateEntry = useCreateEntry();
     const callSaveEntry = useSaveEntry();
     const callDeleteEntry = useDeleteEntry();
     const dispatchActionPromise = useDispatchActionPromise();
     const dispatch = useDispatch();
 
     const modalContext = useModalContext();
 
     return (
       <Entry
         {...props}
         threadInfo={threadInfo}
         loggedIn={loggedIn}
         calendarQuery={calendarQuery}
         online={online}
         createEntry={callCreateEntry}
         saveEntry={callSaveEntry}
         deleteEntry={callDeleteEntry}
         dispatchActionPromise={dispatchActionPromise}
         dispatch={dispatch}
         pushModal={modalContext.pushModal}
         popModal={modalContext.popModal}
       />
     );
   },
 );
 
 export default ConnectedEntry;
diff --git a/web/chat/chat-input-bar.react.js b/web/chat/chat-input-bar.react.js
index f7125ee74..5dad19284 100644
--- a/web/chat/chat-input-bar.react.js
+++ b/web/chat/chat-input-bar.react.js
@@ -1,691 +1,694 @@
 // @flow
 
 import invariant from 'invariant';
 import _difference from 'lodash/fp/difference.js';
 import * as React from 'react';
 
 import {
   joinThreadActionTypes,
   useJoinThread,
   newThreadActionTypes,
 } from 'lib/actions/thread-actions.js';
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import {
   useChatMentionContext,
   useThreadChatMentionCandidates,
 } from 'lib/hooks/chat-mention-hooks.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { userStoreMentionSearchIndex } from 'lib/selectors/user-selectors.js';
 import {
   getMentionTypeaheadUserSuggestions,
   getTypeaheadRegexMatches,
   getUserMentionsCandidates,
   getMentionTypeaheadChatSuggestions,
   type MentionTypeaheadSuggestionItem,
   type TypeaheadMatchedStrings,
 } from 'lib/shared/mention-utils.js';
 import { localIDPrefix, trimMessage } from 'lib/shared/message-utils.js';
 import {
   threadHasPermission,
   viewerIsMember,
   threadFrozenDueToViewerBlock,
   threadActualMembers,
   checkIfDefaultMembersAreVoiced,
 } from 'lib/shared/thread-utils.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import {
   type ClientThreadJoinRequest,
   type ThreadJoinPayload,
   type ThreadInfo,
 } from 'lib/types/thread-types.js';
 import { type UserInfos } from 'lib/types/user-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import css from './chat-input-bar.css';
 import TypeaheadTooltip from './typeahead-tooltip.react.js';
 import Button from '../components/button.react.js';
 import {
   type InputState,
   type PendingMultimediaUpload,
 } from '../input/input-state.js';
 import LoadingIndicator from '../loading-indicator.react.js';
 import { allowedMimeTypeString } from '../media/file-utils.js';
 import Multimedia from '../media/multimedia.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { nonThreadCalendarQuery } from '../selectors/nav-selectors.js';
 import {
   webMentionTypeaheadRegex,
   getMentionTypeaheadTooltipActions,
   getMentionTypeaheadTooltipButtons,
 } from '../utils/typeahead-utils.js';
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
   +inputState: InputState,
 };
 type Props = {
   ...BaseProps,
   +viewerID: ?string,
   +joinThreadLoadingStatus: LoadingStatus,
   +threadCreationInProgress: boolean,
   +calendarQuery: () => CalendarQuery,
   +nextLocalID: number,
   +isThreadActive: boolean,
   +userInfos: UserInfos,
   +dispatchActionPromise: DispatchActionPromise,
   +joinThread: (request: ClientThreadJoinRequest) => Promise<ThreadJoinPayload>,
   +typeaheadMatchedStrings: ?TypeaheadMatchedStrings,
   +suggestions: $ReadOnlyArray<MentionTypeaheadSuggestionItem>,
   +parentThreadInfo: ?ThreadInfo,
 };
 
 class ChatInputBar extends React.PureComponent<Props> {
   textarea: ?HTMLTextAreaElement;
   multimediaInput: ?HTMLInputElement;
 
   componentDidMount() {
     this.updateHeight();
     if (this.props.isThreadActive) {
       this.addReplyListener();
     }
   }
 
   componentWillUnmount() {
     if (this.props.isThreadActive) {
       this.removeReplyListener();
     }
   }
 
   componentDidUpdate(prevProps: Props) {
     if (this.props.isThreadActive && !prevProps.isThreadActive) {
       this.addReplyListener();
     } else if (!this.props.isThreadActive && prevProps.isThreadActive) {
       this.removeReplyListener();
     }
 
     const { inputState } = this.props;
     const prevInputState = prevProps.inputState;
     if (inputState.draft !== prevInputState.draft) {
       this.updateHeight();
     }
 
     if (
       inputState.draft !== prevInputState.draft ||
       inputState.textCursorPosition !== prevInputState.textCursorPosition
     ) {
       inputState.setTypeaheadState({
         canBeVisible: true,
       });
     }
 
     const curUploadIDs = ChatInputBar.unassignedUploadIDs(
       inputState.pendingUploads,
     );
     const prevUploadIDs = ChatInputBar.unassignedUploadIDs(
       prevInputState.pendingUploads,
     );
     const { multimediaInput, textarea } = this;
     if (
       multimediaInput &&
       _difference(prevUploadIDs)(curUploadIDs).length > 0
     ) {
       // Whenever a pending upload is removed, we reset the file
       // HTMLInputElement's value field, so that if the same upload occurs again
       // the onChange call doesn't get filtered
       multimediaInput.value = '';
     } else if (
       textarea &&
       _difference(curUploadIDs)(prevUploadIDs).length > 0
     ) {
       // Whenever a pending upload is added, we focus the textarea
       textarea.focus();
       return;
     }
 
     if (
       (this.props.threadInfo.id !== prevProps.threadInfo.id ||
         (inputState.textCursorPosition !== prevInputState.textCursorPosition &&
           this.textarea?.selectionStart === this.textarea?.selectionEnd)) &&
       this.textarea
     ) {
       this.textarea.focus();
 
       this.textarea?.setSelectionRange(
         inputState.textCursorPosition,
         inputState.textCursorPosition,
         'none',
       );
     }
   }
 
   static unassignedUploadIDs(
     pendingUploads: $ReadOnlyArray<PendingMultimediaUpload>,
   ): Array<string> {
     return pendingUploads
       .filter(
         (pendingUpload: PendingMultimediaUpload) => !pendingUpload.messageID,
       )
       .map((pendingUpload: PendingMultimediaUpload) => pendingUpload.localID);
   }
 
   updateHeight() {
     const textarea = this.textarea;
     if (textarea) {
       textarea.style.height = 'auto';
       const newHeight = Math.min(textarea.scrollHeight, 150);
       textarea.style.height = `${newHeight}px`;
     }
   }
 
   addReplyListener() {
     invariant(
       this.props.inputState,
       'inputState should be set in addReplyListener',
     );
     this.props.inputState.addReplyListener(this.focusAndUpdateText);
   }
 
   removeReplyListener() {
     invariant(
       this.props.inputState,
       'inputState should be set in removeReplyListener',
     );
     this.props.inputState.removeReplyListener(this.focusAndUpdateText);
   }
 
   render(): React.Node {
     const isMember = viewerIsMember(this.props.threadInfo);
     const canJoin = threadHasPermission(
       this.props.threadInfo,
       threadPermissions.JOIN_THREAD,
     );
 
     let joinButton = null;
     if (!isMember && canJoin && !this.props.threadCreationInProgress) {
       let buttonContent;
       if (this.props.joinThreadLoadingStatus === 'loading') {
         buttonContent = (
           <LoadingIndicator
             status={this.props.joinThreadLoadingStatus}
             size="medium"
             color="white"
           />
         );
       } else {
         buttonContent = (
           <>
             <SWMansionIcon icon="plus" size={24} />
             <p className={css.joinButtonText}>Join Chat</p>
           </>
         );
       }
       joinButton = (
         <div className={css.joinButtonContainer}>
           <Button
             variant="filled"
             buttonColor={{ backgroundColor: `#${this.props.threadInfo.color}` }}
             onClick={this.onClickJoin}
           >
             {buttonContent}
           </Button>
         </div>
       );
     }
 
     const { pendingUploads, cancelPendingUpload } = this.props.inputState;
     const multimediaPreviews = pendingUploads.map(pendingUpload => {
       const { uri, mediaType, thumbHash, dimensions } = pendingUpload;
       let mediaSource = { thumbHash, dimensions };
       if (mediaType !== 'encrypted_photo' && mediaType !== 'encrypted_video') {
         mediaSource = {
           ...mediaSource,
           type: mediaType,
           uri,
           thumbnailURI: null,
         };
       } else {
         const { encryptionKey } = pendingUpload;
         invariant(
           encryptionKey,
           'encryptionKey should be set for encrypted media',
         );
         mediaSource = {
           ...mediaSource,
           type: mediaType,
           blobURI: uri,
           encryptionKey,
           thumbnailBlobURI: null,
           thumbnailEncryptionKey: null,
         };
       }
       return (
         <Multimedia
           mediaSource={mediaSource}
           pendingUpload={pendingUpload}
           remove={cancelPendingUpload}
           multimediaCSSClass={css.multimedia}
           multimediaImageCSSClass={css.multimediaImage}
           key={pendingUpload.localID}
         />
       );
     });
     const previews =
       multimediaPreviews.length > 0 ? (
         <div className={css.previews}>{multimediaPreviews}</div>
       ) : null;
 
     let content;
     // If the thread is created by somebody else while the viewer is attempting
     // to create it, the threadInfo might be modified in-place and won't
     // list the viewer as a member, which will end up hiding the input. In
     // this case, we will assume that our creation action will get translated,
     // into a join and as long as members are voiced, we can show the input.
     const defaultMembersAreVoiced = checkIfDefaultMembersAreVoiced(
       this.props.threadInfo,
     );
 
     let sendButton;
     if (this.props.inputState.draft.length) {
       sendButton = (
         <a onClick={this.onSend} className={css.sendButton}>
           <SWMansionIcon
             icon="send-2"
             size={22}
             color={`#${this.props.threadInfo.color}`}
           />
         </a>
       );
     }
 
     if (
       threadHasPermission(this.props.threadInfo, threadPermissions.VOICED) ||
       (this.props.threadCreationInProgress && defaultMembersAreVoiced)
     ) {
       content = (
         <div className={css.inputBarWrapper}>
           <a className={css.multimediaUpload} onClick={this.onMultimediaClick}>
             <input
               type="file"
               onChange={this.onMultimediaFileChange}
               ref={this.multimediaInputRef}
               accept={allowedMimeTypeString}
               multiple
             />
             <SWMansionIcon
               icon="image-1"
               size={22}
               color={`#${this.props.threadInfo.color}`}
               disableFill
             />
           </a>
           <div className={css.inputBarTextInput}>
             <textarea
               rows="1"
               placeholder="Type your message"
               value={this.props.inputState.draft}
               onChange={this.onChangeMessageText}
               onKeyDown={this.onKeyDown}
               onClick={this.onClickTextarea}
               onSelect={this.onSelectTextarea}
               ref={this.textareaRef}
               autoFocus
             />
           </div>
           {sendButton}
         </div>
       );
     } else if (
       threadFrozenDueToViewerBlock(
         this.props.threadInfo,
         this.props.viewerID,
         this.props.userInfos,
       ) &&
       threadActualMembers(this.props.threadInfo.members).length === 2
     ) {
       content = (
         <span className={css.explanation}>
           You can&rsquo;t send messages to a user that you&rsquo;ve blocked.
         </span>
       );
     } else if (isMember) {
       content = (
         <span className={css.explanation}>
           You don&rsquo;t have permission to send messages.
         </span>
       );
     } else if (defaultMembersAreVoiced && canJoin) {
       content = null;
     } else {
       content = (
         <span className={css.explanation}>
           You don&rsquo;t have permission to send messages.
         </span>
       );
     }
 
     let typeaheadTooltip;
     if (
       this.props.inputState.typeaheadState.canBeVisible &&
       this.props.suggestions.length > 0 &&
       this.props.typeaheadMatchedStrings &&
       this.textarea
     ) {
       typeaheadTooltip = (
         <TypeaheadTooltip
           inputState={this.props.inputState}
           textarea={this.textarea}
           matchedStrings={this.props.typeaheadMatchedStrings}
           suggestions={this.props.suggestions}
           typeaheadTooltipActionsGetter={getMentionTypeaheadTooltipActions}
           typeaheadTooltipButtonsGetter={getMentionTypeaheadTooltipButtons}
         />
       );
     }
 
     return (
       <div className={css.inputBar}>
         {joinButton}
         {previews}
         {content}
         {typeaheadTooltip}
       </div>
     );
   }
 
   textareaRef = (textarea: ?HTMLTextAreaElement) => {
     this.textarea = textarea;
     if (textarea) {
       textarea.focus();
     }
   };
 
   onChangeMessageText = (event: SyntheticEvent<HTMLTextAreaElement>) => {
     this.props.inputState.setDraft(event.currentTarget.value);
     this.props.inputState.setTextCursorPosition(
       event.currentTarget.selectionStart,
     );
   };
 
   onClickTextarea = (event: SyntheticEvent<HTMLTextAreaElement>) => {
     this.props.inputState.setTextCursorPosition(
       event.currentTarget.selectionStart,
     );
   };
 
   onSelectTextarea = (event: SyntheticEvent<HTMLTextAreaElement>) => {
     this.props.inputState.setTextCursorPosition(
       event.currentTarget.selectionStart,
     );
   };
 
   focusAndUpdateText = (text: string) => {
     // We need to call focus() first on Safari, otherwise the cursor
     // ends up at the start instead of the end for some reason
     const { textarea } = this;
     invariant(textarea, 'textarea should be set');
     textarea.focus();
 
     // We reset the textarea to an empty string at the start so that the cursor
     // always ends up at the end, even if the text doesn't actually change
     textarea.value = '';
     const currentText = this.props.inputState.draft;
     if (!currentText.startsWith(text)) {
       const prependedText = text.concat(currentText);
       this.props.inputState.setDraft(prependedText);
       textarea.value = prependedText;
     } else {
       textarea.value = currentText;
     }
 
     // The above strategies make sure the cursor is at the end,
     // but we also need to make sure that we're scrolled to the bottom
     textarea.scrollTop = textarea.scrollHeight;
   };
 
   onKeyDown = (event: SyntheticKeyboardEvent<HTMLTextAreaElement>) => {
     const { accept, close, moveChoiceUp, moveChoiceDown } =
       this.props.inputState.typeaheadState;
 
     const actions = {
       Enter: accept,
       Tab: accept,
       ArrowDown: moveChoiceDown,
       ArrowUp: moveChoiceUp,
       Escape: close,
     };
 
     if (
       this.props.inputState.typeaheadState.canBeVisible &&
       actions[event.key]
     ) {
       event.preventDefault();
       actions[event.key]();
     } else if (event.key === 'Enter' && !event.shiftKey) {
       event.preventDefault();
       this.send();
     }
   };
 
   onSend = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     this.send();
   };
 
   send() {
     let { nextLocalID } = this.props;
 
     const text = trimMessage(this.props.inputState.draft);
     if (text) {
       this.dispatchTextMessageAction(text, nextLocalID);
       nextLocalID++;
     }
     if (this.props.inputState.pendingUploads.length > 0) {
       this.props.inputState.createMultimediaMessage(
         nextLocalID,
         this.props.threadInfo,
       );
     }
   }
 
   dispatchTextMessageAction(text: string, nextLocalID: number) {
     this.props.inputState.setDraft('');
 
     const localID = `${localIDPrefix}${nextLocalID}`;
     const creatorID = this.props.viewerID;
     invariant(creatorID, 'should have viewer ID in order to send a message');
 
-    this.props.inputState.sendTextMessage(
+    void this.props.inputState.sendTextMessage(
       {
         type: messageTypes.TEXT,
         localID,
         threadID: this.props.threadInfo.id,
         text,
         creatorID,
         time: Date.now(),
       },
       this.props.threadInfo,
       this.props.parentThreadInfo,
     );
   }
 
   multimediaInputRef = (multimediaInput: ?HTMLInputElement) => {
     this.multimediaInput = multimediaInput;
   };
 
   onMultimediaClick = () => {
     if (this.multimediaInput) {
       this.multimediaInput.click();
     }
   };
 
   onMultimediaFileChange = async (
     event: SyntheticInputEvent<HTMLInputElement>,
   ) => {
     const result = await this.props.inputState.appendFiles(
       this.props.threadInfo,
       [...event.target.files],
     );
     if (!result && this.multimediaInput) {
       this.multimediaInput.value = '';
     }
   };
 
   onClickJoin = () => {
-    this.props.dispatchActionPromise(joinThreadActionTypes, this.joinAction());
+    void this.props.dispatchActionPromise(
+      joinThreadActionTypes,
+      this.joinAction(),
+    );
   };
 
   async joinAction(): Promise<ThreadJoinPayload> {
     const query = this.props.calendarQuery();
     return await this.props.joinThread({
       threadID: this.props.threadInfo.id,
       calendarQuery: {
         startDate: query.startDate,
         endDate: query.endDate,
         filters: [
           ...query.filters,
           { type: 'threads', threadIDs: [this.props.threadInfo.id] },
         ],
       },
     });
   }
 }
 
 const joinThreadLoadingStatusSelector = createLoadingStatusSelector(
   joinThreadActionTypes,
 );
 const createThreadLoadingStatusSelector =
   createLoadingStatusSelector(newThreadActionTypes);
 
 const ConnectedChatInputBar: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedChatInputBar(props) {
     const viewerID = useSelector(
       state => state.currentUserInfo && state.currentUserInfo.id,
     );
     const nextLocalID = useSelector(state => state.nextLocalID);
     const isThreadActive = useSelector(
       state => props.threadInfo.id === state.navInfo.activeChatThreadID,
     );
     const userInfos = useSelector(state => state.userStore.userInfos);
     const joinThreadLoadingStatus = useSelector(
       joinThreadLoadingStatusSelector,
     );
     const createThreadLoadingStatus = useSelector(
       createThreadLoadingStatusSelector,
     );
     const threadCreationInProgress = createThreadLoadingStatus === 'loading';
     const calendarQuery = useSelector(nonThreadCalendarQuery);
     const dispatchActionPromise = useDispatchActionPromise();
     const callJoinThread = useJoinThread();
     const userSearchIndex = useSelector(userStoreMentionSearchIndex);
     const { getChatMentionSearchIndex } = useChatMentionContext();
     const chatMentionSearchIndex = getChatMentionSearchIndex(props.threadInfo);
 
     const { parentThreadID } = props.threadInfo;
     const parentThreadInfo = useSelector(state =>
       parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
     );
 
     const userMentionsCandidates = getUserMentionsCandidates(
       props.threadInfo,
       parentThreadInfo,
     );
 
     const chatMentionCandidates = useThreadChatMentionCandidates(
       props.threadInfo,
     );
 
     const typeaheadRegexMatches = React.useMemo(
       () =>
         getTypeaheadRegexMatches(
           props.inputState.draft,
           {
             start: props.inputState.textCursorPosition,
             end: props.inputState.textCursorPosition,
           },
           webMentionTypeaheadRegex,
         ),
       [props.inputState.textCursorPosition, props.inputState.draft],
     );
 
     const typeaheadMatchedStrings: ?TypeaheadMatchedStrings = React.useMemo(
       () =>
         typeaheadRegexMatches !== null
           ? {
               textBeforeAtSymbol:
                 typeaheadRegexMatches.groups?.textPrefix ?? '',
               query: typeaheadRegexMatches.groups?.mentionText ?? '',
             }
           : null,
       [typeaheadRegexMatches],
     );
 
     React.useEffect(() => {
       if (props.inputState.typeaheadState.keepUpdatingThreadMembers) {
         const setter = props.inputState.setTypeaheadState;
         setter({
           frozenUserMentionsCandidates: userMentionsCandidates,
           frozenChatMentionsCandidates: chatMentionCandidates,
         });
       }
     }, [
       userMentionsCandidates,
       props.inputState.setTypeaheadState,
       props.inputState.typeaheadState.keepUpdatingThreadMembers,
       chatMentionCandidates,
     ]);
 
     const suggestions = React.useMemo(() => {
       if (!typeaheadMatchedStrings) {
         return ([]: $ReadOnlyArray<MentionTypeaheadSuggestionItem>);
       }
       const suggestedUsers = getMentionTypeaheadUserSuggestions(
         userSearchIndex,
         props.inputState.typeaheadState.frozenUserMentionsCandidates,
         viewerID,
         typeaheadMatchedStrings.query,
       );
       const suggestedChats = getMentionTypeaheadChatSuggestions(
         chatMentionSearchIndex,
         props.inputState.typeaheadState.frozenChatMentionsCandidates,
         typeaheadMatchedStrings.query,
       );
       return ([
         ...suggestedUsers,
         ...suggestedChats,
       ]: $ReadOnlyArray<MentionTypeaheadSuggestionItem>);
     }, [
       typeaheadMatchedStrings,
       userSearchIndex,
       props.inputState.typeaheadState.frozenUserMentionsCandidates,
       props.inputState.typeaheadState.frozenChatMentionsCandidates,
       viewerID,
       chatMentionSearchIndex,
     ]);
 
     return (
       <ChatInputBar
         {...props}
         viewerID={viewerID}
         joinThreadLoadingStatus={joinThreadLoadingStatus}
         threadCreationInProgress={threadCreationInProgress}
         calendarQuery={calendarQuery}
         nextLocalID={nextLocalID}
         isThreadActive={isThreadActive}
         userInfos={userInfos}
         dispatchActionPromise={dispatchActionPromise}
         joinThread={callJoinThread}
         typeaheadMatchedStrings={typeaheadMatchedStrings}
         suggestions={suggestions}
         parentThreadInfo={parentThreadInfo}
       />
     );
   });
 
 export default ConnectedChatInputBar;
diff --git a/web/chat/chat-message-list-container.react.js b/web/chat/chat-message-list-container.react.js
index 149a9b3fe..3570169c9 100644
--- a/web/chat/chat-message-list-container.react.js
+++ b/web/chat/chat-message-list-container.react.js
@@ -1,160 +1,160 @@
 // @flow
 
 import classNames from 'classnames';
 import invariant from 'invariant';
 import * as React from 'react';
 import { useDrop } from 'react-dnd';
 import { NativeTypes } from 'react-dnd-html5-backend';
 
 import { useWatchThread, threadIsPending } from 'lib/shared/thread-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import ChatInputBar from './chat-input-bar.react.js';
 import css from './chat-message-list-container.css';
 import ChatMessageList from './chat-message-list.react.js';
 import ChatThreadComposer from './chat-thread-composer.react.js';
 import ThreadTopBar from './thread-top-bar.react.js';
 import { InputStateContext } from '../input/input-state.js';
 import { updateNavInfoActionType } from '../redux/action-types.js';
 import {
   useThreadInfoForPossiblyPendingThread,
   useInfosForPendingThread,
 } from '../utils/thread-utils.js';
 
 type Props = {
   +activeChatThreadID: ?string,
 };
 
 function ChatMessageListContainer(props: Props): React.Node {
   const { activeChatThreadID } = props;
   const { isChatCreation, selectedUserInfos, otherUserInfos } =
     useInfosForPendingThread();
 
   const threadInfo = useThreadInfoForPossiblyPendingThread(activeChatThreadID);
   invariant(threadInfo, 'ThreadInfo should be set');
 
   const dispatch = useDispatch();
 
   React.useEffect(() => {
     if (isChatCreation && activeChatThreadID !== threadInfo.id) {
       let payload = {
         activeChatThreadID: threadInfo.id,
       };
       if (threadIsPending(threadInfo.id)) {
         payload = {
           ...payload,
           pendingThread: threadInfo,
         };
       }
       dispatch({
         type: updateNavInfoActionType,
         payload,
       });
     }
   }, [activeChatThreadID, dispatch, isChatCreation, threadInfo]);
 
   const inputState = React.useContext(InputStateContext);
   invariant(inputState, 'InputState should be set');
   const [{ isActive }, connectDropTarget] = useDrop({
     accept: NativeTypes.FILE,
     drop: item => {
       const { files } = item;
       if (inputState && files.length > 0) {
-        inputState.appendFiles(threadInfo, files);
+        void inputState.appendFiles(threadInfo, files);
       }
     },
     collect: monitor => ({
       isActive: monitor.isOver() && monitor.canDrop(),
     }),
   });
 
   useWatchThread(threadInfo);
 
   const containerStyle = classNames({
     [css.container]: true,
     [css.activeContainer]: isActive,
   });
 
   const containerRef = React.useRef<?HTMLDivElement>();
 
   const onPaste = React.useCallback(
     (e: ClipboardEvent) => {
       if (!inputState) {
         return;
       }
       const { clipboardData } = e;
       if (!clipboardData) {
         return;
       }
       const { files } = clipboardData;
       if (files.length === 0) {
         return;
       }
       e.preventDefault();
-      inputState.appendFiles(threadInfo, [...files]);
+      void inputState.appendFiles(threadInfo, [...files]);
     },
     [inputState, threadInfo],
   );
 
   React.useEffect(() => {
     const currentContainerRef = containerRef.current;
     if (!currentContainerRef) {
       return undefined;
     }
     currentContainerRef.addEventListener('paste', onPaste);
     return () => {
       currentContainerRef.removeEventListener('paste', onPaste);
     };
   }, [onPaste]);
 
   const content = React.useMemo(() => {
     const topBar = <ThreadTopBar threadInfo={threadInfo} />;
     const messageListAndInput = (
       <>
         <ChatMessageList threadInfo={threadInfo} />
         <ChatInputBar threadInfo={threadInfo} inputState={inputState} />
       </>
     );
     if (!isChatCreation) {
       return (
         <>
           {topBar}
           {messageListAndInput}
         </>
       );
     }
     const chatUserSelection = (
       <ChatThreadComposer
         userInfoInputArray={selectedUserInfos}
         otherUserInfos={otherUserInfos}
         threadID={threadInfo.id}
         inputState={inputState}
       />
     );
 
     if (!selectedUserInfos.length) {
       return chatUserSelection;
     }
     return (
       <>
         {topBar}
         {chatUserSelection}
         {messageListAndInput}
       </>
     );
   }, [
     inputState,
     isChatCreation,
     otherUserInfos,
     selectedUserInfos,
     threadInfo,
   ]);
 
   return connectDropTarget(
     <div className={containerStyle} ref={containerRef}>
       {content}
     </div>,
   );
 }
 
 export default ChatMessageListContainer;
diff --git a/web/chat/chat-message-list.react.js b/web/chat/chat-message-list.react.js
index 80dc8d910..cd56ace6d 100644
--- a/web/chat/chat-message-list.react.js
+++ b/web/chat/chat-message-list.react.js
@@ -1,486 +1,486 @@
 // @flow
 
 import classNames from 'classnames';
 import { detect as detectBrowser } from 'detect-browser';
 import invariant from 'invariant';
 import _debounce from 'lodash/debounce.js';
 import * as React from 'react';
 
 import {
   fetchMessagesBeforeCursorActionTypes,
   useFetchMessagesBeforeCursor,
   fetchMostRecentMessagesActionTypes,
   useFetchMostRecentMessages,
 } from 'lib/actions/message-actions.js';
 import type {
   FetchMostRecentMessagesInput,
   FetchMessagesBeforeCursorInput,
 } from 'lib/actions/message-actions.js';
 import { useThreadChatMentionCandidates } from 'lib/hooks/chat-mention-hooks.js';
 import { useOldestMessageServerID } from 'lib/hooks/message-hooks.js';
 import { registerFetchKey } from 'lib/reducers/loading-reducer.js';
 import {
   type ChatMessageItem,
   useMessageListData,
 } from 'lib/selectors/chat-selectors.js';
 import { messageKey } from 'lib/shared/message-utils.js';
 import { threadIsPending } from 'lib/shared/thread-utils.js';
 import type { FetchMessageInfosPayload } from 'lib/types/message-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
 import { editBoxHeight, defaultMaxTextAreaHeight } from './chat-constants.js';
 import css from './chat-message-list.css';
 import type { ScrollToMessageCallback } from './edit-message-provider.js';
 import { useEditModalContext } from './edit-message-provider.js';
 import { MessageListContext } from './message-list-types.js';
 import Message from './message.react.js';
 import RelationshipPrompt from './relationship-prompt/relationship-prompt.js';
 import { useTooltipContext } from './tooltip-provider.js';
 import { type InputState, InputStateContext } from '../input/input-state.js';
 import LoadingIndicator from '../loading-indicator.react.js';
 import { useTextMessageRulesFunc } from '../markdown/rules.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 const browser = detectBrowser();
 const supportsReverseFlex =
   !browser || browser.name !== 'firefox' || parseInt(browser.version) >= 81;
 
 // Margin between the top of the maximum height edit box
 // and the top of the container
 const editBoxTopMargin = 10;
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
 };
 
 type Props = {
   ...BaseProps,
   +activeChatThreadID: ?string,
   +messageListData: ?$ReadOnlyArray<ChatMessageItem>,
   +startReached: boolean,
   +dispatchActionPromise: DispatchActionPromise,
   +fetchMessagesBeforeCursor: (
     input: FetchMessagesBeforeCursorInput,
   ) => Promise<FetchMessageInfosPayload>,
   +fetchMostRecentMessages: (
     input: FetchMostRecentMessagesInput,
   ) => Promise<FetchMessageInfosPayload>,
   +inputState: ?InputState,
   +clearTooltip: () => mixed,
   +oldestMessageServerID: ?string,
   +isEditState: boolean,
   +addScrollToMessageListener: ScrollToMessageCallback => mixed,
   +removeScrollToMessageListener: ScrollToMessageCallback => mixed,
 };
 type Snapshot = {
   +scrollTop: number,
   +scrollHeight: number,
 };
 
 type State = {
   +scrollingEndCallback: ?() => mixed,
 };
 
 class ChatMessageList extends React.PureComponent<Props, State> {
   container: ?HTMLDivElement;
   messageContainer: ?HTMLDivElement;
   loadingFromScroll = false;
 
   constructor(props: Props) {
     super(props);
     this.state = {
       scrollingEndCallback: null,
     };
   }
 
   componentDidMount() {
     this.scrollToBottom();
     this.props.addScrollToMessageListener(this.scrollToMessage);
   }
 
   componentWillUnmount() {
     this.props.removeScrollToMessageListener(this.scrollToMessage);
   }
 
   getSnapshotBeforeUpdate(prevProps: Props): ?Snapshot {
     if (
       ChatMessageList.hasNewMessage(this.props, prevProps) &&
       this.messageContainer
     ) {
       const { scrollTop, scrollHeight } = this.messageContainer;
       return { scrollTop, scrollHeight };
     }
     return null;
   }
 
   static hasNewMessage(props: Props, prevProps: Props): boolean {
     const { messageListData } = props;
     if (!messageListData || messageListData.length === 0) {
       return false;
     }
     const prevMessageListData = prevProps.messageListData;
     if (!prevMessageListData || prevMessageListData.length === 0) {
       return true;
     }
     return (
       ChatMessageList.keyExtractor(prevMessageListData[0]) !==
       ChatMessageList.keyExtractor(messageListData[0])
     );
   }
 
   componentDidUpdate(prevProps: Props, prevState: State, snapshot: ?Snapshot) {
     const { messageListData } = this.props;
     const prevMessageListData = prevProps.messageListData;
 
     const { messageContainer } = this;
     if (messageContainer && prevMessageListData !== messageListData) {
       this.onScroll();
     }
 
     // We'll scroll to the bottom if the user was already scrolled to the bottom
     // before the new message, or if the new message was composed locally
     const hasNewMessage = ChatMessageList.hasNewMessage(this.props, prevProps);
     if (
       this.props.activeChatThreadID !== prevProps.activeChatThreadID ||
       (hasNewMessage &&
         messageListData &&
         messageListData[0].itemType === 'message' &&
         messageListData[0].messageInfo.localID) ||
       (hasNewMessage &&
         snapshot &&
         Math.abs(snapshot.scrollTop) <= 1 &&
         !this.props.isEditState)
     ) {
       this.scrollToBottom();
     } else if (hasNewMessage && messageContainer && snapshot) {
       const { scrollTop, scrollHeight } = messageContainer;
       if (
         scrollHeight > snapshot.scrollHeight &&
         scrollTop === snapshot.scrollTop
       ) {
         const newHeight = scrollHeight - snapshot.scrollHeight;
         const newScrollTop = Math.abs(scrollTop) + newHeight;
         if (supportsReverseFlex) {
           messageContainer.scrollTop = -1 * newScrollTop;
         } else {
           messageContainer.scrollTop = newScrollTop;
         }
       }
     }
   }
 
   scrollToBottom() {
     if (this.messageContainer) {
       this.messageContainer.scrollTop = 0;
     }
   }
 
   static keyExtractor(item: ChatMessageItem): string {
     if (item.itemType === 'loader') {
       return 'loader';
     }
     return messageKey(item.messageInfo);
   }
 
   renderItem = (item: ChatMessageItem): React.Node => {
     if (item.itemType === 'loader') {
       return (
         <div key="loader" className={css.loading}>
           <LoadingIndicator status="loading" size="large" color="white" />
         </div>
       );
     }
     const { threadInfo } = this.props;
     invariant(threadInfo, 'ThreadInfo should be set if messageListData is');
     return (
       <Message
         item={item}
         threadInfo={threadInfo}
         shouldDisplayPinIndicator={true}
         key={ChatMessageList.keyExtractor(item)}
       />
     );
   };
 
   scrollingEndCallbackWrapper = (
     composedMessageID: string,
     callback: (maxHeight: number) => mixed,
   ): (() => mixed) => {
     return () => {
       const maxHeight = this.getMaxEditTextAreaHeight(composedMessageID);
       callback(maxHeight);
     };
   };
 
   scrollToMessage = (
     composedMessageID: string,
     callback: (maxHeight: number) => mixed,
   ) => {
     const element = document.getElementById(composedMessageID);
     if (!element) {
       return;
     }
     const scrollingEndCallback = this.scrollingEndCallbackWrapper(
       composedMessageID,
       callback,
     );
     if (!this.willMessageEditWindowOverflow(composedMessageID)) {
       scrollingEndCallback();
       return;
     }
     this.setState(
       {
         scrollingEndCallback,
       },
       () => {
         element.scrollIntoView({ behavior: 'smooth', block: 'center' });
         // It covers the case when browser decide not to scroll to the message
         // because it's already in the view.
         // In this case, the 'scroll' event won't be triggered,
         // so we need to call the callback manually.
         this.debounceEditModeAfterScrollToMessage();
       },
     );
   };
 
   getMaxEditTextAreaHeight = (composedMessageID: string): number => {
     const { messageContainer } = this;
     if (!messageContainer) {
       return defaultMaxTextAreaHeight;
     }
     const messageElement = document.getElementById(composedMessageID);
     if (!messageElement) {
       console.log(`couldn't find the message element`);
       return defaultMaxTextAreaHeight;
     }
 
     const msgPos = messageElement.getBoundingClientRect();
     const containerPos = messageContainer.getBoundingClientRect();
 
     const messageBottom = msgPos.bottom;
     const containerTop = containerPos.top;
 
     const maxHeight =
       messageBottom - containerTop - editBoxHeight - editBoxTopMargin;
 
     return maxHeight;
   };
 
   willMessageEditWindowOverflow(composedMessageID: string): boolean {
     const { messageContainer } = this;
     if (!messageContainer) {
       return false;
     }
     const messageElement = document.getElementById(composedMessageID);
     if (!messageElement) {
       console.log(`couldn't find the message element`);
       return false;
     }
 
     const msgPos = messageElement.getBoundingClientRect();
     const containerPos = messageContainer.getBoundingClientRect();
     const containerTop = containerPos.top;
     const containerBottom = containerPos.bottom;
 
     const availableTextAreaHeight =
       (containerBottom - containerTop) / 2 - editBoxHeight;
     const messageHeight = msgPos.height;
     const expectedMinimumHeight = Math.min(
       defaultMaxTextAreaHeight,
       availableTextAreaHeight,
     );
     const offset = Math.max(
       0,
       expectedMinimumHeight + editBoxHeight + editBoxTopMargin - messageHeight,
     );
 
     const messageTop = msgPos.top - offset;
     const messageBottom = msgPos.bottom;
 
     return messageBottom > containerBottom || messageTop < containerTop;
   }
 
   render(): React.Node {
     const { messageListData, threadInfo, inputState, isEditState } = this.props;
     if (!messageListData) {
       return <div className={css.container} />;
     }
     invariant(inputState, 'InputState should be set');
     const messages = messageListData.map(this.renderItem);
 
     let relationshipPrompt = null;
     if (threadInfo.type === threadTypes.PERSONAL) {
       relationshipPrompt = <RelationshipPrompt threadInfo={threadInfo} />;
     }
 
     const messageContainerStyle = classNames({
       [css.disableAnchor]:
         this.state.scrollingEndCallback !== null || isEditState,
       [css.messageContainer]: true,
       [css.mirroredMessageContainer]: !supportsReverseFlex,
     });
     return (
       <div className={css.outerMessageContainer}>
         {relationshipPrompt}
         <div className={messageContainerStyle} ref={this.messageContainerRef}>
           {messages}
         </div>
       </div>
     );
   }
 
   messageContainerRef = (messageContainer: ?HTMLDivElement) => {
     this.messageContainer = messageContainer;
     // In case we already have all the most recent messages,
     // but they're not enough
-    this.possiblyLoadMoreMessages();
+    void this.possiblyLoadMoreMessages();
     if (messageContainer) {
       messageContainer.addEventListener('scroll', this.onScroll);
     }
   };
 
   onScroll = () => {
     if (!this.messageContainer) {
       return;
     }
     this.props.clearTooltip();
-    this.possiblyLoadMoreMessages();
+    void this.possiblyLoadMoreMessages();
     this.debounceEditModeAfterScrollToMessage();
   };
 
   debounceEditModeAfterScrollToMessage: () => void = _debounce(() => {
     if (this.state.scrollingEndCallback) {
       this.state.scrollingEndCallback();
     }
     this.setState({ scrollingEndCallback: null });
   }, 100);
 
   async possiblyLoadMoreMessages() {
     if (!this.messageContainer) {
       return;
     }
 
     const { scrollTop, scrollHeight, clientHeight } = this.messageContainer;
     if (
       this.props.startReached ||
       Math.abs(scrollTop) + clientHeight + 55 < scrollHeight
     ) {
       return;
     }
 
     if (this.loadingFromScroll) {
       return;
     }
     this.loadingFromScroll = true;
 
     const threadID = this.props.activeChatThreadID;
     invariant(threadID, 'should be set');
 
     try {
       const { oldestMessageServerID } = this.props;
       if (oldestMessageServerID) {
         await this.props.dispatchActionPromise(
           fetchMessagesBeforeCursorActionTypes,
           this.props.fetchMessagesBeforeCursor({
             threadID,
             beforeMessageID: oldestMessageServerID,
           }),
         );
       } else {
         await this.props.dispatchActionPromise(
           fetchMostRecentMessagesActionTypes,
           this.props.fetchMostRecentMessages({ threadID }),
         );
       }
     } finally {
       this.loadingFromScroll = false;
     }
   }
 }
 
 registerFetchKey(fetchMessagesBeforeCursorActionTypes);
 registerFetchKey(fetchMostRecentMessagesActionTypes);
 const ConnectedChatMessageList: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedChatMessageList(
     props: BaseProps,
   ): React.Node {
     const { threadInfo } = props;
     const messageListData = useMessageListData({
       threadInfo,
       searching: false,
       userInfoInputArray: [],
     });
 
     const startReached = !!useSelector(state => {
       const activeID = threadInfo.id;
       if (!activeID) {
         return null;
       }
 
       if (threadIsPending(activeID)) {
         return true;
       }
 
       const threadMessageInfo = state.messageStore.threads[activeID];
       if (!threadMessageInfo) {
         return null;
       }
       return threadMessageInfo.startReached;
     });
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callFetchMessagesBeforeCursor = useFetchMessagesBeforeCursor();
     const callFetchMostRecentMessages = useFetchMostRecentMessages();
 
     const inputState = React.useContext(InputStateContext);
 
     const { clearTooltip } = useTooltipContext();
 
     const chatMentionCandidates = useThreadChatMentionCandidates(threadInfo);
     const getTextMessageMarkdownRules = useTextMessageRulesFunc(
       threadInfo,
       chatMentionCandidates,
     );
     const messageListContext = React.useMemo(() => {
       if (!getTextMessageMarkdownRules) {
         return undefined;
       }
       return { getTextMessageMarkdownRules };
     }, [getTextMessageMarkdownRules]);
 
     const oldestMessageServerID = useOldestMessageServerID(threadInfo.id);
 
     const {
       editState,
       addScrollToMessageListener,
       removeScrollToMessageListener,
     } = useEditModalContext();
     const isEditState = editState !== null;
 
     return (
       <MessageListContext.Provider value={messageListContext}>
         <ChatMessageList
           activeChatThreadID={threadInfo.id}
           threadInfo={threadInfo}
           messageListData={messageListData}
           startReached={startReached}
           inputState={inputState}
           dispatchActionPromise={dispatchActionPromise}
           fetchMessagesBeforeCursor={callFetchMessagesBeforeCursor}
           fetchMostRecentMessages={callFetchMostRecentMessages}
           clearTooltip={clearTooltip}
           oldestMessageServerID={oldestMessageServerID}
           isEditState={isEditState}
           addScrollToMessageListener={addScrollToMessageListener}
           removeScrollToMessageListener={removeScrollToMessageListener}
         />
       </MessageListContext.Provider>
     );
   });
 
 export default ConnectedChatMessageList;
diff --git a/web/chat/failed-send.react.js b/web/chat/failed-send.react.js
index 8b1df99c6..b573dabec 100644
--- a/web/chat/failed-send.react.js
+++ b/web/chat/failed-send.react.js
@@ -1,162 +1,162 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { type ChatMessageInfoItem } from 'lib/selectors/chat-selectors.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { messageID } from 'lib/shared/message-utils.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
   type RawComposableMessageInfo,
   assertComposableMessageType,
 } from 'lib/types/message-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 
 import css from './chat-message-list.css';
 import multimediaMessageSendFailed from './multimedia-message-send-failed.js';
 import textMessageSendFailed from './text-message-send-failed.js';
 import Button from '../components/button.react.js';
 import { type InputState, InputStateContext } from '../input/input-state.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 type BaseProps = {
   +item: ChatMessageInfoItem,
   +threadInfo: ThreadInfo,
 };
 type Props = {
   ...BaseProps,
   +rawMessageInfo: RawComposableMessageInfo,
   +inputState: ?InputState,
   +parentThreadInfo: ?ThreadInfo,
 };
 class FailedSend extends React.PureComponent<Props> {
   retryingText = false;
   retryingMedia = false;
 
   componentDidUpdate(prevProps: Props) {
     if (
       (this.props.rawMessageInfo.type === messageTypes.IMAGES ||
         this.props.rawMessageInfo.type === messageTypes.MULTIMEDIA) &&
       (prevProps.rawMessageInfo.type === messageTypes.IMAGES ||
         prevProps.rawMessageInfo.type === messageTypes.MULTIMEDIA)
     ) {
       const { inputState } = this.props;
       const prevInputState = prevProps.inputState;
       invariant(
         inputState && prevInputState,
         'inputState should be set in FailedSend',
       );
       const isFailed = multimediaMessageSendFailed(this.props.item, inputState);
       const wasFailed = multimediaMessageSendFailed(
         prevProps.item,
         prevInputState,
       );
       const isDone =
         this.props.item.messageInfo.id !== null &&
         this.props.item.messageInfo.id !== undefined;
       const wasDone =
         prevProps.item.messageInfo.id !== null &&
         prevProps.item.messageInfo.id !== undefined;
       if ((isFailed && !wasFailed) || (isDone && !wasDone)) {
         this.retryingMedia = false;
       }
     } else if (
       this.props.rawMessageInfo.type === messageTypes.TEXT &&
       prevProps.rawMessageInfo.type === messageTypes.TEXT
     ) {
       const isFailed = textMessageSendFailed(this.props.item);
       const wasFailed = textMessageSendFailed(prevProps.item);
       const isDone =
         this.props.item.messageInfo.id !== null &&
         this.props.item.messageInfo.id !== undefined;
       const wasDone =
         prevProps.item.messageInfo.id !== null &&
         prevProps.item.messageInfo.id !== undefined;
       if ((isFailed && !wasFailed) || (isDone && !wasDone)) {
         this.retryingText = false;
       }
     }
   }
 
   render(): React.Node {
     return (
       <div className={css.failedSend}>
         <span className={css.deliveryFailed}>Delivery failed.</span>
         <Button
           variant="text"
           buttonColor={{
             color: `#${this.props.threadInfo.color}`,
           }}
           onClick={this.retrySend}
         >
           <span className={css.retryButtonText}>Retry?</span>
         </Button>
       </div>
     );
   }
 
   retrySend = () => {
     const { inputState } = this.props;
     invariant(inputState, 'inputState should be set in FailedSend');
 
     const { rawMessageInfo } = this.props;
     if (rawMessageInfo.type === messageTypes.TEXT) {
       if (this.retryingText) {
         return;
       }
       this.retryingText = true;
-      inputState.sendTextMessage(
+      void inputState.sendTextMessage(
         {
           ...rawMessageInfo,
           time: Date.now(),
         },
         this.props.threadInfo,
         this.props.parentThreadInfo,
       );
     } else if (
       rawMessageInfo.type === messageTypes.IMAGES ||
       rawMessageInfo.type === messageTypes.MULTIMEDIA
     ) {
       const { localID } = rawMessageInfo;
       invariant(localID, 'failed RawMessageInfo should have localID');
       if (this.retryingMedia) {
         return;
       }
       this.retryingMedia = true;
       inputState.retryMultimediaMessage(localID, this.props.threadInfo);
     }
   };
 }
 
 const ConnectedFailedSend: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedFailedSend(props) {
     const { messageInfo } = props.item;
     assertComposableMessageType(messageInfo.type);
     const id = messageID(messageInfo);
     const rawMessageInfo = useSelector(
       state => state.messageStore.messages[id],
     );
     assertComposableMessageType(rawMessageInfo.type);
     invariant(
       rawMessageInfo.type === messageTypes.TEXT ||
         rawMessageInfo.type === messageTypes.IMAGES ||
         rawMessageInfo.type === messageTypes.MULTIMEDIA,
       'FailedSend should only be used for composable message types',
     );
     const inputState = React.useContext(InputStateContext);
     const { parentThreadID } = props.threadInfo;
     const parentThreadInfo = useSelector(state =>
       parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
     );
     return (
       <FailedSend
         {...props}
         rawMessageInfo={rawMessageInfo}
         inputState={inputState}
         parentThreadInfo={parentThreadInfo}
       />
     );
   });
 
 export default ConnectedFailedSend;
diff --git a/web/chat/reaction-message-utils.js b/web/chat/reaction-message-utils.js
index 904b64b8c..c41a7ba8d 100644
--- a/web/chat/reaction-message-utils.js
+++ b/web/chat/reaction-message-utils.js
@@ -1,219 +1,219 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   useSendReactionMessage,
   sendReactionMessageActionTypes,
 } from 'lib/actions/message-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import type { ReactionInfo } from 'lib/selectors/chat-selectors';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import type { RawReactionMessageInfo } from 'lib/types/messages/reaction.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import type { CallServerEndpointResultInfoInterface } from 'lib/utils/call-server-endpoint.js';
 import { cloneError } from 'lib/utils/errors.js';
 
 import Alert from '../modals/alert.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import {
   type TooltipSize,
   type TooltipPositionStyle,
 } from '../utils/tooltip-utils.js';
 import { getAppContainerPositionInfo } from '../utils/window-utils.js';
 
 function useSendReaction(
   messageID: ?string,
   localID: string,
   threadID: string,
   reactions: ReactionInfo,
 ): (reaction: string) => mixed {
   const { pushModal } = useModalContext();
 
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
 
   const callSendReactionMessage = useSendReactionMessage();
   const dispatchActionPromise = useDispatchActionPromise();
 
   return React.useCallback(
     reaction => {
       if (!messageID) {
         return;
       }
 
       invariant(viewerID, 'viewerID should be set');
 
       const viewerReacted = reactions[reaction]
         ? reactions[reaction].viewerReacted
         : false;
       const action = viewerReacted ? 'remove_reaction' : 'add_reaction';
 
       const reactionMessagePromise = (async () => {
         try {
           const result = await callSendReactionMessage({
             threadID,
             localID,
             targetMessageID: messageID,
             reaction,
             action,
           });
           const serverID: string = result.id;
           const time: number = result.time;
           const interfaceInfo: CallServerEndpointResultInfoInterface =
             result.interface;
           return {
             localID,
             serverID,
             threadID,
             time,
             interface: interfaceInfo,
           };
         } catch (e) {
           pushModal(
             <Alert title="Couldn’t send the reaction">
               Please try again later
             </Alert>,
           );
 
           const copy = cloneError(e);
           copy.localID = localID;
           copy.threadID = threadID;
           throw copy;
         }
       })();
 
       const startingPayload: RawReactionMessageInfo = {
         type: messageTypes.REACTION,
         threadID,
         localID,
         creatorID: viewerID,
         time: Date.now(),
         targetMessageID: messageID,
         reaction,
         action,
       };
 
-      dispatchActionPromise(
+      void dispatchActionPromise(
         sendReactionMessageActionTypes,
         reactionMessagePromise,
         undefined,
         startingPayload,
       );
     },
     [
       messageID,
       viewerID,
       reactions,
       threadID,
       localID,
       dispatchActionPromise,
       callSendReactionMessage,
       pushModal,
     ],
   );
 }
 
 type EmojiKeyboardPosition = {
   +bottom: number,
   +left: number,
 };
 
 function getEmojiKeyboardPosition(
   emojiKeyboard: ?HTMLDivElement,
   tooltipPositionStyle: TooltipPositionStyle,
   tooltipSize: TooltipSize,
 ): ?EmojiKeyboardPosition {
   const { alignment, anchorPoint } = tooltipPositionStyle;
   const tooltipAnchorX = anchorPoint.x;
   const tooltipAnchorY = anchorPoint.y;
 
   const tooltipWidth = tooltipSize.width;
   const tooltipHeight = tooltipSize.height;
 
   const appContainerPositionInfo = getAppContainerPositionInfo();
 
   if (!appContainerPositionInfo) {
     return null;
   }
 
   let emojiKeyboardWidth = 352;
   let emojiKeyboardHeight = 435;
 
   if (emojiKeyboard) {
     const { width, height } = emojiKeyboard.getBoundingClientRect();
     emojiKeyboardWidth = width;
     emojiKeyboardHeight = height;
   }
 
   const {
     top: containerTop,
     left: containerLeft,
     right: containerRight,
     bottom: containerBottom,
   } = appContainerPositionInfo;
 
   const padding = 16;
 
   const canBeDisplayedOnRight =
     tooltipAnchorX + tooltipWidth + emojiKeyboardWidth <= containerRight;
 
   const canBeDisplayedOnLeft =
     tooltipAnchorX - emojiKeyboardWidth >= containerLeft;
 
   const canBeDisplayedOnTop =
     tooltipAnchorY - emojiKeyboardHeight - padding >= containerTop;
 
   const canBeDisplayedOnBottom =
     tooltipAnchorY + tooltipHeight + emojiKeyboardHeight + padding <=
     containerBottom;
 
   const emojiKeyboardOverflowTop =
     containerTop - (tooltipAnchorY + tooltipHeight - emojiKeyboardHeight);
 
   const emojiKeyboardOverflowTopCorrection =
     emojiKeyboardOverflowTop > 0 ? -emojiKeyboardOverflowTop - padding : 0;
 
   const emojiKeyboardOverflowRight =
     tooltipAnchorX + emojiKeyboardWidth - containerRight;
 
   const emojiKeyboardOverflowRightCorrection =
     emojiKeyboardOverflowRight > 0 ? -emojiKeyboardOverflowRight - padding : 0;
 
   if (alignment === 'left' && canBeDisplayedOnRight) {
     return {
       left: tooltipWidth,
       bottom: emojiKeyboardOverflowTopCorrection,
     };
   }
 
   if (alignment === 'right' && canBeDisplayedOnLeft) {
     return {
       left: -emojiKeyboardWidth,
       bottom: emojiKeyboardOverflowTopCorrection,
     };
   }
 
   if (canBeDisplayedOnTop) {
     return {
       bottom: tooltipHeight + padding,
       left: emojiKeyboardOverflowRightCorrection,
     };
   }
 
   if (canBeDisplayedOnBottom) {
     return {
       bottom: -emojiKeyboardHeight - padding,
       left: emojiKeyboardOverflowRightCorrection,
     };
   }
 
   return {
     left: alignment === 'left' ? -emojiKeyboardWidth : tooltipWidth,
     bottom: emojiKeyboardOverflowTopCorrection,
   };
 }
 
 export { useSendReaction, getEmojiKeyboardPosition };
diff --git a/web/chat/thread-menu.react.js b/web/chat/thread-menu.react.js
index 413ef5584..1a5e7edd4 100644
--- a/web/chat/thread-menu.react.js
+++ b/web/chat/thread-menu.react.js
@@ -1,314 +1,314 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useLeaveThread,
   leaveThreadActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import { usePromoteSidebar } from 'lib/hooks/promote-sidebar.react.js';
 import { childThreadInfos } from 'lib/selectors/thread-selectors.js';
 import {
   threadHasPermission,
   viewerIsMember,
   threadIsChannel,
 } from 'lib/shared/thread-utils.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { type ThreadInfo } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import css from './thread-menu.css';
 import MenuItem from '../components/menu-item.react.js';
 import Menu from '../components/menu.react.js';
 import SidebarPromoteModal from '../modals/chat/sidebar-promote-modal.react.js';
 import ConfirmLeaveThreadModal from '../modals/threads/confirm-leave-thread-modal.react.js';
 import ComposeSubchannelModal from '../modals/threads/create/compose-subchannel-modal.react.js';
 import ThreadSettingsMediaGalleryModal from '../modals/threads/gallery/thread-settings-media-gallery.react.js';
 import ThreadMembersModal from '../modals/threads/members/members-modal.react.js';
 import ThreadNotificationsModal from '../modals/threads/notifications/notifications-modal.react.js';
 import ThreadSettingsModal from '../modals/threads/settings/thread-settings-modal.react.js';
 import SidebarsModal from '../modals/threads/sidebars/sidebars-modal.react.js';
 import SubchannelsModal from '../modals/threads/subchannels/subchannels-modal.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 type ThreadMenuProps = {
   +threadInfo: ThreadInfo,
 };
 
 function ThreadMenu(props: ThreadMenuProps): React.Node {
   const { pushModal, popModal } = useModalContext();
   const { threadInfo } = props;
   const { onPromoteSidebar, canPromoteSidebar } = usePromoteSidebar(threadInfo);
 
   const onClickSettings = React.useCallback(
     () => pushModal(<ThreadSettingsModal threadID={threadInfo.id} />),
     [pushModal, threadInfo.id],
   );
 
   const settingsItem = React.useMemo(() => {
     return (
       <MenuItem
         key="settings"
         text="Settings"
         icon="settings"
         onClick={onClickSettings}
       />
     );
   }, [onClickSettings]);
 
   const onClickMembers = React.useCallback(
     () =>
       pushModal(
         <ThreadMembersModal threadID={threadInfo.id} onClose={popModal} />,
       ),
     [popModal, pushModal, threadInfo.id],
   );
   const membersItem = React.useMemo(() => {
     if (threadInfo.type === threadTypes.PERSONAL) {
       return null;
     }
     return (
       <MenuItem
         key="members"
         text="Members"
         icon="users"
         onClick={onClickMembers}
       />
     );
   }, [onClickMembers, threadInfo.type]);
 
   const onClickThreadMediaGallery = React.useCallback(
     () =>
       pushModal(
         <ThreadSettingsMediaGalleryModal
           onClose={popModal}
           parentThreadInfo={threadInfo}
           limit={36}
           activeTab="All"
         />,
       ),
     [popModal, pushModal, threadInfo],
   );
 
   const threadMediaGalleryItem = React.useMemo(
     () => (
       <MenuItem
         key="threadMediaGallery"
         text="Media"
         icon="image-1"
         onClick={onClickThreadMediaGallery}
       />
     ),
     [onClickThreadMediaGallery],
   );
 
   const childThreads = useSelector(
     state => childThreadInfos(state)[threadInfo.id],
   );
 
   const hasSidebars = React.useMemo(() => {
     return childThreads?.some(
       childThreadInfo => childThreadInfo.type === threadTypes.SIDEBAR,
     );
   }, [childThreads]);
 
   const onClickSidebars = React.useCallback(
     () =>
       pushModal(<SidebarsModal threadID={threadInfo.id} onClose={popModal} />),
     [popModal, pushModal, threadInfo.id],
   );
 
   const sidebarItem = React.useMemo(() => {
     if (!hasSidebars) {
       return null;
     }
     return (
       <MenuItem
         key="sidebars"
         text="Threads"
         icon="arrow-right"
         onClick={onClickSidebars}
       />
     );
   }, [hasSidebars, onClickSidebars]);
 
   const canCreateSubchannels = React.useMemo(
     () => threadHasPermission(threadInfo, threadPermissions.CREATE_SUBCHANNELS),
     [threadInfo],
   );
 
   const hasSubchannels = React.useMemo(() => {
     return !!childThreads?.some(threadIsChannel);
   }, [childThreads]);
 
   const onClickViewSubchannels = React.useCallback(
     () =>
       pushModal(
         <SubchannelsModal threadID={threadInfo.id} onClose={popModal} />,
       ),
     [popModal, pushModal, threadInfo.id],
   );
 
   const viewSubchannelsItem = React.useMemo(() => {
     if (!hasSubchannels) {
       return null;
     }
     return (
       <MenuItem
         key="subchannels"
         text="Subchannels"
         icon="message-square"
         onClick={onClickViewSubchannels}
       />
     );
   }, [hasSubchannels, onClickViewSubchannels]);
 
   const onClickCreateSubchannel = React.useCallback(
     () =>
       pushModal(
         <ComposeSubchannelModal
           parentThreadInfo={threadInfo}
           onClose={popModal}
         />,
       ),
     [popModal, pushModal, threadInfo],
   );
 
   const createSubchannelsItem = React.useMemo(() => {
     if (!canCreateSubchannels) {
       return null;
     }
     return (
       <MenuItem
         key="newSubchannel"
         text="Create new subchannel"
         icon="plus-circle"
         onClick={onClickCreateSubchannel}
       />
     );
   }, [canCreateSubchannels, onClickCreateSubchannel]);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callLeaveThread = useLeaveThread();
 
   const onConfirmLeaveThread = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       leaveThreadActionTypes,
       callLeaveThread({ threadID: threadInfo.id }),
     );
     popModal();
   }, [callLeaveThread, popModal, dispatchActionPromise, threadInfo.id]);
 
   const onClickLeaveThread = React.useCallback(
     () =>
       pushModal(
         <ConfirmLeaveThreadModal
           threadInfo={threadInfo}
           onClose={popModal}
           onConfirm={onConfirmLeaveThread}
         />,
       ),
     [popModal, onConfirmLeaveThread, pushModal, threadInfo],
   );
 
   const leaveThreadItem = React.useMemo(() => {
     const canLeaveThread = threadHasPermission(
       threadInfo,
       threadPermissions.LEAVE_THREAD,
     );
     if (!viewerIsMember(threadInfo) || !canLeaveThread) {
       return null;
     }
     return (
       <MenuItem
         key="leave"
         text="Leave chat"
         icon="logout"
         dangerous
         onClick={onClickLeaveThread}
       />
     );
   }, [onClickLeaveThread, threadInfo]);
 
   const onClickPromoteSidebarToThread = React.useCallback(
     () =>
       pushModal(
         <SidebarPromoteModal
           threadInfo={threadInfo}
           onClose={popModal}
           onConfirm={onPromoteSidebar}
         />,
       ),
     [pushModal, threadInfo, popModal, onPromoteSidebar],
   );
 
   const promoteSidebar = React.useMemo(() => {
     return (
       <MenuItem
         key="promote"
         text="Promote to channel"
         icon="message-square-lines"
         onClick={onClickPromoteSidebarToThread}
       />
     );
   }, [onClickPromoteSidebarToThread]);
 
   const onClickNotifications = React.useCallback(() => {
     pushModal(
       <ThreadNotificationsModal threadID={threadInfo.id} onClose={popModal} />,
     );
   }, [popModal, pushModal, threadInfo.id]);
 
   const notificationsItem = React.useMemo(() => {
     if (!viewerIsMember(threadInfo)) {
       return null;
     }
     return (
       <MenuItem
         key="notifications"
         text="Notifications"
         icon="bell"
         onClick={onClickNotifications}
       />
     );
   }, [onClickNotifications, threadInfo]);
 
   const menuItems = React.useMemo(() => {
     const separator = <hr key="separator" className={css.separator} />;
 
     const items = [
       settingsItem,
       notificationsItem,
       membersItem,
       threadMediaGalleryItem,
       sidebarItem,
       viewSubchannelsItem,
       createSubchannelsItem,
       leaveThreadItem && separator,
       canPromoteSidebar && promoteSidebar,
       leaveThreadItem,
     ];
     return items.filter(Boolean);
   }, [
     settingsItem,
     notificationsItem,
     membersItem,
     threadMediaGalleryItem,
     sidebarItem,
     viewSubchannelsItem,
     promoteSidebar,
     createSubchannelsItem,
     leaveThreadItem,
     canPromoteSidebar,
   ]);
   const icon = React.useMemo(
     () => <SWMansionIcon icon="menu-vertical" size={20} />,
     [],
   );
   return <Menu icon={icon}>{menuItems}</Menu>;
 }
 
 export default ThreadMenu;
diff --git a/web/database/database-module-provider.js b/web/database/database-module-provider.js
index 61d973c27..1adb67fde 100644
--- a/web/database/database-module-provider.js
+++ b/web/database/database-module-provider.js
@@ -1,160 +1,160 @@
 // @flow
 
 import invariant from 'invariant';
 import localforage from 'localforage';
 
 import {
   DATABASE_WORKER_PATH,
   WORKERS_MODULES_DIR_PATH,
   SQLITE_ENCRYPTION_KEY,
 } from './utils/constants.js';
 import { isDesktopSafari, isSQLiteSupported } from './utils/db-utils.js';
 import WorkerConnectionProxy from './utils/WorkerConnectionProxy.js';
 import {
   exportKeyToJWK,
   generateCryptoKey,
 } from '../crypto/aes-gcm-crypto-utils.js';
 import {
   workerRequestMessageTypes,
   type WorkerRequestMessage,
   type WorkerResponseMessage,
 } from '../types/worker-types.js';
 
 declare var baseURL: string;
 declare var commQueryExecutorFilename: string;
 const databaseStatuses = Object.freeze({
   notRunning: 'NOT_RUNNING',
   initSuccess: 'INIT_SUCCESS',
   initInProgress: 'INIT_IN_PROGRESS',
   initError: 'INIT_ERROR',
 });
 
 type DatabaseStatus =
   | { +type: 'NOT_RUNNING' | 'INIT_SUCCESS' | 'INIT_ERROR' }
   | { +type: 'INIT_IN_PROGRESS', +initPromise: Promise<void> };
 
 type InitOptions = { +clearDatabase: boolean };
 
 class DatabaseModule {
   worker: ?SharedWorker;
   workerProxy: ?WorkerConnectionProxy;
   status: DatabaseStatus = { type: databaseStatuses.notRunning };
 
   async init({ clearDatabase }: InitOptions): Promise<void> {
     if (!isSQLiteSupported()) {
       console.warn('SQLite is not supported');
       this.status = { type: databaseStatuses.initError };
       return;
     }
 
     if (clearDatabase && this.status.type === databaseStatuses.initSuccess) {
       console.info('Clearing sensitive data');
       invariant(this.workerProxy, 'Worker proxy should exist');
       await this.workerProxy.scheduleOnWorker({
         type: workerRequestMessageTypes.CLEAR_SENSITIVE_DATA,
       });
       this.status = { type: databaseStatuses.notRunning };
     }
 
     if (this.status.type === databaseStatuses.initInProgress) {
       await this.status.initPromise;
       return;
     }
 
     if (
       this.status.type === databaseStatuses.initSuccess ||
       this.status.type === databaseStatuses.initError
     ) {
       return;
     }
 
     this.worker = new SharedWorker(DATABASE_WORKER_PATH);
     this.worker.onerror = console.error;
     this.workerProxy = new WorkerConnectionProxy(
       this.worker.port,
       console.error,
     );
 
     const origin = window.location.origin;
 
     const initPromise = (async () => {
       try {
         let encryptionKey = null;
         if (isDesktopSafari) {
           encryptionKey = await getSafariEncryptionKey();
         }
         invariant(this.workerProxy, 'Worker proxy should exist');
         await this.workerProxy.scheduleOnWorker({
           type: workerRequestMessageTypes.INIT,
           databaseModuleFilePath: `${origin}${baseURL}${WORKERS_MODULES_DIR_PATH}`,
           encryptionKey,
           commQueryExecutorFilename,
         });
         this.status = { type: databaseStatuses.initSuccess };
         console.info('Database initialization success');
       } catch (error) {
         this.status = { type: databaseStatuses.initError };
         console.error(`Database initialization failure`, error);
       }
     })();
 
     this.status = { type: databaseStatuses.initInProgress, initPromise };
 
     await initPromise;
   }
 
   async isDatabaseSupported(): Promise<boolean> {
     if (this.status.type === databaseStatuses.initInProgress) {
       await this.status.initPromise;
     }
     return this.status.type === databaseStatuses.initSuccess;
   }
 
   async schedule(
     payload: WorkerRequestMessage,
   ): Promise<?WorkerResponseMessage> {
     if (this.status.type === databaseStatuses.notRunning) {
       throw new Error('Database not running');
     }
 
     if (this.status.type === databaseStatuses.initInProgress) {
       await this.status.initPromise;
     }
 
     if (this.status.type === databaseStatuses.initError) {
       throw new Error('Database could not be initialized');
     }
 
     invariant(this.workerProxy, 'Worker proxy should exist');
     return this.workerProxy.scheduleOnWorker(payload);
   }
 }
 
 async function getSafariEncryptionKey(): Promise<SubtleCrypto$JsonWebKey> {
   const encryptionKey = await localforage.getItem<CryptoKey>(
     SQLITE_ENCRYPTION_KEY,
   );
   if (encryptionKey) {
     return await exportKeyToJWK(encryptionKey);
   }
   const newEncryptionKey = await generateCryptoKey({
     extractable: true,
   });
   await localforage.setItem(SQLITE_ENCRYPTION_KEY, newEncryptionKey);
   return await exportKeyToJWK(newEncryptionKey);
 }
 
 let databaseModule: ?DatabaseModule = null;
 async function getDatabaseModule(): Promise<DatabaseModule> {
   if (databaseModule) {
     return databaseModule;
   }
   const newModule = new DatabaseModule();
   databaseModule = newModule;
   await newModule.init({ clearDatabase: false });
   return newModule;
 }
 // Start initializing the database immediately
-getDatabaseModule();
+void getDatabaseModule();
 
 export { getDatabaseModule };
diff --git a/web/database/sqlite-data-handler.js b/web/database/sqlite-data-handler.js
index 46b42eb62..f6d6590d1 100644
--- a/web/database/sqlite-data-handler.js
+++ b/web/database/sqlite-data-handler.js
@@ -1,66 +1,66 @@
 // @flow
 
 import * as React from 'react';
 
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import { getDatabaseModule } from './database-module-provider.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { workerRequestMessageTypes } from '../types/worker-types.js';
 
 function SQLiteDataHandler(): React.Node {
   const dispatch = useDispatch();
   const rehydrateConcluded = useSelector(
     state => !!(state._persist && state._persist.rehydrated),
   );
   const currentLoggedInUserID = useSelector(state =>
     state.currentUserInfo?.anonymous ? undefined : state.currentUserInfo?.id,
   );
 
   const handleSensitiveData = React.useCallback(async () => {
     const databaseModule = await getDatabaseModule();
     try {
       const currentUserData = await databaseModule.schedule({
         type: workerRequestMessageTypes.GET_CURRENT_USER_ID,
       });
       const currentDBUserID = currentUserData?.userID;
 
       if (currentDBUserID === currentLoggedInUserID) {
         return;
       }
 
       if (currentDBUserID) {
         await databaseModule.init({ clearDatabase: true });
       }
       if (currentLoggedInUserID) {
         await databaseModule.schedule({
           type: workerRequestMessageTypes.SET_CURRENT_USER_ID,
           userID: currentLoggedInUserID,
         });
       }
     } catch (error) {
       console.error(error);
       throw error;
     }
   }, [currentLoggedInUserID]);
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       const databaseModule = await getDatabaseModule();
 
       if (!rehydrateConcluded) {
         return;
       }
 
       const isSupported = await databaseModule.isDatabaseSupported();
       if (!isSupported) {
         return;
       }
       await handleSensitiveData();
     })();
   }, [dispatch, handleSensitiveData, rehydrateConcluded]);
 
   return null;
 }
 
 export { SQLiteDataHandler };
diff --git a/web/database/worker/db-worker.js b/web/database/worker/db-worker.js
index 98a301cff..6fabea20f 100644
--- a/web/database/worker/db-worker.js
+++ b/web/database/worker/db-worker.js
@@ -1,263 +1,263 @@
 // @flow
 
 import localforage from 'localforage';
 
 import {
   getClientStore,
   processDBStoreOperations,
 } from './process-operations.js';
 import {
   decryptData,
   encryptData,
   generateCryptoKey,
   importJWKKey,
   type EncryptedData,
 } from '../../crypto/aes-gcm-crypto-utils.js';
 import {
   type SharedWorkerMessageEvent,
   type WorkerRequestMessage,
   type WorkerResponseMessage,
   workerRequestMessageTypes,
   workerResponseMessageTypes,
   type WorkerRequestProxyMessage,
   workerWriteRequests,
 } from '../../types/worker-types.js';
 import { getDatabaseModule } from '../db-module.js';
 import { type EmscriptenModule } from '../types/module.js';
 import { type SQLiteQueryExecutor } from '../types/sqlite-query-executor.js';
 import {
   COMM_SQLITE_DATABASE_PATH,
   CURRENT_USER_ID_KEY,
   localforageConfig,
   SQLITE_CONTENT,
   SQLITE_ENCRYPTION_KEY,
 } from '../utils/constants.js';
 import {
   clearSensitiveData,
   exportDatabaseContent,
   importDatabaseContent,
 } from '../utils/db-utils.js';
 
 localforage.config(localforageConfig);
 
 let encryptionKey: ?CryptoKey = null;
 
 let sqliteQueryExecutor: ?SQLiteQueryExecutor = null;
 let dbModule: ?EmscriptenModule = null;
 
 let persistNeeded: boolean = false;
 let persistInProgress: boolean = false;
 
 async function initDatabase(
   databaseModuleFilePath: string,
   commQueryExecutorFilename: ?string,
   encryptionKeyJWK?: ?SubtleCrypto$JsonWebKey,
 ) {
   const newModule = getDatabaseModule(
     commQueryExecutorFilename,
     databaseModuleFilePath,
   );
   dbModule = newModule;
 
   try {
     const result = newModule.CommQueryExecutor.testDBOperation();
     console.log(result);
   } catch (e) {
     console.error(e);
   }
 
   if (encryptionKeyJWK) {
     encryptionKey = await importJWKKey(encryptionKeyJWK);
   } else {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
     if (!encryptionKey) {
       const cryptoKey = await generateCryptoKey({ extractable: false });
       await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     }
   }
 
   const encryptedContent = await localforage.getItem<EncryptedData>(
     SQLITE_CONTENT,
   );
 
   let dbContent = null;
   try {
     if (encryptionKey && encryptedContent) {
       dbContent = await decryptData(encryptedContent, encryptionKey);
     }
   } catch (e) {
     console.error('Error while decrypting content, clearing database content');
     await localforage.removeItem(SQLITE_CONTENT);
   }
 
   if (dbContent) {
     importDatabaseContent(dbContent, newModule, COMM_SQLITE_DATABASE_PATH);
 
     console.info(
       'Database exists and is properly encrypted, using persisted data',
     );
   } else {
     console.info('Creating fresh database');
   }
   sqliteQueryExecutor = new newModule.SQLiteQueryExecutor(
     COMM_SQLITE_DATABASE_PATH,
   );
 }
 
 async function persist() {
   persistInProgress = true;
   const module = dbModule;
   if (!sqliteQueryExecutor || !module) {
     persistInProgress = false;
     throw new Error(
       'Database not initialized while persisting database content',
     );
   }
 
   if (!encryptionKey) {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
   }
 
   while (persistNeeded) {
     persistNeeded = false;
     const dbData = exportDatabaseContent(module, COMM_SQLITE_DATABASE_PATH);
     if (!encryptionKey) {
       persistInProgress = false;
       throw new Error('Encryption key is missing');
     }
     const encryptedData = await encryptData(dbData, encryptionKey);
     await localforage.setItem(SQLITE_CONTENT, encryptedData);
   }
   persistInProgress = false;
 }
 
 async function processAppRequest(
   message: WorkerRequestMessage,
 ): Promise<?WorkerResponseMessage> {
   // non-database operations
   if (message.type === workerRequestMessageTypes.PING) {
     return {
       type: workerResponseMessageTypes.PONG,
       text: 'PONG',
     };
   } else if (
     message.type === workerRequestMessageTypes.GENERATE_DATABASE_ENCRYPTION_KEY
   ) {
     const cryptoKey = await generateCryptoKey({ extractable: false });
     await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     return undefined;
   }
 
   // database operations
   if (message.type === workerRequestMessageTypes.INIT) {
     await initDatabase(
       message.databaseModuleFilePath,
       message.commQueryExecutorFilename,
       message.encryptionKey,
     );
     return undefined;
   } else if (message.type === workerRequestMessageTypes.CLEAR_SENSITIVE_DATA) {
     encryptionKey = null;
     await localforage.clear();
     if (dbModule && sqliteQueryExecutor) {
       clearSensitiveData(
         dbModule,
         COMM_SQLITE_DATABASE_PATH,
         sqliteQueryExecutor,
       );
     }
     sqliteQueryExecutor = null;
     return undefined;
   }
 
   if (!sqliteQueryExecutor) {
     throw new Error(
       `Database not initialized, unable to process request type: ${message.type}`,
     );
   }
 
   // read-only operations
   if (message.type === workerRequestMessageTypes.GET_CLIENT_STORE) {
     return {
       type: workerResponseMessageTypes.CLIENT_STORE,
       store: getClientStore(sqliteQueryExecutor),
     };
   } else if (message.type === workerRequestMessageTypes.GET_CURRENT_USER_ID) {
     return {
       type: workerResponseMessageTypes.GET_CURRENT_USER_ID,
       userID: sqliteQueryExecutor.getMetadata(CURRENT_USER_ID_KEY),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_PERSIST_STORAGE_ITEM
   ) {
     return {
       type: workerResponseMessageTypes.GET_PERSIST_STORAGE_ITEM,
       item: sqliteQueryExecutor.getPersistStorageItem(message.key),
     };
   }
 
   // write operations
   if (!workerWriteRequests.includes(message.type)) {
     throw new Error('Request type not supported');
   }
   if (!sqliteQueryExecutor) {
     throw new Error(
       `Database not initialized, unable to process request type: ${message.type}`,
     );
   }
 
   if (message.type === workerRequestMessageTypes.PROCESS_STORE_OPERATIONS) {
     processDBStoreOperations(sqliteQueryExecutor, message.storeOperations);
   } else if (message.type === workerRequestMessageTypes.SET_CURRENT_USER_ID) {
     sqliteQueryExecutor.setMetadata(CURRENT_USER_ID_KEY, message.userID);
   } else if (
     message.type === workerRequestMessageTypes.SET_PERSIST_STORAGE_ITEM
   ) {
     sqliteQueryExecutor.setPersistStorageItem(message.key, message.item);
   } else if (
     message.type === workerRequestMessageTypes.REMOVE_PERSIST_STORAGE_ITEM
   ) {
     sqliteQueryExecutor.removePersistStorageItem(message.key);
   }
 
   persistNeeded = true;
   if (!persistInProgress) {
-    persist();
+    void persist();
   }
 
   return undefined;
 }
 
 function connectHandler(event: SharedWorkerMessageEvent) {
   if (!event.ports.length) {
     return;
   }
   const port: MessagePort = event.ports[0];
   console.log('Web database worker alive!');
 
   port.onmessage = async function (messageEvent: MessageEvent) {
     const data: WorkerRequestProxyMessage = (messageEvent.data: any);
     const { id, message } = data;
 
     if (!id) {
       port.postMessage({
         error: 'Request without identifier',
       });
     }
 
     try {
       const result = await processAppRequest(message);
       port.postMessage({
         id,
         message: result,
       });
     } catch (e) {
       port.postMessage({
         id,
         error: e.message,
       });
     }
   };
 }
 
 self.addEventListener('connect', connectHandler);
diff --git a/web/input/input-state-container.react.js b/web/input/input-state-container.react.js
index 751ecafff..3d72cf0c1 100644
--- a/web/input/input-state-container.react.js
+++ b/web/input/input-state-container.react.js
@@ -1,1707 +1,1707 @@
 // @flow
 
 import invariant from 'invariant';
 import _groupBy from 'lodash/fp/groupBy.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import _omit from 'lodash/fp/omit.js';
 import _partition from 'lodash/fp/partition.js';
 import _sortBy from 'lodash/fp/sortBy.js';
 import _memoize from 'lodash/memoize.js';
 import * as React from 'react';
 import { createSelector } from 'reselect';
 
 import {
   createLocalMessageActionType,
   sendMultimediaMessageActionTypes,
   useLegacySendMultimediaMessage,
   sendTextMessageActionTypes,
   useSendTextMessage,
 } from 'lib/actions/message-actions.js';
 import type {
   LegacySendMultimediaMessageInput,
   SendTextMessageInput,
 } from 'lib/actions/message-actions.js';
 import { queueReportsActionType } from 'lib/actions/report-actions.js';
 import { useNewThread } from 'lib/actions/thread-actions.js';
 import {
   uploadMultimedia,
   updateMultimediaMessageMediaActionType,
   useDeleteUpload,
   useBlobServiceUpload,
   type MultimediaUploadCallbacks,
   type MultimediaUploadExtras,
   type BlobServiceUploadAction,
   type DeleteUploadInput,
 } from 'lib/actions/upload-actions.js';
 import {
   useModalContext,
   type PushModal,
 } from 'lib/components/modal-provider.react.js';
 import blobService from 'lib/facts/blob-service.js';
 import commStaffCommunity from 'lib/facts/comm-staff-community.js';
 import { getNextLocalUploadID } from 'lib/media/media-utils.js';
 import { pendingToRealizedThreadIDsSelector } from 'lib/selectors/thread-selectors.js';
 import {
   createMediaMessageInfo,
   localIDPrefix,
   useMessageCreationSideEffectsFunc,
 } from 'lib/shared/message-utils.js';
 import type { CreationSideEffectsFunc } from 'lib/shared/messages/message-spec.js';
 import {
   createRealThreadFromPendingThread,
   draftKeyFromThreadID,
   threadIsPending,
   threadIsPendingSidebar,
   patchThreadInfoToIncludeMentionedMembersOfParent,
   threadInfoInsideCommunity,
 } from 'lib/shared/thread-utils.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import type {
   UploadMultimediaResult,
   MediaMissionStep,
   MediaMissionFailure,
   MediaMissionResult,
   MediaMission,
 } from 'lib/types/media-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
   type RawMessageInfo,
   type RawMultimediaMessageInfo,
   type SendMessageResult,
   type SendMessagePayload,
 } from 'lib/types/message-types.js';
 import type { RawImagesMessageInfo } from 'lib/types/messages/images.js';
 import type { RawMediaMessageInfo } from 'lib/types/messages/media.js';
 import type { RawTextMessageInfo } from 'lib/types/messages/text.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { reportTypes } from 'lib/types/report-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import {
   type ClientNewThreadRequest,
   type NewThreadResult,
   type ThreadInfo,
 } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import {
   makeBlobServiceEndpointURL,
   isBlobServiceURI,
   blobHashFromBlobServiceURI,
 } from 'lib/utils/blob-service.js';
 import { getConfig } from 'lib/utils/config.js';
 import { getMessageForException, cloneError } from 'lib/utils/errors.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { generateReportID } from 'lib/utils/report-utils.js';
 
 import {
   type PendingMultimediaUpload,
   type TypeaheadState,
   InputStateContext,
   type BaseInputState,
   type TypeaheadInputState,
   type InputState,
 } from './input-state.js';
 import { encryptFile } from '../media/encryption-utils.js';
 import { generateThumbHash } from '../media/image-utils.js';
 import {
   preloadMediaResource,
   validateFile,
   preloadImage,
 } from '../media/media-utils.js';
 import InvalidUploadModal from '../modals/chat/invalid-upload.react.js';
 import { updateNavInfoActionType } from '../redux/action-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { nonThreadCalendarQuery } from '../selectors/nav-selectors.js';
 
 type CombinedInputState = {
   +inputBaseState: BaseInputState,
   +typeaheadState: TypeaheadInputState,
 };
 
 type BaseProps = {
   +children: React.Node,
 };
 type Props = {
   ...BaseProps,
   +activeChatThreadID: ?string,
   +drafts: { +[key: string]: string },
   +viewerID: ?string,
   +messageStoreMessages: { +[id: string]: RawMessageInfo },
   +pendingRealizedThreadIDs: $ReadOnlyMap<string, string>,
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   +calendarQuery: () => CalendarQuery,
   +uploadMultimedia: (
     multimedia: Object,
     extras: MultimediaUploadExtras,
     callbacks: MultimediaUploadCallbacks,
   ) => Promise<UploadMultimediaResult>,
   +blobServiceUpload: BlobServiceUploadAction,
   +deleteUpload: (input: DeleteUploadInput) => Promise<void>,
   +sendMultimediaMessage: (
     input: LegacySendMultimediaMessageInput,
   ) => Promise<SendMessageResult>,
   +sendTextMessage: (input: SendTextMessageInput) => Promise<SendMessageResult>,
   +newThread: (request: ClientNewThreadRequest) => Promise<NewThreadResult>,
   +pushModal: PushModal,
   +sendCallbacks: $ReadOnlyArray<() => mixed>,
   +registerSendCallback: (() => mixed) => void,
   +unregisterSendCallback: (() => mixed) => void,
   +textMessageCreationSideEffectsFunc: CreationSideEffectsFunc<RawTextMessageInfo>,
 };
 type WritableState = {
   pendingUploads: {
     [threadID: string]: { [localUploadID: string]: PendingMultimediaUpload },
   },
   textCursorPositions: { [threadID: string]: number },
   typeaheadState: TypeaheadState,
 };
 type State = $ReadOnly<WritableState>;
 
 type PropsAndState = {
   ...Props,
   ...State,
 };
 class InputStateContainer extends React.PureComponent<Props, State> {
   state: State = {
     pendingUploads: {},
     textCursorPositions: {},
     typeaheadState: {
       canBeVisible: false,
       keepUpdatingThreadMembers: true,
       frozenUserMentionsCandidates: [],
       frozenChatMentionsCandidates: {},
       moveChoiceUp: null,
       moveChoiceDown: null,
       close: null,
       accept: null,
     },
   };
   replyCallbacks: Array<(message: string) => void> = [];
   pendingThreadCreations: Map<string, Promise<string>> = new Map<
     string,
     Promise<string>,
   >();
   // TODO: flip the switch
   // Note that this enables Blob service for encrypted media only
   useBlobServiceUploads = false;
 
   // When the user sends a multimedia message that triggers the creation of a
   // sidebar, the sidebar gets created right away, but the message needs to wait
   // for the uploads to complete before sending. We use this Set to track the
   // message localIDs that need sidebarCreation: true.
   pendingSidebarCreationMessageLocalIDs: Set<string> = new Set<string>();
 
   static reassignToRealizedThreads<T>(
     state: { +[threadID: string]: T },
     props: Props,
   ): ?{ [threadID: string]: T } {
     const newState: { [string]: T } = {};
     let updated = false;
     for (const threadID in state) {
       const newThreadID =
         props.pendingRealizedThreadIDs.get(threadID) ?? threadID;
       if (newThreadID !== threadID) {
         updated = true;
       }
       newState[newThreadID] = state[threadID];
     }
     return updated ? newState : null;
   }
 
   static getDerivedStateFromProps(props: Props, state: State): ?Partial<State> {
     const pendingUploads = InputStateContainer.reassignToRealizedThreads(
       state.pendingUploads,
       props,
     );
     const textCursorPositions = InputStateContainer.reassignToRealizedThreads(
       state.textCursorPositions,
       props,
     );
 
     if (!pendingUploads && !textCursorPositions) {
       return null;
     }
 
     const stateUpdate: Partial<WritableState> = {};
     if (pendingUploads) {
       stateUpdate.pendingUploads = pendingUploads;
     }
     if (textCursorPositions) {
       stateUpdate.textCursorPositions = textCursorPositions;
     }
     return stateUpdate;
   }
 
   static completedMessageIDs(state: State): Set<string> {
     const completed = new Map<string, boolean>();
     for (const threadID in state.pendingUploads) {
       const pendingUploads = state.pendingUploads[threadID];
       for (const localUploadID in pendingUploads) {
         const upload = pendingUploads[localUploadID];
         const { messageID, serverID, failed } = upload;
         if (!messageID || !messageID.startsWith(localIDPrefix)) {
           continue;
         }
         if (!serverID || failed) {
           completed.set(messageID, false);
           continue;
         }
         if (completed.get(messageID) === undefined) {
           completed.set(messageID, true);
         }
       }
     }
     const messageIDs = new Set<string>();
     for (const [messageID, isCompleted] of completed) {
       if (isCompleted) {
         messageIDs.add(messageID);
       }
     }
     return messageIDs;
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (this.props.viewerID !== prevProps.viewerID) {
       this.setState({ pendingUploads: {} });
       return;
     }
 
     const previouslyAssignedMessageIDs = new Set<string>();
     for (const threadID in prevState.pendingUploads) {
       const pendingUploads = prevState.pendingUploads[threadID];
       for (const localUploadID in pendingUploads) {
         const { messageID } = pendingUploads[localUploadID];
         if (messageID) {
           previouslyAssignedMessageIDs.add(messageID);
         }
       }
     }
 
     const newlyAssignedUploads = new Map<
       string,
       {
         +threadID: string,
         +shouldEncrypt: boolean,
         +uploads: PendingMultimediaUpload[],
       },
     >();
     for (const threadID in this.state.pendingUploads) {
       const pendingUploads = this.state.pendingUploads[threadID];
       for (const localUploadID in pendingUploads) {
         const upload = pendingUploads[localUploadID];
         const { messageID } = upload;
         if (
           !messageID ||
           !messageID.startsWith(localIDPrefix) ||
           previouslyAssignedMessageIDs.has(messageID)
         ) {
           continue;
         }
         const { shouldEncrypt } = upload;
         let assignedUploads = newlyAssignedUploads.get(messageID);
         if (!assignedUploads) {
           assignedUploads = { threadID, shouldEncrypt, uploads: [] };
           newlyAssignedUploads.set(messageID, assignedUploads);
         }
         if (shouldEncrypt !== assignedUploads.shouldEncrypt) {
           console.warn(
             `skipping upload ${localUploadID} ` +
               "because shouldEncrypt doesn't match",
           );
           continue;
         }
         assignedUploads.uploads.push(upload);
       }
     }
 
     const newMessageInfos = new Map<string, RawMultimediaMessageInfo>();
     for (const [messageID, assignedUploads] of newlyAssignedUploads) {
       const { uploads, threadID, shouldEncrypt } = assignedUploads;
       const creatorID = this.props.viewerID;
       invariant(creatorID, 'need viewer ID in order to send a message');
       const media = uploads.map(
         ({
           localID,
           serverID,
           uri,
           mediaType,
           dimensions,
           encryptionKey,
           thumbHash,
         }) => {
           // We can get into this state where dimensions are null if the user is
           // uploading a file type that the browser can't render. In that case
           // we fake the dimensions here while we wait for the server to tell us
           // the true dimensions.
           const shimmedDimensions = dimensions ?? { height: 0, width: 0 };
           invariant(
             mediaType === 'photo' || mediaType === 'encrypted_photo',
             "web InputStateContainer can't handle video",
           );
           if (
             mediaType !== 'encrypted_photo' &&
             mediaType !== 'encrypted_video'
           ) {
             return {
               id: serverID ? serverID : localID,
               uri,
               type: 'photo',
               dimensions: shimmedDimensions,
               thumbHash,
             };
           }
           invariant(
             encryptionKey,
             'encrypted media must have an encryption key',
           );
           return {
             id: serverID ? serverID : localID,
             blobURI: uri,
             type: 'encrypted_photo',
             encryptionKey,
             dimensions: shimmedDimensions,
             thumbHash,
           };
         },
       );
       const messageInfo = createMediaMessageInfo(
         {
           localID: messageID,
           threadID,
           creatorID,
           media,
         },
         { forceMultimediaMessageType: shouldEncrypt },
       );
       newMessageInfos.set(messageID, messageInfo);
     }
 
     const currentlyCompleted = InputStateContainer.completedMessageIDs(
       this.state,
     );
     const previouslyCompleted =
       InputStateContainer.completedMessageIDs(prevState);
     for (const messageID of currentlyCompleted) {
       if (previouslyCompleted.has(messageID)) {
         continue;
       }
       let rawMessageInfo = newMessageInfos.get(messageID);
       if (rawMessageInfo) {
         newMessageInfos.delete(messageID);
       } else {
         rawMessageInfo = this.getRawMultimediaMessageInfo(messageID);
       }
-      this.sendMultimediaMessage(rawMessageInfo);
+      void this.sendMultimediaMessage(rawMessageInfo);
     }
 
     for (const [, messageInfo] of newMessageInfos) {
       this.props.dispatch({
         type: createLocalMessageActionType,
         payload: messageInfo,
       });
     }
   }
 
   getRawMultimediaMessageInfo(
     localMessageID: string,
   ): RawMultimediaMessageInfo {
     const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
     invariant(rawMessageInfo, `rawMessageInfo ${localMessageID} should exist`);
     invariant(
       rawMessageInfo.type === messageTypes.IMAGES ||
         rawMessageInfo.type === messageTypes.MULTIMEDIA,
       `rawMessageInfo ${localMessageID} should be multimedia`,
     );
     return rawMessageInfo;
   }
 
   shouldEncryptMedia(threadInfo: ThreadInfo): boolean {
     return threadInfoInsideCommunity(threadInfo, commStaffCommunity.id);
   }
 
   async sendMultimediaMessage(
     messageInfo: RawMultimediaMessageInfo,
   ): Promise<void> {
     if (!threadIsPending(messageInfo.threadID)) {
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         sendMultimediaMessageActionTypes,
         this.sendMultimediaMessageAction(messageInfo),
         undefined,
         messageInfo,
       );
       return;
     }
 
     this.props.dispatch({
       type: sendMultimediaMessageActionTypes.started,
       payload: messageInfo,
     });
 
     let newThreadID = null;
     try {
       const threadCreationPromise = this.pendingThreadCreations.get(
         messageInfo.threadID,
       );
       if (!threadCreationPromise) {
         // When we create or retry multimedia message, we add a promise to
         // pendingThreadCreations map. This promise can be removed in
         // sendMultimediaMessage and sendTextMessage methods. When any of these
         // method remove the promise, it has to be settled. If the promise was
         // fulfilled, this method would be called with realized thread, so we
         // can conclude that the promise was rejected. We don't have enough info
         // here to retry the thread creation, but we can mark the message as
         // failed. Then the retry will be possible and promise will be created
         // again.
         throw new Error('Thread creation failed');
       }
       newThreadID = await threadCreationPromise;
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = messageInfo.localID;
       copy.threadID = messageInfo.threadID;
       this.props.dispatch({
         type: sendMultimediaMessageActionTypes.failed,
         payload: copy,
         error: true,
       });
       return;
     } finally {
       this.pendingThreadCreations.delete(messageInfo.threadID);
     }
 
     // While the thread was being created, the image preload may have completed,
     // and we might have a finalized URI now. So we fetch from Redux again
     const { localID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should exist for locally-created RawMessageInfo',
     );
     const latestMessageInfo = this.getRawMultimediaMessageInfo(localID);
 
     // Conditional is necessary for Flow
     let newMessageInfo;
     if (latestMessageInfo.type === messageTypes.MULTIMEDIA) {
       newMessageInfo = {
         ...latestMessageInfo,
         threadID: newThreadID,
         time: Date.now(),
       };
     } else {
       newMessageInfo = {
         ...latestMessageInfo,
         threadID: newThreadID,
         time: Date.now(),
       };
     }
 
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       sendMultimediaMessageActionTypes,
       this.sendMultimediaMessageAction(newMessageInfo),
       undefined,
       newMessageInfo,
     );
   }
 
   async sendMultimediaMessageAction(
     messageInfo: RawMultimediaMessageInfo,
   ): Promise<SendMessagePayload> {
     const { localID, threadID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should be set',
     );
     const sidebarCreation =
       this.pendingSidebarCreationMessageLocalIDs.has(localID);
     const mediaIDs = [];
     for (const { id } of messageInfo.media) {
       mediaIDs.push(id);
     }
     try {
       const result = await this.props.sendMultimediaMessage({
         threadID,
         localID,
         mediaIDs,
         sidebarCreation,
       });
       this.pendingSidebarCreationMessageLocalIDs.delete(localID);
       this.setState(prevState => {
         const newThreadID = this.getRealizedOrPendingThreadID(threadID);
         const prevUploads = prevState.pendingUploads[newThreadID];
         const newUploads: { [string]: PendingMultimediaUpload } = {};
         for (const localUploadID in prevUploads) {
           const upload = prevUploads[localUploadID];
           if (upload.messageID !== localID) {
             newUploads[localUploadID] = upload;
           } else if (!upload.uriIsReal) {
             newUploads[localUploadID] = {
               ...upload,
               messageID: result.id,
             };
           }
         }
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [newThreadID]: newUploads,
           },
         };
       });
       return {
         localID,
         serverID: result.id,
         threadID,
         time: result.time,
         interface: result.interface,
       };
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = localID;
       copy.threadID = threadID;
       throw copy;
     }
   }
 
   startThreadCreation(threadInfo: ThreadInfo): Promise<string> {
     if (!threadIsPending(threadInfo.id)) {
       return Promise.resolve(threadInfo.id);
     }
     let threadCreationPromise = this.pendingThreadCreations.get(threadInfo.id);
     if (!threadCreationPromise) {
       const calendarQuery = this.props.calendarQuery();
       threadCreationPromise = createRealThreadFromPendingThread({
         threadInfo,
         dispatchActionPromise: this.props.dispatchActionPromise,
         createNewThread: this.props.newThread,
         sourceMessageID: threadInfo.sourceMessageID,
         viewerID: this.props.viewerID,
         calendarQuery,
       });
       this.pendingThreadCreations.set(threadInfo.id, threadCreationPromise);
     }
     return threadCreationPromise;
   }
 
   inputBaseStateSelector: (?string) => PropsAndState => BaseInputState =
     _memoize((threadID: ?string) =>
       createSelector(
         (propsAndState: PropsAndState) =>
           threadID ? propsAndState.pendingUploads[threadID] : null,
         (propsAndState: PropsAndState) =>
           threadID
             ? propsAndState.drafts[draftKeyFromThreadID(threadID)]
             : null,
         (propsAndState: PropsAndState) =>
           threadID ? propsAndState.textCursorPositions[threadID] : null,
         (
           pendingUploads: ?{ [localUploadID: string]: PendingMultimediaUpload },
           draft: ?string,
           textCursorPosition: ?number,
         ) => {
           let threadPendingUploads: $ReadOnlyArray<PendingMultimediaUpload> =
             [];
           const assignedUploads: {
             [string]: $ReadOnlyArray<PendingMultimediaUpload>,
           } = {};
           if (pendingUploads) {
             const [uploadsWithMessageIDs, uploadsWithoutMessageIDs] =
               _partition('messageID')(pendingUploads);
             threadPendingUploads = _sortBy('localID')(uploadsWithoutMessageIDs);
             const threadAssignedUploads = _groupBy('messageID')(
               uploadsWithMessageIDs,
             );
             for (const messageID in threadAssignedUploads) {
               // lodash libdefs don't return $ReadOnlyArray
               assignedUploads[messageID] = [
                 ...threadAssignedUploads[messageID],
               ];
             }
           }
           return ({
             pendingUploads: threadPendingUploads,
             assignedUploads,
             draft: draft ?? '',
             textCursorPosition: textCursorPosition ?? 0,
             appendFiles: (
               threadInfo: ThreadInfo,
               files: $ReadOnlyArray<File>,
             ) => this.appendFiles(threadInfo, files),
             cancelPendingUpload: (localUploadID: string) =>
               this.cancelPendingUpload(threadID, localUploadID),
             sendTextMessage: (
               messageInfo: RawTextMessageInfo,
               threadInfo: ThreadInfo,
               parentThreadInfo: ?ThreadInfo,
             ) =>
               this.sendTextMessage(messageInfo, threadInfo, parentThreadInfo),
             createMultimediaMessage: (
               localID: number,
               threadInfo: ThreadInfo,
             ) => this.createMultimediaMessage(localID, threadInfo),
             setDraft: (newDraft: string) => this.setDraft(threadID, newDraft),
             setTextCursorPosition: (newPosition: number) =>
               this.setTextCursorPosition(threadID, newPosition),
             messageHasUploadFailure: (localMessageID: string) =>
               this.messageHasUploadFailure(assignedUploads[localMessageID]),
             retryMultimediaMessage: (
               localMessageID: string,
               threadInfo: ThreadInfo,
             ) =>
               this.retryMultimediaMessage(
                 localMessageID,
                 threadInfo,
                 assignedUploads[localMessageID],
               ),
             addReply: (message: string) => this.addReply(message),
             addReplyListener: this.addReplyListener,
             removeReplyListener: this.removeReplyListener,
             registerSendCallback: this.props.registerSendCallback,
             unregisterSendCallback: this.props.unregisterSendCallback,
           }: BaseInputState);
         },
       ),
     );
 
   typeaheadStateSelector: PropsAndState => TypeaheadInputState = createSelector(
     (propsAndState: PropsAndState) => propsAndState.typeaheadState,
     (typeaheadState: TypeaheadState) => ({
       typeaheadState,
       setTypeaheadState: this.setTypeaheadState,
     }),
   );
 
   inputStateSelector: CombinedInputState => InputState = createSelector(
     (state: CombinedInputState) => state.inputBaseState,
     (state: CombinedInputState) => state.typeaheadState,
     (inputBaseState: BaseInputState, typeaheadState: TypeaheadInputState) => ({
       ...inputBaseState,
       ...typeaheadState,
     }),
   );
 
   getRealizedOrPendingThreadID(threadID: string): string {
     return this.props.pendingRealizedThreadIDs.get(threadID) ?? threadID;
   }
 
   async appendFiles(
     threadInfo: ThreadInfo,
     files: $ReadOnlyArray<File>,
   ): Promise<boolean> {
     const selectionTime = Date.now();
     const { pushModal } = this.props;
 
     const appendResults = await Promise.all(
       files.map(file => this.appendFile(threadInfo, file, selectionTime)),
     );
 
     if (appendResults.some(({ result }) => !result.success)) {
       pushModal(<InvalidUploadModal />);
 
       const time = Date.now() - selectionTime;
       const reports = [];
       for (const appendResult of appendResults) {
         const { steps } = appendResult;
         let { result } = appendResult;
         let uploadLocalID;
         if (result.success) {
           uploadLocalID = result.pendingUpload.localID;
           result = { success: false, reason: 'web_sibling_validation_failed' };
         }
         const mediaMission = { steps, result, userTime: time, totalTime: time };
         reports.push({ mediaMission, uploadLocalID });
       }
       this.queueMediaMissionReports(reports);
 
       return false;
     }
 
     const newUploads = appendResults.map(({ result }) => {
       invariant(result.success, 'any failed validation should be caught above');
       return result.pendingUpload;
     });
 
     const newUploadsObject = _keyBy('localID')(newUploads);
     this.setState(
       prevState => {
         const newThreadID = this.getRealizedOrPendingThreadID(threadInfo.id);
         const prevUploads = prevState.pendingUploads[newThreadID];
         const mergedUploads = prevUploads
           ? { ...prevUploads, ...newUploadsObject }
           : newUploadsObject;
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [newThreadID]: mergedUploads,
           },
         };
       },
       () => this.uploadFiles(threadInfo.id, newUploads),
     );
     return true;
   }
 
   async appendFile(
     threadInfo: ThreadInfo,
     file: File,
     selectTime: number,
   ): Promise<{
     steps: $ReadOnlyArray<MediaMissionStep>,
     result:
       | MediaMissionFailure
       | { success: true, pendingUpload: PendingMultimediaUpload },
   }> {
     const steps: MediaMissionStep[] = [
       {
         step: 'web_selection',
         filename: file.name,
         size: file.size,
         mime: file.type,
         selectTime,
       },
     ];
 
     let response;
     const validationStart = Date.now();
     try {
       response = await validateFile(file);
     } catch (e) {
       return {
         steps,
         result: {
           success: false,
           reason: 'processing_exception',
           time: Date.now() - validationStart,
           exceptionMessage: getMessageForException(e),
         },
       };
     }
     const { steps: validationSteps, result } = response;
     steps.push(...validationSteps);
     if (!result.success) {
       return { steps, result };
     }
     const { uri, file: fixedFile, mediaType, dimensions } = result;
 
     const shouldEncrypt = this.shouldEncryptMedia(threadInfo);
 
     let encryptionResult;
     if (shouldEncrypt) {
       let encryptionResponse;
       const encryptionStart = Date.now();
       try {
         encryptionResponse = await encryptFile(fixedFile);
       } catch (e) {
         return {
           steps,
           result: {
             success: false,
             reason: 'encryption_exception',
             time: Date.now() - encryptionStart,
             exceptionMessage: getMessageForException(e),
           },
         };
       }
       steps.push(...encryptionResponse.steps);
       encryptionResult = encryptionResponse.result;
     }
     if (encryptionResult && !encryptionResult.success) {
       return { steps, result: encryptionResult };
     }
 
     const { steps: thumbHashSteps, result: thumbHashResult } =
       await generateThumbHash(fixedFile, encryptionResult?.encryptionKey);
     const thumbHash = thumbHashResult.success
       ? thumbHashResult.thumbHash
       : null;
     steps.push(...thumbHashSteps);
 
     return {
       steps,
       result: {
         success: true,
         pendingUpload: {
           localID: getNextLocalUploadID(),
           serverID: null,
           messageID: null,
           failed: false,
           file: encryptionResult?.file ?? fixedFile,
           mediaType: encryptionResult ? 'encrypted_photo' : mediaType,
           dimensions,
           uri: encryptionResult?.uri ?? uri,
           loop: false,
           uriIsReal: false,
           blobHolder: null,
           blobHash: encryptionResult?.sha256Hash,
           encryptionKey: encryptionResult?.encryptionKey,
           thumbHash,
           progressPercent: 0,
           abort: null,
           steps,
           selectTime,
           shouldEncrypt,
         },
       },
     };
   }
 
   uploadFiles(
     threadID: string,
     uploads: $ReadOnlyArray<PendingMultimediaUpload>,
   ): Promise<mixed> {
     return Promise.all(
       uploads.map(upload => this.uploadFile(threadID, upload)),
     );
   }
 
   async uploadFile(threadID: string, upload: PendingMultimediaUpload) {
     const { selectTime, localID, encryptionKey } = upload;
     const isEncrypted =
       !!encryptionKey &&
       (upload.mediaType === 'encrypted_photo' ||
         upload.mediaType === 'encrypted_video');
 
     const steps = [...upload.steps];
     let userTime;
 
     const sendReport = (missionResult: MediaMissionResult) => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const latestUpload = this.state.pendingUploads[newThreadID][localID];
       invariant(
         latestUpload,
         `pendingUpload ${localID} for ${newThreadID} missing in sendReport`,
       );
       const { serverID, messageID } = latestUpload;
       const totalTime = Date.now() - selectTime;
       userTime = userTime ? userTime : totalTime;
       const mission = { steps, result: missionResult, totalTime, userTime };
       this.queueMediaMissionReports([
         {
           mediaMission: mission,
           uploadLocalID: localID,
           uploadServerID: serverID,
           messageLocalID: messageID,
         },
       ]);
     };
 
     let uploadResult, uploadExceptionMessage;
     const uploadStart = Date.now();
     try {
       const callbacks = {
         onProgress: (percent: number) =>
           this.setProgress(threadID, localID, percent),
         abortHandler: (abort: () => void) =>
           this.handleAbortCallback(threadID, localID, abort),
       };
       if (
         this.useBlobServiceUploads &&
         (upload.mediaType === 'encrypted_photo' ||
           upload.mediaType === 'encrypted_video')
       ) {
         const { blobHash, dimensions, thumbHash } = upload;
         invariant(
           encryptionKey && blobHash && dimensions,
           'incomplete encrypted upload',
         );
         uploadResult = await this.props.blobServiceUpload({
           uploadInput: {
             blobInput: {
               type: 'file',
               file: upload.file,
             },
             blobHash,
             encryptionKey,
             dimensions,
             loop: false,
             thumbHash,
           },
           keyserverOrThreadID: threadID,
           callbacks,
         });
       } else {
         let uploadExtras = {
           ...upload.dimensions,
           loop: false,
           thumbHash: upload.thumbHash,
         };
         if (encryptionKey) {
           uploadExtras = { ...uploadExtras, encryptionKey };
         }
         uploadResult = await this.props.uploadMultimedia(
           upload.file,
           uploadExtras,
           callbacks,
         );
       }
     } catch (e) {
       uploadExceptionMessage = getMessageForException(e);
       this.handleUploadFailure(threadID, localID);
     }
     userTime = Date.now() - selectTime;
     steps.push({
       step: 'upload',
       success: !!uploadResult,
       exceptionMessage: uploadExceptionMessage,
       time: Date.now() - uploadStart,
       inputFilename: upload.file.name,
       outputMediaType: uploadResult && uploadResult.mediaType,
       outputURI: uploadResult && uploadResult.uri,
       outputDimensions: uploadResult && uploadResult.dimensions,
       outputLoop: uploadResult && uploadResult.loop,
     });
     if (!uploadResult) {
       sendReport({
         success: false,
         reason: 'http_upload_failed',
         exceptionMessage: uploadExceptionMessage,
       });
       return;
     }
     const result = uploadResult;
     const outputMediaType = isEncrypted ? 'encrypted_photo' : result.mediaType;
 
     const successThreadID = this.getRealizedOrPendingThreadID(threadID);
     const uploadAfterSuccess =
       this.state.pendingUploads[successThreadID][localID];
     invariant(
       uploadAfterSuccess,
       `pendingUpload ${localID}/${result.id} for ${successThreadID} missing ` +
         `after upload`,
     );
     if (uploadAfterSuccess.messageID) {
       this.props.dispatch({
         type: updateMultimediaMessageMediaActionType,
         payload: {
           messageID: uploadAfterSuccess.messageID,
           currentMediaID: localID,
           mediaUpdate: {
             id: result.id,
           },
         },
       });
     }
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const uploads = prevState.pendingUploads[newThreadID];
       const currentUpload = uploads[localID];
       invariant(
         currentUpload,
         `pendingUpload ${localID}/${result.id} for ${newThreadID} ` +
           `missing while assigning serverID`,
       );
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: {
             ...uploads,
             [localID]: {
               ...currentUpload,
               serverID: result.id,
               blobHolder: result.blobHolder,
               abort: null,
             },
           },
         },
       };
     });
 
     if (encryptionKey) {
       const { steps: preloadSteps } = await preloadMediaResource(result.uri);
       steps.push(...preloadSteps);
     } else {
       const { steps: preloadSteps } = await preloadImage(result.uri);
       steps.push(...preloadSteps);
     }
     sendReport({ success: true });
 
     const preloadThreadID = this.getRealizedOrPendingThreadID(threadID);
     const uploadAfterPreload =
       this.state.pendingUploads[preloadThreadID][localID];
     invariant(
       uploadAfterPreload,
       `pendingUpload ${localID}/${result.id} for ${preloadThreadID} missing ` +
         `after preload`,
     );
     if (uploadAfterPreload.messageID) {
       const { mediaType, uri, dimensions, loop } = result;
       const { thumbHash } = upload;
       let mediaUpdate = {
         loop,
         dimensions,
         ...(thumbHash ? { thumbHash } : undefined),
       };
       if (!isEncrypted) {
         mediaUpdate = {
           ...mediaUpdate,
           type: mediaType,
           uri,
         };
       } else {
         mediaUpdate = {
           ...mediaUpdate,
           type: outputMediaType,
           blobURI: uri,
           encryptionKey,
         };
       }
       this.props.dispatch({
         type: updateMultimediaMessageMediaActionType,
         payload: {
           messageID: uploadAfterPreload.messageID,
           currentMediaID: result.id ?? uploadAfterPreload.localID,
           mediaUpdate,
         },
       });
     }
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const uploads = prevState.pendingUploads[newThreadID];
       const currentUpload = uploads[localID];
       invariant(
         currentUpload,
         `pendingUpload ${localID}/${result.id} for ${newThreadID} ` +
           `missing while assigning URI`,
       );
       const { messageID } = currentUpload;
       if (messageID && !messageID.startsWith(localIDPrefix)) {
         const newPendingUploads = _omit([localID])(uploads);
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [newThreadID]: newPendingUploads,
           },
         };
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: {
             ...uploads,
             [localID]: {
               ...currentUpload,
               uri: result.uri,
               mediaType: outputMediaType,
               dimensions: result.dimensions,
               uriIsReal: true,
               loop: result.loop,
             },
           },
         },
       };
     });
   }
 
   handleAbortCallback(
     threadID: string,
     localUploadID: string,
     abort: () => void,
   ) {
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const uploads = prevState.pendingUploads[newThreadID];
       const upload = uploads[localUploadID];
       if (!upload) {
         // The upload has been cancelled before we were even handed the
         // abort function. We should immediately abort.
         abort();
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: {
             ...uploads,
             [localUploadID]: {
               ...upload,
               abort,
             },
           },
         },
       };
     });
   }
 
   handleUploadFailure(threadID: string, localUploadID: string) {
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const uploads = prevState.pendingUploads[newThreadID];
       const upload = uploads[localUploadID];
       if (!upload || !upload.abort || upload.serverID) {
         // The upload has been cancelled or completed before it failed
         return {};
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: {
             ...uploads,
             [localUploadID]: {
               ...upload,
               failed: true,
               progressPercent: 0,
               abort: null,
             },
           },
         },
       };
     });
   }
 
   queueMediaMissionReports(
     partials: $ReadOnlyArray<{
       mediaMission: MediaMission,
       uploadLocalID?: ?string,
       uploadServerID?: ?string,
       messageLocalID?: ?string,
     }>,
   ) {
     const reports = partials.map(
       ({ mediaMission, uploadLocalID, uploadServerID, messageLocalID }) => ({
         type: reportTypes.MEDIA_MISSION,
         time: Date.now(),
         platformDetails: getConfig().platformDetails,
         mediaMission,
         uploadServerID,
         uploadLocalID,
         messageLocalID,
         id: generateReportID(),
       }),
     );
     this.props.dispatch({ type: queueReportsActionType, payload: { reports } });
   }
 
   cancelPendingUpload(threadID: ?string, localUploadID: string) {
     invariant(threadID, 'threadID should be set in cancelPendingUpload');
 
     let revokeURL: ?string, abortRequest: ?() => void;
     this.setState(
       prevState => {
         const newThreadID = this.getRealizedOrPendingThreadID(threadID);
         const currentPendingUploads = prevState.pendingUploads[newThreadID];
         if (!currentPendingUploads) {
           return {};
         }
         const pendingUpload = currentPendingUploads[localUploadID];
         if (!pendingUpload) {
           return {};
         }
         if (!pendingUpload.uriIsReal) {
           revokeURL = pendingUpload.uri;
         }
         if (pendingUpload.abort) {
           abortRequest = pendingUpload.abort;
         }
         if (pendingUpload.serverID) {
-          this.props.deleteUpload({
+          void this.props.deleteUpload({
             id: pendingUpload.serverID,
             keyserverOrThreadID: threadID,
           });
           if (isBlobServiceURI(pendingUpload.uri)) {
             invariant(
               pendingUpload.blobHolder,
               'blob service upload has no holder',
             );
             const endpoint = blobService.httpEndpoints.DELETE_BLOB;
             const holder = pendingUpload.blobHolder;
             const blobHash = blobHashFromBlobServiceURI(pendingUpload.uri);
-            fetch(makeBlobServiceEndpointURL(endpoint), {
+            void fetch(makeBlobServiceEndpointURL(endpoint), {
               method: endpoint.method,
               body: JSON.stringify({
                 holder,
                 blob_hash: blobHash,
               }),
               headers: {
                 'content-type': 'application/json',
               },
             });
           }
         }
         const newPendingUploads = _omit([localUploadID])(currentPendingUploads);
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [newThreadID]: newPendingUploads,
           },
         };
       },
       () => {
         if (revokeURL) {
           URL.revokeObjectURL(revokeURL);
         }
         if (abortRequest) {
           abortRequest();
         }
       },
     );
   }
 
   async sendTextMessage(
     messageInfo: RawTextMessageInfo,
     inputThreadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ) {
     this.props.sendCallbacks.forEach(callback => callback());
 
     const { localID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should be set',
     );
     if (threadIsPendingSidebar(inputThreadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localID);
     }
 
     if (!threadIsPending(inputThreadInfo.id)) {
-      this.props.dispatchActionPromise(
+      void this.props.dispatchActionPromise(
         sendTextMessageActionTypes,
         this.sendTextMessageAction(
           messageInfo,
           inputThreadInfo,
           parentThreadInfo,
         ),
         undefined,
         messageInfo,
       );
       return;
     }
 
     this.props.dispatch({
       type: sendTextMessageActionTypes.started,
       payload: messageInfo,
     });
 
     let threadInfo = inputThreadInfo;
     const { viewerID } = this.props;
     if (viewerID && inputThreadInfo.type === threadTypes.SIDEBAR) {
       invariant(parentThreadInfo, 'sidebar should have parent');
       threadInfo = patchThreadInfoToIncludeMentionedMembersOfParent(
         inputThreadInfo,
         parentThreadInfo,
         messageInfo.text,
         viewerID,
       );
       if (threadInfo !== inputThreadInfo) {
         this.props.dispatch({
           type: updateNavInfoActionType,
           payload: { pendingThread: threadInfo },
         });
       }
     }
 
     let newThreadID = null;
     try {
       newThreadID = await this.startThreadCreation(threadInfo);
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = messageInfo.localID;
       copy.threadID = messageInfo.threadID;
       this.props.dispatch({
         type: sendTextMessageActionTypes.failed,
         payload: copy,
         error: true,
       });
       return;
     } finally {
       this.pendingThreadCreations.delete(threadInfo.id);
     }
 
     const newMessageInfo = {
       ...messageInfo,
       threadID: newThreadID,
       time: Date.now(),
     };
 
     // Branching to appease `flow`.
     const newThreadInfo = threadInfo.minimallyEncoded
       ? {
           ...threadInfo,
           id: newThreadID,
         }
       : {
           ...threadInfo,
           id: newThreadID,
         };
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       sendTextMessageActionTypes,
       this.sendTextMessageAction(
         newMessageInfo,
         newThreadInfo,
         parentThreadInfo,
       ),
       undefined,
       newMessageInfo,
     );
   }
 
   async sendTextMessageAction(
     messageInfo: RawTextMessageInfo,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ): Promise<SendMessagePayload> {
     try {
       await this.props.textMessageCreationSideEffectsFunc(
         messageInfo,
         threadInfo,
         parentThreadInfo,
       );
       const { localID } = messageInfo;
       invariant(
         localID !== null && localID !== undefined,
         'localID should be set',
       );
       const sidebarCreation =
         this.pendingSidebarCreationMessageLocalIDs.has(localID);
       const result = await this.props.sendTextMessage({
         threadID: messageInfo.threadID,
         localID,
         text: messageInfo.text,
         sidebarCreation,
       });
       this.pendingSidebarCreationMessageLocalIDs.delete(localID);
       return {
         localID,
         serverID: result.id,
         threadID: messageInfo.threadID,
         time: result.time,
         interface: result.interface,
       };
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = messageInfo.localID;
       copy.threadID = messageInfo.threadID;
       throw copy;
     }
   }
 
   // Creates a MultimediaMessage from the unassigned pending uploads,
   // if there are any
   createMultimediaMessage(localID: number, threadInfo: ThreadInfo) {
     this.props.sendCallbacks.forEach(callback => callback());
 
     const localMessageID = `${localIDPrefix}${localID}`;
-    this.startThreadCreation(threadInfo);
+    void this.startThreadCreation(threadInfo);
 
     if (threadIsPendingSidebar(threadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localMessageID);
     }
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadInfo.id);
       const currentPendingUploads = prevState.pendingUploads[newThreadID];
       if (!currentPendingUploads) {
         return {};
       }
       const newPendingUploads: { [string]: PendingMultimediaUpload } = {};
       let uploadAssigned = false;
       for (const localUploadID in currentPendingUploads) {
         const upload = currentPendingUploads[localUploadID];
         if (upload.messageID) {
           newPendingUploads[localUploadID] = upload;
         } else {
           const newUpload = {
             ...upload,
             messageID: localMessageID,
           };
           uploadAssigned = true;
           newPendingUploads[localUploadID] = newUpload;
         }
       }
       if (!uploadAssigned) {
         return {};
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: newPendingUploads,
         },
       };
     });
   }
 
   setDraft(threadID: ?string, draft: string) {
     invariant(threadID, 'threadID should be set in setDraft');
 
     const newThreadID = this.getRealizedOrPendingThreadID(threadID);
     this.props.dispatch({
       type: 'UPDATE_DRAFT',
       payload: {
         key: draftKeyFromThreadID(newThreadID),
         text: draft,
       },
     });
   }
 
   setTextCursorPosition(threadID: ?string, newPosition: number) {
     invariant(threadID, 'threadID should be set in setTextCursorPosition');
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       return {
         textCursorPositions: {
           ...prevState.textCursorPositions,
           [newThreadID]: newPosition,
         },
       };
     });
   }
 
   setTypeaheadState = (newState: Partial<TypeaheadState>) => {
     this.setState(prevState => ({
       typeaheadState: {
         ...prevState.typeaheadState,
         ...newState,
       },
     }));
   };
 
   setProgress(
     threadID: string,
     localUploadID: string,
     progressPercent: number,
   ) {
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const pendingUploads = prevState.pendingUploads[newThreadID];
       if (!pendingUploads) {
         return {};
       }
       const pendingUpload = pendingUploads[localUploadID];
       if (!pendingUpload) {
         return {};
       }
       const newPendingUploads = {
         ...pendingUploads,
         [localUploadID]: {
           ...pendingUpload,
           progressPercent,
         },
       };
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: newPendingUploads,
         },
       };
     });
   }
 
   messageHasUploadFailure(
     pendingUploads: ?$ReadOnlyArray<PendingMultimediaUpload>,
   ): boolean {
     if (!pendingUploads) {
       return false;
     }
     return pendingUploads.some(upload => upload.failed);
   }
 
   retryMultimediaMessage(
     localMessageID: string,
     threadInfo: ThreadInfo,
     pendingUploads: ?$ReadOnlyArray<PendingMultimediaUpload>,
   ) {
     this.props.sendCallbacks.forEach(callback => callback());
 
     const rawMessageInfo = this.getRawMultimediaMessageInfo(localMessageID);
     let newRawMessageInfo;
     // This conditional is for Flow
     if (rawMessageInfo.type === messageTypes.MULTIMEDIA) {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: Date.now(),
       }: RawMediaMessageInfo);
     } else {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: Date.now(),
       }: RawImagesMessageInfo);
     }
 
-    this.startThreadCreation(threadInfo);
+    void this.startThreadCreation(threadInfo);
 
     if (threadIsPendingSidebar(threadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localMessageID);
     }
 
     const completed = InputStateContainer.completedMessageIDs(this.state);
     if (completed.has(localMessageID)) {
-      this.sendMultimediaMessage(newRawMessageInfo);
+      void this.sendMultimediaMessage(newRawMessageInfo);
       return;
     }
 
     if (!pendingUploads) {
       return;
     }
 
     // We're not actually starting the send here,
     // we just use this action to update the message's timestamp in Redux
     this.props.dispatch({
       type: sendMultimediaMessageActionTypes.started,
       payload: newRawMessageInfo,
     });
 
     const uploadIDsToRetry = new Set<string>();
     const uploadsToRetry = [];
     for (const pendingUpload of pendingUploads) {
       const { serverID, messageID, localID, abort } = pendingUpload;
       if (serverID || messageID !== localMessageID) {
         continue;
       }
       if (abort) {
         abort();
       }
       uploadIDsToRetry.add(localID);
       uploadsToRetry.push(pendingUpload);
     }
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadInfo.id);
       const prevPendingUploads = prevState.pendingUploads[newThreadID];
       if (!prevPendingUploads) {
         return {};
       }
       const newPendingUploads: { [string]: PendingMultimediaUpload } = {};
       let pendingUploadChanged = false;
       for (const localID in prevPendingUploads) {
         const pendingUpload = prevPendingUploads[localID];
         if (uploadIDsToRetry.has(localID) && !pendingUpload.serverID) {
           newPendingUploads[localID] = {
             ...pendingUpload,
             failed: false,
             progressPercent: 0,
             abort: null,
           };
           pendingUploadChanged = true;
         } else {
           newPendingUploads[localID] = pendingUpload;
         }
       }
       if (!pendingUploadChanged) {
         return {};
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: newPendingUploads,
         },
       };
     });
 
-    this.uploadFiles(threadInfo.id, uploadsToRetry);
+    void this.uploadFiles(threadInfo.id, uploadsToRetry);
   }
 
   addReply = (message: string) => {
     this.replyCallbacks.forEach(addReplyCallback => addReplyCallback(message));
   };
 
   addReplyListener = (callbackReply: (message: string) => void) => {
     this.replyCallbacks.push(callbackReply);
   };
 
   removeReplyListener = (callbackReply: (message: string) => void) => {
     this.replyCallbacks = this.replyCallbacks.filter(
       candidate => candidate !== callbackReply,
     );
   };
 
   render(): React.Node {
     const { activeChatThreadID } = this.props;
 
     // we're going with two selectors as we want to avoid
     // recreation of chat state setter functions on typeahead state updates
     const inputBaseState = this.inputBaseStateSelector(activeChatThreadID)({
       ...this.state,
       ...this.props,
     });
 
     const typeaheadState = this.typeaheadStateSelector({
       ...this.state,
       ...this.props,
     });
 
     const inputState = this.inputStateSelector({
       inputBaseState,
       typeaheadState,
     });
 
     return (
       <InputStateContext.Provider value={inputState}>
         {this.props.children}
       </InputStateContext.Provider>
     );
   }
 }
 
 const ConnectedInputStateContainer: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedInputStateContainer(props) {
     const activeChatThreadID = useSelector(
       state => state.navInfo.activeChatThreadID,
     );
     const drafts = useSelector(state => state.draftStore.drafts);
     const viewerID = useSelector(
       state => state.currentUserInfo && state.currentUserInfo.id,
     );
     const messageStoreMessages = useSelector(
       state => state.messageStore.messages,
     );
     const pendingToRealizedThreadIDs = useSelector(state =>
       pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
     );
     const calendarQuery = useSelector(nonThreadCalendarQuery);
     const callUploadMultimedia = useServerCall(uploadMultimedia);
     const callBlobServiceUpload = useBlobServiceUpload();
     const callDeleteUpload = useDeleteUpload();
     const callSendMultimediaMessage = useLegacySendMultimediaMessage();
     const callSendTextMessage = useSendTextMessage();
     const callNewThread = useNewThread();
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const modalContext = useModalContext();
 
     const [sendCallbacks, setSendCallbacks] = React.useState<
       $ReadOnlyArray<() => mixed>,
     >([]);
     const registerSendCallback = React.useCallback((callback: () => mixed) => {
       setSendCallbacks(prevCallbacks => [...prevCallbacks, callback]);
     }, []);
     const unregisterSendCallback = React.useCallback(
       (callback: () => mixed) => {
         setSendCallbacks(prevCallbacks =>
           prevCallbacks.filter(candidate => candidate !== callback),
         );
       },
       [],
     );
     const textMessageCreationSideEffectsFunc =
       useMessageCreationSideEffectsFunc<RawTextMessageInfo>(messageTypes.TEXT);
 
     return (
       <InputStateContainer
         {...props}
         activeChatThreadID={activeChatThreadID}
         drafts={drafts}
         viewerID={viewerID}
         messageStoreMessages={messageStoreMessages}
         pendingRealizedThreadIDs={pendingToRealizedThreadIDs}
         calendarQuery={calendarQuery}
         uploadMultimedia={callUploadMultimedia}
         blobServiceUpload={callBlobServiceUpload}
         deleteUpload={callDeleteUpload}
         sendMultimediaMessage={callSendMultimediaMessage}
         sendTextMessage={callSendTextMessage}
         newThread={callNewThread}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         pushModal={modalContext.pushModal}
         sendCallbacks={sendCallbacks}
         registerSendCallback={registerSendCallback}
         unregisterSendCallback={unregisterSendCallback}
         textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
       />
     );
   });
 
 export default ConnectedInputStateContainer;
diff --git a/web/invite-links/accept-invite-modal.react.js b/web/invite-links/accept-invite-modal.react.js
index ca07534e6..4b0e344b6 100644
--- a/web/invite-links/accept-invite-modal.react.js
+++ b/web/invite-links/accept-invite-modal.react.js
@@ -1,130 +1,133 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   useJoinThread,
   joinThreadActionTypes,
 } from 'lib/actions/thread-actions.js';
 import ModalOverlay from 'lib/components/modal-overlay.react.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { type InviteLinkVerificationResponse } from 'lib/types/link-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import css from './accept-invite-modal.css';
 import Button, { buttonThemes } from '../components/button.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { nonThreadCalendarQuery } from '../selectors/nav-selectors.js';
 
 type Props = {
   +verificationResponse: InviteLinkVerificationResponse,
   +inviteSecret: string,
 };
 
 function AcceptInviteModal(props: Props): React.Node {
   const { verificationResponse, inviteSecret } = props;
   const [isLinkValid, setIsLinkValid] = React.useState(
     verificationResponse.status === 'valid',
   );
   const { popModal } = useModalContext();
 
   React.useEffect(() => {
     if (verificationResponse.status === 'already_joined') {
       popModal();
     }
   }, [popModal, verificationResponse.status]);
 
   const callJoinThread = useJoinThread();
   const calendarQuery = useSelector(nonThreadCalendarQuery);
   const communityID = verificationResponse.community?.id;
   const createJoinCommunityAction = React.useCallback(async () => {
     invariant(
       communityID,
       'CommunityID should be present while calling this function',
     );
     const query = calendarQuery();
     try {
       const result = await callJoinThread({
         threadID: communityID,
         calendarQuery: {
           startDate: query.startDate,
           endDate: query.endDate,
           filters: [
             ...query.filters,
             { type: 'threads', threadIDs: [communityID] },
           ],
         },
         inviteLinkSecret: inviteSecret,
       });
       popModal();
       return result;
     } catch (e) {
       setIsLinkValid(false);
       throw e;
     }
   }, [calendarQuery, callJoinThread, communityID, inviteSecret, popModal]);
   const dispatchActionPromise = useDispatchActionPromise();
   const joinCommunity = React.useCallback(() => {
-    dispatchActionPromise(joinThreadActionTypes, createJoinCommunityAction());
+    void dispatchActionPromise(
+      joinThreadActionTypes,
+      createJoinCommunityAction(),
+    );
   }, [createJoinCommunityAction, dispatchActionPromise]);
   const joinThreadLoadingStatus = useSelector(joinThreadLoadingStatusSelector);
 
   let content;
   if (verificationResponse.status === 'valid' && isLinkValid) {
     const { community } = verificationResponse;
     content = (
       <>
         <div className={css.text}>You have been invited to join</div>
         <div className={css.heading}>{community.name}</div>
         <hr />
         <div className={css.group}>
           <Button
             variant="filled"
             buttonColor={buttonThemes.standard}
             disabled={joinThreadLoadingStatus === 'loading'}
             onClick={joinCommunity}
           >
             Accept invite
           </Button>
           <Button variant="outline" onClick={popModal}>
             Cancel
           </Button>
         </div>
       </>
     );
   } else {
     content = (
       <>
         <div className={css.group}>
           <div className={css.heading}>Invite invalid</div>
           <div className={css.text}>
             This invite link may be expired. Please try again with another
             invite link.
           </div>
         </div>
         <hr />
         <Button
           variant="filled"
           buttonColor={buttonThemes.standard}
           onClick={popModal}
         >
           Return to Comm
         </Button>
       </>
     );
   }
 
   return (
     <ModalOverlay onClose={popModal}>
       <div className={css.container}>{content}</div>
     </ModalOverlay>
   );
 }
 
 const joinThreadLoadingStatusSelector = createLoadingStatusSelector(
   joinThreadActionTypes,
 );
 
 export default AcceptInviteModal;
diff --git a/web/invite-links/invite-link-handler.react.js b/web/invite-links/invite-link-handler.react.js
index 9f01380ee..d41ece5ca 100644
--- a/web/invite-links/invite-link-handler.react.js
+++ b/web/invite-links/invite-link-handler.react.js
@@ -1,63 +1,66 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   verifyInviteLink,
   verifyInviteLinkActionTypes,
 } from 'lib/actions/link-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import AcceptInviteModal from './accept-invite-modal.react.js';
 import { updateNavInfoActionType } from '../redux/action-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 function InviteLinkHandler(): null {
   const inviteSecret = useSelector(state => state.navInfo.inviteSecret);
   const loggedIn = useSelector(isLoggedIn);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const dispatch = useDispatch();
   const validateLink = useServerCall(verifyInviteLink);
   const { pushModal } = useModalContext();
   React.useEffect(() => {
     if (!inviteSecret || !loggedIn) {
       return;
     }
     dispatch({
       type: updateNavInfoActionType,
       payload: { inviteSecret: null },
     });
     const validateLinkPromise = validateLink({ secret: inviteSecret });
-    dispatchActionPromise(verifyInviteLinkActionTypes, validateLinkPromise);
-    (async () => {
+    void dispatchActionPromise(
+      verifyInviteLinkActionTypes,
+      validateLinkPromise,
+    );
+    void (async () => {
       const result = await validateLinkPromise;
       if (result.status === 'already_joined') {
         return;
       }
       pushModal(
         <AcceptInviteModal
           verificationResponse={result}
           inviteSecret={inviteSecret}
         />,
       );
     })();
   }, [
     dispatch,
     dispatchActionPromise,
     inviteSecret,
     loggedIn,
     pushModal,
     validateLink,
   ]);
 
   return null;
 }
 
 export default InviteLinkHandler;
diff --git a/web/invite-links/invite-links-refresher.react.js b/web/invite-links/invite-links-refresher.react.js
index a52440fbf..1187d077b 100644
--- a/web/invite-links/invite-links-refresher.react.js
+++ b/web/invite-links/invite-links-refresher.react.js
@@ -1,33 +1,33 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   fetchPrimaryInviteLinkActionTypes,
   useFetchPrimaryInviteLinks,
 } from 'lib/actions/link-actions.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import { useSelector } from '../redux/redux-utils.js';
 
 function InviteLinksRefresher(): React.Node {
   const isActive = useSelector(state => state.windowActive);
   const loggedIn = useSelector(isLoggedIn);
   const callFetchPrimaryLinks = useFetchPrimaryInviteLinks();
   const dispatchActionPromise = useDispatchActionPromise();
 
   React.useEffect(() => {
     if (!isActive || !loggedIn) {
       return;
     }
-    dispatchActionPromise(
+    void dispatchActionPromise(
       fetchPrimaryInviteLinkActionTypes,
       callFetchPrimaryLinks(),
     );
   }, [callFetchPrimaryLinks, dispatchActionPromise, isActive, loggedIn]);
 
   return null;
 }
 
 export default InviteLinksRefresher;
diff --git a/web/media/encrypted-multimedia.react.js b/web/media/encrypted-multimedia.react.js
index 82199c0bd..be28dbd5a 100644
--- a/web/media/encrypted-multimedia.react.js
+++ b/web/media/encrypted-multimedia.react.js
@@ -1,141 +1,141 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import 'react-circular-progressbar/dist/styles.css';
 import { AlertCircle as AlertCircleIcon } from 'react-feather';
 
 import type { EncryptedMediaType } from 'lib/types/media-types.js';
 
 import { decryptMedia } from './encryption-utils.js';
 import LoadableVideo from './loadable-video.react.js';
 import css from './media.css';
 import LoadingIndicator from '../loading-indicator.react.js';
 import type { CSSStyle } from '../types/styles';
 
 type Props = {
   +blobURI: string,
   +encryptionKey: string,
   +type: EncryptedMediaType,
   +thumbnailBlobURI?: ?string,
   +thumbnailEncryptionKey?: ?string,
   +placeholderSrc?: ?string,
   +multimediaClassName?: string,
   +elementStyle?: ?Partial<CSSStyle>,
   // if provided, this component will be shown instead of the loading indicator
   +loadingIndicatorComponent?: React.Node,
   // if true, the loading indicator will not be shown
   +invisibleLoad?: boolean,
 };
 
 type Source = { +uri: string } | { +error: string };
 
 function EncryptedMultimedia(props: Props): React.Node {
   const {
     blobURI,
     encryptionKey,
     placeholderSrc,
     elementStyle,
     multimediaClassName,
     invisibleLoad,
   } = props;
 
   const [source, setSource] = React.useState<?Source>(null);
   const videoRef = React.useRef<?HTMLVideoElement>(null);
 
   React.useEffect(() => {
     let isMounted = true,
       uriToDispose;
     setSource(null);
 
     const loadDecrypted = async () => {
       const { result } = await decryptMedia(blobURI, encryptionKey);
       if (!isMounted) {
         return;
       }
 
       if (result.success) {
         const { uri } = result;
         setSource({ uri });
         uriToDispose = uri;
       } else {
         setSource({ error: result.reason });
       }
     };
 
-    loadDecrypted();
+    void loadDecrypted();
 
     return () => {
       isMounted = false;
       if (uriToDispose) {
         URL.revokeObjectURL(uriToDispose);
       }
     };
   }, [blobURI, encryptionKey]);
 
   // we need to update the video source when the source changes
   // because re-rendering the <source> element wouldn't reload parent <video>
   React.useEffect(() => {
     if (videoRef.current && source?.uri) {
       videoRef.current.src = source.uri;
       videoRef.current.load();
     }
   }, [source]);
 
   let loadingIndicator, errorIndicator;
 
   if (!source && !invisibleLoad) {
     loadingIndicator = props.loadingIndicatorComponent ?? (
       <LoadingIndicator
         status="loading"
         size="large"
         color="white"
         loadingClassName={css.loadingIndicator}
       />
     );
   }
 
   if (source?.error) {
     errorIndicator = <AlertCircleIcon className={css.uploadError} size={36} />;
   }
 
   let mediaNode;
   if (props.type === 'encrypted_photo') {
     mediaNode = (
       <img
         src={source?.uri ?? placeholderSrc}
         key={blobURI}
         className={multimediaClassName}
         style={elementStyle}
       />
     );
   } else {
     const { thumbnailBlobURI, thumbnailEncryptionKey } = props;
     invariant(
       thumbnailBlobURI && thumbnailEncryptionKey,
       'Thumbnail missing for encrypted video',
     );
 
     mediaNode = (
       <LoadableVideo
         uri={null}
         ref={videoRef}
         key={blobURI}
         thumbnailSource={{ thumbnailBlobURI, thumbnailEncryptionKey }}
         elementStyle={elementStyle}
         thumbHashDataURL={placeholderSrc}
         multimediaClassName={multimediaClassName}
       />
     );
   }
 
   return (
     <>
       {mediaNode}
       {loadingIndicator}
       {errorIndicator}
     </>
   );
 }
 
 export default EncryptedMultimedia;
diff --git a/web/media/loadable-video.react.js b/web/media/loadable-video.react.js
index ada0908ac..7781f6633 100644
--- a/web/media/loadable-video.react.js
+++ b/web/media/loadable-video.react.js
@@ -1,98 +1,98 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { decryptMedia } from './encryption-utils.js';
 import { preloadImage } from './media-utils.js';
 import type { CSSStyle } from '../types/styles';
 
 type ThumbnailSource =
   | {
       +thumbnailURI: string,
     }
   | {
       +thumbnailBlobURI: string,
       +thumbnailEncryptionKey: string,
     };
 type Props = {
   +uri: ?string,
   +thumbnailSource: ThumbnailSource,
   +thumbHashDataURL?: ?string,
   +elementStyle?: ?Partial<CSSStyle>,
   +multimediaClassName?: string,
 };
 
 function LoadableVideo(props: Props, videoRef: React.Ref<'video'>): React.Node {
   const {
     uri,
     thumbHashDataURL,
     thumbnailSource,
     elementStyle,
     multimediaClassName,
   } = props;
   const { thumbnailURI, thumbnailBlobURI, thumbnailEncryptionKey } =
     thumbnailSource;
 
   const [thumbnailImage, setThumbnailImage] = React.useState<?string>(null);
 
   React.useEffect(() => {
     let isMounted = true,
       uriToDispose;
     setThumbnailImage(null);
 
-    (async () => {
+    void (async () => {
       if (thumbnailURI) {
         await preloadImage(thumbnailURI);
         if (isMounted) {
           setThumbnailImage(thumbnailURI);
         }
         return;
       }
 
       invariant(
         thumbnailBlobURI && thumbnailEncryptionKey,
         'invalid encrypted thumbnail source',
       );
       const { result } = await decryptMedia(
         thumbnailBlobURI,
         thumbnailEncryptionKey,
       );
       if (isMounted && result.success) {
         setThumbnailImage(result.uri);
         uriToDispose = result.uri;
       }
     })();
 
     return () => {
       isMounted = false;
       if (uriToDispose) {
         URL.revokeObjectURL(uriToDispose);
       }
     };
   }, [thumbnailURI, thumbnailBlobURI, thumbnailEncryptionKey]);
 
   let videoSource;
   if (uri) {
     videoSource = <source src={uri} />;
   }
   const poster = thumbnailImage ?? thumbHashDataURL;
   return (
     <video
       controls
       poster={poster}
       className={multimediaClassName}
       style={elementStyle}
       ref={videoRef}
     >
       {videoSource}
     </video>
   );
 }
 
 const MemoizedLoadableVideo: React.AbstractComponent<Props, HTMLVideoElement> =
   React.memo<Props, HTMLVideoElement>(
     React.forwardRef<Props, HTMLVideoElement>(LoadableVideo),
   );
 
 export default MemoizedLoadableVideo;
diff --git a/web/media/media-utils.js b/web/media/media-utils.js
index d7be56b3f..4329a1cd1 100644
--- a/web/media/media-utils.js
+++ b/web/media/media-utils.js
@@ -1,274 +1,274 @@
 // @flow
 
 import { detect as detectBrowser } from 'detect-browser';
 import * as React from 'react';
 import { thumbHashToDataURL } from 'thumbhash';
 
 import { fetchableMediaURI } from 'lib/media/media-utils.js';
 import type {
   MediaType,
   Dimensions,
   MediaMissionStep,
   MediaMissionFailure,
 } from 'lib/types/media-types.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 
 import { probeFile } from './blob-utils.js';
 import { decryptThumbhashToDataURL } from './encryption-utils.js';
 import { getOrientation } from './image-utils.js';
 import { base64DecodeBuffer } from '../utils/base64-utils.js';
 
 async function preloadImage(uri: string): Promise<{
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: ?Image,
 }> {
   let image, exceptionMessage;
   const start = Date.now();
   const imageURI = fetchableMediaURI(uri);
   try {
     image = await new Promise<Image>((resolve, reject) => {
       const img = new Image();
       img.src = imageURI;
       img.onload = () => {
         resolve(img);
       };
       img.onerror = e => {
         reject(e);
       };
     });
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   const dimensions = image
     ? { height: image.height, width: image.width }
     : null;
   const step = {
     step: 'preload_image',
     success: !!image,
     exceptionMessage,
     time: Date.now() - start,
     uri: imageURI,
     dimensions,
   };
   return { steps: [step], result: image };
 }
 
 /**
  * Preloads a media resource (image or video) from a URI. This sends a HTTP GET
  * request to the URI to let the browser download it and cache it,
  * so further requests will be loaded from the cache.
  *
  * For raw images, use {@link preloadImage} instead.
  *
  * @param uri The URI of the media resource.
  * @returns Steps and the result of the preload. The preload is successful
  * if the HTTP response is OK (20x).
  */
 async function preloadMediaResource(uri: string): Promise<{
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: { +success: boolean },
 }> {
   const start = Date.now();
   const mediaURI = fetchableMediaURI(uri);
   let success, exceptionMessage;
   try {
     const response = await fetch(mediaURI);
     // we need to read the blob to make sure the browser caches it
     await response.blob();
     success = response.ok;
   } catch (e) {
     success = false;
     exceptionMessage = getMessageForException(e);
   }
 
   const step = {
     step: 'preload_resource',
     success,
     exceptionMessage,
     time: Date.now() - start,
     uri: mediaURI,
   };
 
   return { steps: [step], result: { success } };
 }
 
 type ProcessFileSuccess = {
   success: true,
   uri: string,
   dimensions: ?Dimensions,
 };
 
 const browser = detectBrowser();
 const exifRotate =
   !browser || (browser.name !== 'safari' && browser.name !== 'chrome');
 
 async function processFile(file: File): Promise<{
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: MediaMissionFailure | ProcessFileSuccess,
 }> {
   const initialURI = URL.createObjectURL(file);
   if (!exifRotate) {
     const { steps, result } = await preloadImage(initialURI);
     let dimensions;
     if (result) {
       const { width, height } = result;
       dimensions = { width, height };
     }
     return { steps, result: { success: true, uri: initialURI, dimensions } };
   }
 
   const [preloadResponse, orientationStep] = await Promise.all([
     preloadImage(initialURI),
     getOrientation(file),
   ]);
   const { steps: preloadSteps, result: image } = preloadResponse;
 
   const steps: MediaMissionStep[] = [...preloadSteps, orientationStep];
 
   if (!image) {
     return {
       steps,
       result: { success: true, uri: initialURI, dimensions: undefined },
     };
   }
 
   if (!orientationStep.success) {
     return { steps, result: { success: false, reason: 'exif_fetch_failed' } };
   }
   const { orientation } = orientationStep;
 
   const dimensions =
     !!orientation && orientation > 4
       ? { width: image.height, height: image.width }
       : { width: image.width, height: image.height };
   if (!orientation || orientation === 1) {
     return { steps, result: { success: true, uri: initialURI, dimensions } };
   }
 
   let reorientedBlob, reorientExceptionMessage;
   const reorientStart = Date.now();
   try {
     const canvas = document.createElement('canvas');
     const context = canvas.getContext('2d');
     canvas.height = dimensions.height;
     canvas.width = dimensions.width;
 
     if (orientation === 2) {
       context.transform(-1, 0, 0, 1, dimensions.width, 0);
     } else if (orientation === 3) {
       context.transform(-1, 0, 0, -1, dimensions.width, dimensions.height);
     } else if (orientation === 4) {
       context.transform(1, 0, 0, -1, 0, dimensions.height);
     } else if (orientation === 5) {
       context.transform(0, 1, 1, 0, 0, 0);
     } else if (orientation === 6) {
       context.transform(0, 1, -1, 0, dimensions.width, 0);
     } else if (orientation === 7) {
       context.transform(0, -1, -1, 0, dimensions.width, dimensions.height);
     } else if (orientation === 8) {
       context.transform(0, -1, 1, 0, 0, dimensions.height);
     } else {
       context.transform(1, 0, 0, 1, 0, 0);
     }
 
     context.drawImage(image, 0, 0);
     reorientedBlob = await new Promise<Blob>(resolve =>
       canvas.toBlob(blobResult => resolve(blobResult)),
     );
   } catch (e) {
     reorientExceptionMessage = getMessageForException(e);
   }
   URL.revokeObjectURL(initialURI);
   const uri = reorientedBlob && URL.createObjectURL(reorientedBlob);
   steps.push({
     step: 'reorient_image',
     success: !!reorientedBlob,
     exceptionMessage: reorientExceptionMessage,
     time: Date.now() - reorientStart,
     uri,
   });
 
   if (!uri) {
     return {
       steps,
       result: { success: false, reason: 'reorient_image_failed' },
     };
   }
   return { steps, result: { success: true, uri, dimensions } };
 }
 
 type FileValidationSuccess = {
   success: true,
   file: File,
   mediaType: MediaType,
   uri: string,
   dimensions: ?Dimensions,
 };
 async function validateFile(file: File): Promise<{
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: MediaMissionFailure | FileValidationSuccess,
 }> {
   const [probeResponse, processResponse] = await Promise.all([
     probeFile(file),
     processFile(file),
   ]);
   const { steps: probeSteps, result: probeResult } = probeResponse;
   const { steps: processSteps, result: processResult } = processResponse;
 
   const steps = [...probeSteps, ...processSteps];
 
   if (!probeResult.success) {
     return { steps, result: probeResult };
   }
   const { file: fixedFile, mediaType } = probeResult;
 
   if (!processResult.success) {
     return { steps, result: processResult };
   }
   const { dimensions, uri } = processResult;
 
   return {
     steps,
     result: {
       success: true,
       file: fixedFile,
       mediaType,
       uri,
       dimensions,
     },
   };
 }
 
 function usePlaceholder(thumbHash: ?string, encryptionKey: ?string): ?string {
   const [placeholder, setPlaceholder] = React.useState<?string>(null);
 
   React.useEffect(() => {
     if (!thumbHash) {
       setPlaceholder(null);
       return;
     }
 
     if (!encryptionKey) {
       const binaryThumbHash = base64DecodeBuffer(thumbHash);
       const placeholderImage = thumbHashToDataURL(binaryThumbHash);
       setPlaceholder(placeholderImage);
       return;
     }
 
-    (async () => {
+    void (async () => {
       try {
         const decryptedThumbHash = await decryptThumbhashToDataURL(
           thumbHash,
           encryptionKey,
         );
         setPlaceholder(decryptedThumbHash);
       } catch {
         setPlaceholder(null);
       }
     })();
   }, [thumbHash, encryptionKey]);
 
   return placeholder;
 }
 
 export { preloadImage, preloadMediaResource, validateFile, usePlaceholder };
diff --git a/web/modals/chat/message-results-modal.react.js b/web/modals/chat/message-results-modal.react.js
index 5c40ed0f1..093fc706a 100644
--- a/web/modals/chat/message-results-modal.react.js
+++ b/web/modals/chat/message-results-modal.react.js
@@ -1,162 +1,162 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   fetchPinnedMessageActionTypes,
   useFetchPinnedMessages,
 } from 'lib/actions/message-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import {
   messageListData,
   type ChatMessageInfoItem,
 } from 'lib/selectors/chat-selectors.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import {
   createMessageInfo,
   isInvalidPinSourceForThread,
   modifyItemForResultScreen,
 } from 'lib/shared/message-utils.js';
 import type { RawMessageInfo } from 'lib/types/message-types.js';
 import { type ThreadInfo } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import css from './message-results-modal.css';
 import MessageResult from '../../components/message-result.react.js';
 import LoadingIndicator from '../../loading-indicator.react.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import Modal from '../modal.react.js';
 
 type MessageResultsModalProps = {
   +threadInfo: ThreadInfo,
   +modalName: string,
 };
 
 const loadingStatusSelector = createLoadingStatusSelector(
   fetchPinnedMessageActionTypes,
 );
 
 function MessageResultsModal(props: MessageResultsModalProps): React.Node {
   const { threadInfo, modalName } = props;
   const { id: threadID } = threadInfo;
   const { popModal } = useModalContext();
   const [rawMessageResults, setRawMessageResults] = React.useState<
     $ReadOnlyArray<RawMessageInfo>,
   >([]);
 
   const callFetchPinnedMessages = useFetchPinnedMessages();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const userInfos = useSelector(state => state.userStore.userInfos);
   const loadingStatus = useSelector(loadingStatusSelector);
 
   React.useEffect(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       fetchPinnedMessageActionTypes,
       (async () => {
         const result = await callFetchPinnedMessages({ threadID });
         setRawMessageResults(result.pinnedMessages);
       })(),
     );
   }, [dispatchActionPromise, callFetchPinnedMessages, threadID]);
 
   const translatedMessageResults = React.useMemo(() => {
     const threadInfos = { [threadID]: threadInfo };
 
     return rawMessageResults
       .map(messageInfo =>
         createMessageInfo(messageInfo, null, userInfos, threadInfos),
       )
       .filter(Boolean);
   }, [rawMessageResults, userInfos, threadID, threadInfo]);
 
   const chatMessageInfos = useSelector(
     messageListData(threadInfo.id, translatedMessageResults),
   );
 
   const sortedUniqueChatMessageInfoItems = React.useMemo(() => {
     if (!chatMessageInfos) {
       return ([]: ChatMessageInfoItem[]);
     }
 
     const chatMessageInfoItems = chatMessageInfos.filter(
       item =>
         item.itemType === 'message' &&
         item.isPinned &&
         !isInvalidPinSourceForThread(item.messageInfo, threadInfo),
     );
 
     // By the nature of using messageListData and passing in
     // the desired translatedMessageResults as additional
     // messages, we will have duplicate ChatMessageInfoItems.
     const uniqueChatMessageInfoItemsMap = new Map<
       string,
       ChatMessageInfoItem,
     >();
     chatMessageInfoItems.forEach(
       item =>
         item.messageInfo &&
         item.messageInfo.id &&
         uniqueChatMessageInfoItemsMap.set(item.messageInfo.id, item),
     );
 
     // Push the items in the order they appear in the rawMessageResults
     // since the messages fetched from the server are already sorted
     // in the order of pin_time (newest first).
     const sortedChatMessageInfoItems = [];
     for (let i = 0; i < rawMessageResults.length; i++) {
       const rawMessageID = rawMessageResults[i].id;
       if (!rawMessageID) {
         continue;
       }
       sortedChatMessageInfoItems.push(
         uniqueChatMessageInfoItemsMap.get(rawMessageID),
       );
     }
 
     return sortedChatMessageInfoItems;
   }, [chatMessageInfos, rawMessageResults, threadInfo]);
 
   const modifiedItems = React.useMemo(
     () =>
       sortedUniqueChatMessageInfoItems
         .filter(Boolean)
         .map(item => modifyItemForResultScreen(item)),
     [sortedUniqueChatMessageInfoItems],
   );
 
   const messageResultsToDisplay = React.useMemo(() => {
     const items = modifiedItems.map(item => (
       <MessageResult
         key={item.messageInfo.id}
         item={item}
         threadInfo={threadInfo}
         scrollable={false}
       />
     ));
     return <>{items}</>;
   }, [modifiedItems, threadInfo]);
 
   const loadingIndicator = React.useMemo(() => {
     if (loadingStatus === 'loading') {
       return (
         <div className={css.loadingIndicator}>
           <LoadingIndicator status="loading" size="medium" />
         </div>
       );
     }
     return null;
   }, [loadingStatus]);
 
   return (
     <Modal name={modalName} onClose={popModal} size="large">
       <hr className={css.separator} />
       <div className={css.topSpace}>{loadingIndicator}</div>
       <div className={css.messageResultsContainer}>
         {messageResultsToDisplay}
       </div>
     </Modal>
   );
 }
 
 export default MessageResultsModal;
diff --git a/web/modals/chat/toggle-pin-modal.react.js b/web/modals/chat/toggle-pin-modal.react.js
index c34127fe7..4b2a9955c 100644
--- a/web/modals/chat/toggle-pin-modal.react.js
+++ b/web/modals/chat/toggle-pin-modal.react.js
@@ -1,130 +1,130 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   useToggleMessagePin,
   toggleMessagePinActionTypes,
 } from 'lib/actions/message-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import type { ChatMessageInfoItem } from 'lib/selectors/chat-selectors.js';
 import { modifyItemForResultScreen } from 'lib/shared/message-utils.js';
 import type { RawMessageInfo } from 'lib/types/message-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import css from './toggle-pin-modal.css';
 import Button, { buttonThemes } from '../../components/button.react.js';
 import MessageResult from '../../components/message-result.react.js';
 import Modal from '../modal.react.js';
 
 type TogglePinModalProps = {
   +item: ChatMessageInfoItem,
   +threadInfo: ThreadInfo,
 };
 
 function TogglePinModal(props: TogglePinModalProps): React.Node {
   const { item, threadInfo } = props;
   const { messageInfo, isPinned } = item;
   const { popModal } = useModalContext();
 
   const callToggleMessagePin = useToggleMessagePin();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const modalInfo = React.useMemo(() => {
     if (isPinned) {
       return {
         name: 'Remove Pinned Message',
         action: 'unpin',
         confirmationText:
           'Are you sure you want to remove this pinned message?',
         buttonText: 'Remove Pinned Message',
         buttonColor: buttonThemes.danger,
       };
     }
 
     return {
       name: 'Pin Message',
       action: 'pin',
       confirmationText: `You may pin this message to the channel 
         you are currently viewing. To unpin a message, select the pinned 
         messages icon in the channel.`,
       buttonText: 'Pin Message',
       buttonColor: buttonThemes.standard,
     };
   }, [isPinned]);
 
   // We want to remove inline engagement (threadCreatedFromMessage / reactions)
   // and the message header (startsConversation). We also want to set isViewer
   // to false so that the message is left-aligned and uncolored.
   const modifiedItem = React.useMemo(() => {
     if (item.messageInfoType !== 'composable') {
       return item;
     }
 
     const strippedItem = {
       ...item,
       threadCreatedFromMessage: undefined,
       reactions: {},
     };
     return modifyItemForResultScreen(strippedItem);
   }, [item]);
 
   const onClick = React.useCallback(() => {
     const createToggleMessagePinPromise = async () => {
       invariant(messageInfo.id, 'messageInfo.id should be defined');
       const result = await callToggleMessagePin({
         messageID: messageInfo.id,
         action: modalInfo.action,
       });
       return ({
         newMessageInfos: result.newMessageInfos,
         threadID: result.threadID,
       }: {
         +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
         +threadID: string,
       });
     };
 
-    dispatchActionPromise(
+    void dispatchActionPromise(
       toggleMessagePinActionTypes,
       createToggleMessagePinPromise(),
     );
     popModal();
   }, [
     modalInfo,
     callToggleMessagePin,
     dispatchActionPromise,
     messageInfo.id,
     popModal,
   ]);
 
   return (
     <Modal name={modalInfo.name} onClose={popModal} size="large">
       <div className={css.confirmationText}>{modalInfo.confirmationText}</div>
       <div className={css.messageContainer}>
         <MessageResult
           item={modifiedItem}
           threadInfo={threadInfo}
           scrollable={true}
         />
       </div>
       <div className={css.buttonContainer}>
         <Button
           variant="filled"
           className={css.togglePinButton}
           buttonColor={modalInfo.buttonColor}
           onClick={onClick}
         >
           {modalInfo.buttonText}
         </Button>
         <div className={css.cancelButton} onClick={popModal}>
           Cancel
         </div>
       </div>
     </Modal>
   );
 }
 
 export default TogglePinModal;
diff --git a/web/modals/history/history-entry.react.js b/web/modals/history/history-entry.react.js
index 21635f61b..cb0385ed8 100644
--- a/web/modals/history/history-entry.react.js
+++ b/web/modals/history/history-entry.react.js
@@ -1,188 +1,188 @@
 // @flow
 
 import classNames from 'classnames';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   restoreEntryActionTypes,
   useRestoreEntry,
 } from 'lib/actions/entry-actions.js';
 import { useENSNames } from 'lib/hooks/ens-cache.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { colorIsDark } from 'lib/shared/color-utils.js';
 import {
   type EntryInfo,
   type RestoreEntryInfo,
   type RestoreEntryResult,
   type CalendarQuery,
   type RestoreEntryPayload,
 } from 'lib/types/entry-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { ResolvedThreadInfo } from 'lib/types/thread-types.js';
 import type { UserInfo } from 'lib/types/user-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { useResolvedThreadInfo } from 'lib/utils/entity-helpers.js';
 
 import css from './history.css';
 import LoadingIndicator from '../../loading-indicator.react.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { nonThreadCalendarQuery } from '../../selectors/nav-selectors.js';
 
 type BaseProps = {
   +entryInfo: EntryInfo,
   +onClick: (entryID: string) => void,
   +animateAndLoadEntry: (entryID: string) => void,
 };
 type Props = {
   ...BaseProps,
   +threadInfo: ResolvedThreadInfo,
   +loggedIn: boolean,
   +restoreLoadingStatus: LoadingStatus,
   +calendarQuery: () => CalendarQuery,
   +dispatchActionPromise: DispatchActionPromise,
   +restoreEntry: (info: RestoreEntryInfo) => Promise<RestoreEntryResult>,
   +creator: ?UserInfo,
 };
 
 class HistoryEntry extends React.PureComponent<Props> {
   render(): React.Node {
     let deleted = null;
     if (this.props.entryInfo.deleted) {
       let restore = null;
       if (this.props.loggedIn) {
         restore = (
           <span>
             <span className={css.restoreEntryLabel}>
               (
               <a href="#" onClick={this.onRestore}>
                 restore
               </a>
               )
             </span>
             <LoadingIndicator
               status={this.props.restoreLoadingStatus}
               color="black"
               loadingClassName={css.restoreLoading}
               errorClassName={css.restoreError}
             />
           </span>
         );
       }
       deleted = (
         <span className={css.deletedEntry}>
           <span className={css.deletedEntryLabel}>deleted</span>
           {restore}
         </span>
       );
     }
 
     const textClasses = classNames({
       [css.entry]: true,
       [css.darkEntry]: colorIsDark(this.props.threadInfo.color),
     });
     const textStyle = { backgroundColor: '#' + this.props.threadInfo.color };
     const creator = this.props.creator?.username ? (
       <span className={css.entryUsername}>{this.props.creator.username}</span>
     ) : (
       'anonymous'
     );
 
     return (
       <li>
         <div className={textClasses} style={textStyle}>
           {this.props.entryInfo.text}
         </div>
         <span className={css.entryAuthor}>
           {'created by '}
           {creator}
         </span>
         <span className={css.entryThread}>{this.props.threadInfo.uiName}</span>
         <div className={css.clear} />
         {deleted}
         <a
           href="#"
           className={css.revisionHistoryButton}
           onClick={this.onClick}
         >
           revision history &gt;
         </a>
         <div className={css.clear} />
       </li>
     );
   }
 
   onRestore = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     const entryID = this.props.entryInfo.id;
     invariant(entryID, 'entryInfo.id (serverID) should be set');
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       restoreEntryActionTypes,
       this.restoreEntryAction(),
       { customKeyName: `${restoreEntryActionTypes.started}:${entryID}` },
     );
   };
 
   onClick = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     const entryID = this.props.entryInfo.id;
     invariant(entryID, 'entryInfo.id (serverID) should be set');
     this.props.onClick(entryID);
   };
 
   async restoreEntryAction(): Promise<RestoreEntryPayload> {
     const entryID = this.props.entryInfo.id;
     invariant(entryID, 'entry should have ID');
     const result = await this.props.restoreEntry({
       entryID,
       calendarQuery: this.props.calendarQuery(),
     });
     this.props.animateAndLoadEntry(entryID);
     return { ...result, threadID: this.props.threadInfo.id };
   }
 }
 
 const ConnectedHistoryEntry: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedHistoryEntry(props) {
     const entryID = props.entryInfo.id;
     invariant(entryID, 'entryInfo.id (serverID) should be set');
     const unresolvedThreadInfo = useSelector(
       state => threadInfoSelector(state)[props.entryInfo.threadID],
     );
     const threadInfo = useResolvedThreadInfo(unresolvedThreadInfo);
     const loggedIn = useSelector(
       state =>
         !!(state.currentUserInfo && !state.currentUserInfo.anonymous && true),
     );
     const restoreLoadingStatus = useSelector(
       createLoadingStatusSelector(
         restoreEntryActionTypes,
         `${restoreEntryActionTypes.started}:${entryID}`,
       ),
     );
     const calenderQuery = useSelector(nonThreadCalendarQuery);
     const callRestoreEntry = useRestoreEntry();
     const dispatchActionPromise = useDispatchActionPromise();
 
     const { creator } = props.entryInfo;
     const [creatorWithENSName] = useENSNames([creator]);
 
     return (
       <HistoryEntry
         {...props}
         threadInfo={threadInfo}
         loggedIn={loggedIn}
         restoreLoadingStatus={restoreLoadingStatus}
         calendarQuery={calenderQuery}
         dispatchActionPromise={dispatchActionPromise}
         restoreEntry={callRestoreEntry}
         creator={creatorWithENSName}
       />
     );
   });
 
 export default ConnectedHistoryEntry;
diff --git a/web/modals/history/history-modal.react.js b/web/modals/history/history-modal.react.js
index 0711dcf71..b3d0be17d 100644
--- a/web/modals/history/history-modal.react.js
+++ b/web/modals/history/history-modal.react.js
@@ -1,287 +1,287 @@
 // @flow
 
 import classNames from 'classnames';
 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 _unionBy from 'lodash/fp/unionBy.js';
 import * as React from 'react';
 
 import {
   fetchEntriesActionTypes,
   useFetchEntries,
   fetchRevisionsForEntryActionTypes,
   useFetchRevisionsForEntry,
 } from 'lib/actions/entry-actions.js';
 import type { FetchRevisionsForEntryInput } from 'lib/actions/entry-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { nonExcludeDeletedCalendarFiltersSelector } from 'lib/selectors/calendar-filter-selectors.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type {
   EntryInfo,
   CalendarQuery,
   FetchEntryInfosResult,
   FetchRevisionsForEntryPayload,
 } from 'lib/types/entry-types.js';
 import { type CalendarFilter } from 'lib/types/filter-types.js';
 import type {
   HistoryMode,
   HistoryRevisionInfo,
 } from 'lib/types/history-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { prettyDateWithoutDay } from 'lib/utils/date-utils.js';
 
 import HistoryEntry from './history-entry.react.js';
 import HistoryRevision from './history-revision.react.js';
 import css from './history.css';
 import LoadingIndicator from '../../loading-indicator.react.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { allDaysToEntries } from '../../selectors/entry-selectors.js';
 import Modal from '../modal.react.js';
 
 type BaseProps = {
   +mode: HistoryMode,
   +dayString: string,
   +currentEntryID?: ?string,
 };
 type Props = {
   ...BaseProps,
   +entryInfos: ?(EntryInfo[]),
   +dayLoadingStatus: LoadingStatus,
   +entryLoadingStatus: LoadingStatus,
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +dispatchActionPromise: DispatchActionPromise,
   +fetchEntries: (
     calendarQuery: CalendarQuery,
   ) => Promise<FetchEntryInfosResult>,
   +fetchRevisionsForEntry: (
     input: FetchRevisionsForEntryInput,
   ) => Promise<$ReadOnlyArray<HistoryRevisionInfo>>,
   +onClose: () => void,
 };
 type State = {
   +mode: HistoryMode,
   +animateModeChange: boolean,
   +currentEntryID: ?string,
   +revisions: $ReadOnlyArray<HistoryRevisionInfo>,
 };
 class HistoryModal extends React.PureComponent<Props, State> {
   static defaultProps: Partial<Props> = { currentEntryID: null };
 
   constructor(props: Props) {
     super(props);
     this.state = {
       mode: props.mode,
       animateModeChange: false,
       currentEntryID: props.currentEntryID,
       revisions: [],
     };
   }
 
   componentDidMount() {
     this.loadDay();
     if (this.state.mode === 'entry') {
       invariant(this.state.currentEntryID, 'entry ID should be set');
       this.loadEntry(this.state.currentEntryID);
     }
   }
 
   render(): React.Node {
     let allHistoryButton = null;
     if (this.state.mode === 'entry') {
       allHistoryButton = (
         <a
           href="#"
           onClick={this.onClickAllEntries}
           className={css.allHistoryButton}
         >
           &lt; all entries
         </a>
       );
     }
     const prettyDate = prettyDateWithoutDay(this.props.dayString);
     const loadingStatus =
       this.state.mode === 'day'
         ? this.props.dayLoadingStatus
         : this.props.entryLoadingStatus;
 
     let entries;
     const entryInfos = this.props.entryInfos;
     if (entryInfos) {
       entries = _flow(
         _filter((entryInfo: EntryInfo) => entryInfo.id),
         _map((entryInfo: EntryInfo) => {
           const serverID = entryInfo.id;
           invariant(serverID, 'serverID should be set');
           return (
             <HistoryEntry
               entryInfo={entryInfo}
               onClick={this.onClickEntry}
               animateAndLoadEntry={this.animateAndLoadEntry}
               key={serverID}
             />
           );
         }),
       )(entryInfos);
     } else {
       entries = [];
     }
 
     const revisionInfos = this.state.revisions.filter(
       revisionInfo => revisionInfo.entryID === this.state.currentEntryID,
     );
     const revisions = [];
     for (let i = 0; i < revisionInfos.length; i++) {
       const revisionInfo = revisionInfos[i];
       const nextRevisionInfo = revisionInfos[i + 1];
       const isDeletionOrRestoration =
         nextRevisionInfo !== undefined &&
         revisionInfo.deleted !== nextRevisionInfo.deleted;
       revisions.push(
         <HistoryRevision
           revisionInfo={revisionInfo}
           isDeletionOrRestoration={isDeletionOrRestoration}
           key={revisionInfo.id}
         />,
       );
     }
 
     const animate = this.state.animateModeChange;
     const dayMode = this.state.mode === 'day';
     const dayClasses = classNames({
       [css.dayHistory]: true,
       [css.dayHistoryVisible]: dayMode && !animate,
       [css.dayHistoryInvisible]: !dayMode && !animate,
       [css.dayHistoryVisibleAnimate]: dayMode && animate,
       [css.dayHistoryInvisibleAnimate]: !dayMode && animate,
     });
     const entryMode = this.state.mode === 'entry';
     const entryClasses = classNames({
       [css.entryHistory]: true,
       [css.entryHistoryVisible]: entryMode && !animate,
       [css.entryHistoryInvisible]: !entryMode && !animate,
       [css.entryHistoryVisibleAnimate]: entryMode && animate,
       [css.entryHistoryInvisibleAnimate]: !entryMode && animate,
     });
 
     return (
       <Modal name="History" onClose={this.props.onClose}>
         <div className={css.modalBody}>
           <div className={css.header}>
             {allHistoryButton}
             <span className={css.date}>{prettyDate}</span>
             <LoadingIndicator
               status={loadingStatus}
               color="black"
               loadingClassName={css.loading}
               errorClassName={css.error}
             />
           </div>
           <div className={dayClasses}>
             <ul>{entries}</ul>
           </div>
           <div className={entryClasses}>
             <ul>{revisions}</ul>
           </div>
         </div>
       </Modal>
     );
   }
 
   loadDay() {
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       fetchEntriesActionTypes,
       this.props.fetchEntries({
         startDate: this.props.dayString,
         endDate: this.props.dayString,
         filters: this.props.calendarFilters,
       }),
     );
   }
 
   loadEntry(entryID: string) {
     this.setState({ mode: 'entry', currentEntryID: entryID });
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       fetchRevisionsForEntryActionTypes,
       this.fetchRevisionsForEntryAction(entryID),
     );
   }
 
   async fetchRevisionsForEntryAction(
     entryID: string,
   ): Promise<FetchRevisionsForEntryPayload> {
     const result = await this.props.fetchRevisionsForEntry({ entryID });
     this.setState(prevState => {
       // This merge here will preserve time ordering correctly
       const revisions = _unionBy('id')(result)(prevState.revisions);
       return { ...prevState, revisions };
     });
     return {
       entryID,
       text: result[0].text,
       deleted: result[0].deleted,
     };
   }
 
   onClickEntry = (entryID: string) => {
     this.setState({ animateModeChange: true });
     this.loadEntry(entryID);
   };
 
   onClickAllEntries = (event: SyntheticEvent<HTMLAnchorElement>) => {
     event.preventDefault();
     this.setState({
       mode: 'day',
       animateModeChange: true,
     });
   };
 
   animateAndLoadEntry = (entryID: string) => {
     this.setState({ animateModeChange: true });
     this.loadEntry(entryID);
   };
 }
 
 const dayLoadingStatusSelector = createLoadingStatusSelector(
   fetchEntriesActionTypes,
 );
 const entryLoadingStatusSelector = createLoadingStatusSelector(
   fetchRevisionsForEntryActionTypes,
 );
 
 const ConnectedHistoryModal: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedHistoryModal(props) {
     const entryInfos = useSelector(
       state => allDaysToEntries(state)[props.dayString],
     );
     const dayLoadingStatus = useSelector(dayLoadingStatusSelector);
     const entryLoadingStatus = useSelector(entryLoadingStatusSelector);
     const calendarFilters = useSelector(
       nonExcludeDeletedCalendarFiltersSelector,
     );
     const callFetchEntries = useFetchEntries();
     const callFetchRevisionsForEntry = useFetchRevisionsForEntry();
     const dispatchActionPromise = useDispatchActionPromise();
     const modalContext = useModalContext();
 
     return (
       <HistoryModal
         {...props}
         entryInfos={entryInfos}
         dayLoadingStatus={dayLoadingStatus}
         entryLoadingStatus={entryLoadingStatus}
         calendarFilters={calendarFilters}
         fetchEntries={callFetchEntries}
         fetchRevisionsForEntry={callFetchRevisionsForEntry}
         dispatchActionPromise={dispatchActionPromise}
         onClose={modalContext.popModal}
       />
     );
   });
 
 export default ConnectedHistoryModal;
diff --git a/web/modals/threads/gallery/thread-settings-media-gallery.react.js b/web/modals/threads/gallery/thread-settings-media-gallery.react.js
index 4ea81a680..5162f0cc3 100644
--- a/web/modals/threads/gallery/thread-settings-media-gallery.react.js
+++ b/web/modals/threads/gallery/thread-settings-media-gallery.react.js
@@ -1,192 +1,192 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { useFetchThreadMedia } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import {
   encryptedMediaBlobURI,
   encryptedVideoThumbnailBlobURI,
 } from 'lib/media/media-utils.js';
 import type { Media } from 'lib/types/media-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 
 import GalleryItem from './thread-settings-media-gallery-item.react.js';
 import css from './thread-settings-media-gallery.css';
 import Tabs from '../../../components/tabs.react.js';
 import MultimediaModal from '../../../media/multimedia-modal.react.js';
 import Modal from '../../modal.react.js';
 
 type MediaGalleryTab = 'All' | 'Images' | 'Videos';
 
 type ThreadSettingsMediaGalleryModalProps = {
   +onClose: () => void,
   +parentThreadInfo: ThreadInfo,
   +limit: number,
   +activeTab: MediaGalleryTab,
 };
 
 function ThreadSettingsMediaGalleryModal(
   props: ThreadSettingsMediaGalleryModalProps,
 ): React.Node {
   const { pushModal } = useModalContext();
   const { onClose, parentThreadInfo, limit, activeTab } = props;
   const { id: threadID } = parentThreadInfo;
   const modalName = 'Media';
 
   const callFetchThreadMedia = useFetchThreadMedia();
   const [mediaInfos, setMediaInfos] = React.useState<$ReadOnlyArray<Media>>([]);
   const [tab, setTab] = React.useState<MediaGalleryTab>(activeTab);
 
   React.useEffect(() => {
     const fetchData = async () => {
       const result = await callFetchThreadMedia({
         threadID,
         limit,
         offset: 0,
       });
       setMediaInfos(result.media);
     };
-    fetchData();
+    void fetchData();
   }, [callFetchThreadMedia, threadID, limit]);
 
   const onClick = React.useCallback(
     (media: Media) => {
       const thumbHash = media.thumbnailThumbHash ?? media.thumbHash;
       let mediaInfo = {
         thumbHash,
         dimensions: media.dimensions,
       };
       if (media.type === 'photo' || media.type === 'video') {
         const { uri, thumbnailURI } = media;
         mediaInfo = {
           ...mediaInfo,
           type: media.type,
           uri,
           thumbnailURI,
         };
       } else {
         const { encryptionKey, thumbnailEncryptionKey } = media;
         const thumbnailBlobURI =
           media.type === 'encrypted_video'
             ? encryptedVideoThumbnailBlobURI(media)
             : null;
         mediaInfo = {
           ...mediaInfo,
           type: media.type,
           blobURI: encryptedMediaBlobURI(media),
           encryptionKey,
           thumbnailBlobURI,
           thumbnailEncryptionKey,
         };
       }
       pushModal(<MultimediaModal media={mediaInfo} />);
     },
     [pushModal],
   );
 
   const mediaGalleryItems = React.useMemo(() => {
     let filteredMediaInfos = mediaInfos;
     if (tab === 'Images') {
       filteredMediaInfos = mediaInfos.filter(
         mediaInfo =>
           mediaInfo.type === 'photo' || mediaInfo.type === 'encrypted_photo',
       );
     } else if (tab === 'Videos') {
       filteredMediaInfos = mediaInfos.filter(
         mediaInfo =>
           mediaInfo.type === 'video' || mediaInfo.type === 'encrypted_video',
       );
     }
 
     return filteredMediaInfos.map((media, i) => {
       let imageSource;
       if (media.type === 'photo') {
         imageSource = {
           kind: 'plain',
           uri: media.uri,
           thumbHash: media.thumbHash,
         };
       } else if (media.type === 'video') {
         imageSource = {
           kind: 'plain',
           uri: media.thumbnailURI,
           thumbHash: media.thumbnailThumbHash,
         };
       } else if (media.type === 'encrypted_photo') {
         imageSource = {
           kind: 'encrypted',
           blobURI: encryptedMediaBlobURI(media),
           encryptionKey: media.encryptionKey,
           thumbHash: media.thumbHash,
         };
       } else {
         imageSource = {
           kind: 'encrypted',
           blobURI: encryptedVideoThumbnailBlobURI(media),
           encryptionKey: media.thumbnailEncryptionKey,
           thumbHash: media.thumbnailThumbHash,
         };
       }
 
       return (
         <GalleryItem
           key={i}
           onClick={() => onClick(media)}
           imageSource={imageSource}
           imageCSSClass={css.media}
           imageContainerCSSClass={css.mediaContainer}
         />
       );
     });
   }, [tab, mediaInfos, onClick]);
 
   const handleScroll = React.useCallback(
     async (event: SyntheticEvent<HTMLDivElement>) => {
       const container = event.target;
       invariant(container instanceof HTMLDivElement, 'target not div');
       // Load more data when the user is within 1000 pixels of the end
       const buffer = 1000;
 
       if (
         container.scrollHeight - container.scrollTop >
         container.clientHeight + buffer
       ) {
         return;
       }
 
       const result = await callFetchThreadMedia({
         threadID,
         limit,
         offset: mediaInfos.length,
       });
       setMediaInfos([...mediaInfos, ...result.media]);
     },
     [callFetchThreadMedia, threadID, limit, mediaInfos],
   );
 
   return (
     <Modal name={modalName} onClose={onClose} size="large">
       <Tabs.Container activeTab={tab} setTab={setTab}>
         <Tabs.Item id="All" header="All">
           <div className={css.container} onScroll={handleScroll}>
             {mediaGalleryItems}
           </div>
         </Tabs.Item>
         <Tabs.Item id="Images" header="Images">
           <div className={css.container} onScroll={handleScroll}>
             {mediaGalleryItems}
           </div>
         </Tabs.Item>
         <Tabs.Item id="Videos" header="Videos">
           <div className={css.container} onScroll={handleScroll}>
             {mediaGalleryItems}
           </div>
         </Tabs.Item>
       </Tabs.Container>
     </Modal>
   );
 }
 
 export default ThreadSettingsMediaGalleryModal;
diff --git a/web/modals/threads/members/add-members-modal.react.js b/web/modals/threads/members/add-members-modal.react.js
index 94956158a..89531eb85 100644
--- a/web/modals/threads/members/add-members-modal.react.js
+++ b/web/modals/threads/members/add-members-modal.react.js
@@ -1,199 +1,199 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from 'lib/actions/thread-actions.js';
 import { useENSNames } from 'lib/hooks/ens-cache.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import {
   userSearchIndexForPotentialMembers,
   userInfoSelectorForPotentialMembers,
 } from 'lib/selectors/user-selectors.js';
 import { getPotentialMemberItems } from 'lib/shared/search-utils.js';
 import { threadActualMembers } from 'lib/shared/thread-utils.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import AddMembersListContent from './add-members-list-content.react.js';
 import css from './members-modal.css';
 import Button from '../../../components/button.react.js';
 import Label from '../../../components/label.react.js';
 import { useSelector } from '../../../redux/redux-utils.js';
 import SearchModal from '../../search-modal.react.js';
 
 type ContentProps = {
   +searchText: string,
   +threadID: string,
   +onClose: () => void,
 };
 
 function AddMembersModalContent(props: ContentProps): React.Node {
   const { searchText, threadID, onClose } = props;
 
   const [pendingUsersToAdd, setPendingUsersToAdd] = React.useState<
     $ReadOnlySet<string>,
   >(new Set());
 
   const threadInfo = useSelector(state => threadInfoSelector(state)[threadID]);
   const { parentThreadID, community } = threadInfo;
   const parentThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
   const communityThreadInfo = useSelector(state =>
     community ? threadInfoSelector(state)[community] : null,
   );
   const otherUserInfos = useSelector(userInfoSelectorForPotentialMembers);
   const userSearchIndex = useSelector(userSearchIndexForPotentialMembers);
   const excludeUserIDs = React.useMemo(
     () =>
       threadActualMembers(threadInfo.members).concat(
         Array.from(pendingUsersToAdd),
       ),
     [pendingUsersToAdd, threadInfo.members],
   );
 
   const userSearchResults = React.useMemo(
     () =>
       getPotentialMemberItems({
         text: searchText,
         userInfos: otherUserInfos,
         searchIndex: userSearchIndex,
         excludeUserIDs,
         inputParentThreadInfo: parentThreadInfo,
         inputCommunityThreadInfo: communityThreadInfo,
         threadType: threadInfo.type,
       }),
     [
       communityThreadInfo,
       excludeUserIDs,
       otherUserInfos,
       parentThreadInfo,
       searchText,
       threadInfo.type,
       userSearchIndex,
     ],
   );
   const userSearchResultsWithENSNames = useENSNames(userSearchResults);
 
   const onSwitchUser = React.useCallback(
     (userID: string) =>
       setPendingUsersToAdd(users => {
         const newUsers = new Set(users);
         if (newUsers.has(userID)) {
           newUsers.delete(userID);
         } else {
           newUsers.add(userID);
         }
         return newUsers;
       }),
     [],
   );
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useChangeThreadSettings();
 
   const addUsers = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       changeThreadSettingsActionTypes,
       callChangeThreadSettings({
         threadID,
         changes: { newMemberIDs: Array.from(pendingUsersToAdd) },
       }),
     );
     onClose();
   }, [
     callChangeThreadSettings,
     dispatchActionPromise,
     onClose,
     pendingUsersToAdd,
     threadID,
   ]);
 
   const pendingUserInfos = React.useMemo(
     () =>
       Array.from(pendingUsersToAdd)
         .map(userID => ({
           id: userID,
           username: otherUserInfos[userID].username,
         }))
         .sort((a, b) => a.username.localeCompare(b.username)),
     [otherUserInfos, pendingUsersToAdd],
   );
   const pendingUserInfosWithENSNames = useENSNames(pendingUserInfos);
 
   const labelItems = React.useMemo(() => {
     if (!pendingUserInfosWithENSNames.length) {
       return null;
     }
     return (
       <div className={css.addMembersPendingList}>
         {pendingUserInfosWithENSNames.map(userInfo => (
           <Label key={userInfo.id} onClose={() => onSwitchUser(userInfo.id)}>
             {userInfo.username}
           </Label>
         ))}
       </div>
     );
   }, [onSwitchUser, pendingUserInfosWithENSNames]);
 
   return (
     <div className={css.addMembersContent}>
       {labelItems}
       <div className={css.addMembersListContainer}>
         <AddMembersListContent
           userListItems={userSearchResultsWithENSNames}
           switchUser={onSwitchUser}
           pendingUsersToAdd={pendingUsersToAdd}
           hasParentThread={!!threadInfo.parentThreadID}
         />
       </div>
       <div className={css.addMembersFooter}>
         <Button onClick={onClose} variant="outline">
           Cancel
         </Button>
         <Button
           disabled={!pendingUsersToAdd.size}
           variant="filled"
           onClick={addUsers}
         >
           Add selected members
         </Button>
       </div>
     </div>
   );
 }
 
 type Props = {
   +threadID: string,
   +onClose: () => void,
 };
 
 function AddMembersModal(props: Props): React.Node {
   const { threadID, onClose } = props;
 
   const addMembersModalContent = React.useCallback(
     (searchText: string) => (
       <AddMembersModalContent
         searchText={searchText}
         threadID={threadID}
         onClose={onClose}
       />
     ),
     [onClose, threadID],
   );
 
   return (
     <SearchModal
       name="Add members"
       searchPlaceholder="Search members"
       onClose={onClose}
       size="fit-content"
     >
       {addMembersModalContent}
     </SearchModal>
   );
 }
 
 export { AddMembersModal, AddMembersModalContent };
diff --git a/web/modals/threads/members/change-member-role-modal.react.js b/web/modals/threads/members/change-member-role-modal.react.js
index aeee7020a..5646add70 100644
--- a/web/modals/threads/members/change-member-role-modal.react.js
+++ b/web/modals/threads/members/change-member-role-modal.react.js
@@ -1,153 +1,153 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   useChangeThreadMemberRoles,
   changeThreadMemberRolesActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import { otherUsersButNoOtherAdmins } from 'lib/selectors/thread-selectors.js';
 import { roleIsAdminRole } from 'lib/shared/thread-utils.js';
 import type { RelativeMemberInfo, ThreadInfo } from 'lib/types/thread-types';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { values } from 'lib/utils/objects.js';
 
 import css from './change-member-role-modal.css';
 import UserAvatar from '../../../avatars/user-avatar.react.js';
 import Button, { buttonThemes } from '../../../components/button.react.js';
 import Dropdown from '../../../components/dropdown.react.js';
 import { useSelector } from '../../../redux/redux-utils.js';
 import Modal from '../../modal.react.js';
 import UnsavedChangesModal from '../../unsaved-changes-modal.react.js';
 
 type ChangeMemberRoleModalProps = {
   +memberInfo: RelativeMemberInfo,
   +threadInfo: ThreadInfo,
 };
 
 function ChangeMemberRoleModal(props: ChangeMemberRoleModalProps): React.Node {
   const { memberInfo, threadInfo } = props;
   const { pushModal, popModal } = useModalContext();
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadMemberRoles = useChangeThreadMemberRoles();
   const otherUsersButNoOtherAdminsValue = useSelector(
     otherUsersButNoOtherAdmins(threadInfo.id),
   );
 
   const roleOptions = React.useMemo(
     () =>
       values(threadInfo.roles).map(role => ({
         id: role.id,
         name: role.name,
       })),
     [threadInfo.roles],
   );
 
   const initialSelectedRole = memberInfo.role;
   invariant(initialSelectedRole, "Member's role must be defined");
 
   const [selectedRole, setSelectedRole] = React.useState(initialSelectedRole);
 
   const onCloseModal = React.useCallback(() => {
     if (selectedRole === initialSelectedRole) {
       popModal();
       return;
     }
 
     pushModal(<UnsavedChangesModal />);
   }, [initialSelectedRole, popModal, pushModal, selectedRole]);
 
   const disabledRoleChangeMessage = React.useMemo(() => {
     const memberIsAdmin = roleIsAdminRole(
       threadInfo.roles[initialSelectedRole],
     );
 
     if (!otherUsersButNoOtherAdminsValue || !memberIsAdmin) {
       return null;
     }
 
     return (
       <div className={css.roleModalDisabled}>
         <SWMansionIcon icon="info-circle" size={36} className={css.infoIcon} />
         <div className={css.infoText}>
           There must be at least one admin at any given time in a community.
         </div>
       </div>
     );
   }, [initialSelectedRole, otherUsersButNoOtherAdminsValue, threadInfo.roles]);
 
   const onSave = React.useCallback(() => {
     if (selectedRole === initialSelectedRole) {
       popModal();
       return;
     }
 
     const createChangeThreadMemberRolesPromise = () =>
       callChangeThreadMemberRoles({
         threadID: threadInfo.id,
         memberIDs: [memberInfo.id],
         newRole: selectedRole,
       });
 
-    dispatchActionPromise(
+    void dispatchActionPromise(
       changeThreadMemberRolesActionTypes,
       createChangeThreadMemberRolesPromise(),
     );
     popModal();
   }, [
     callChangeThreadMemberRoles,
     dispatchActionPromise,
     initialSelectedRole,
     memberInfo.id,
     popModal,
     selectedRole,
     threadInfo.id,
   ]);
 
   return (
     <Modal name="Change Role" onClose={onCloseModal} size="large">
       <div className={css.roleModalDescription}>
         Members can only be assigned to one role at a time. Changing a
         member&rsquo;s role will replace their previously assigned role.
       </div>
       <div className={css.roleModalMember}>
         <div className={css.roleModalMemberAvatar}>
           <UserAvatar userID={memberInfo.id} size="M" />
         </div>
         <div className={css.roleModalMemberName}>{memberInfo.username}</div>
       </div>
       <div className={css.roleModalRoleSelector}>
         <Dropdown
           options={roleOptions}
           activeSelection={selectedRole}
           setActiveSelection={setSelectedRole}
           disabled={!!disabledRoleChangeMessage}
         />
       </div>
       {disabledRoleChangeMessage}
       <div className={css.roleModalActionButtons}>
         <Button
           variant="outline"
           className={css.roleModalBackButton}
           onClick={onCloseModal}
         >
           Back
         </Button>
         <Button
           variant="filled"
           className={css.roleModalSaveButton}
           buttonColor={buttonThemes.primary}
           onClick={onSave}
           disabled={!!disabledRoleChangeMessage}
         >
           Save
         </Button>
       </div>
     </Modal>
   );
 }
 
 export default ChangeMemberRoleModal;
diff --git a/web/modals/threads/notifications/notifications-modal.react.js b/web/modals/threads/notifications/notifications-modal.react.js
index fe02430aa..9067cde3b 100644
--- a/web/modals/threads/notifications/notifications-modal.react.js
+++ b/web/modals/threads/notifications/notifications-modal.react.js
@@ -1,266 +1,266 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useUpdateSubscription,
   updateSubscriptionActionTypes,
 } from 'lib/actions/user-actions.js';
 import { canPromoteSidebar } from 'lib/hooks/promote-sidebar.react.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { threadIsSidebar } from 'lib/shared/thread-utils.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import css from './notifications-modal.css';
 import AllNotifsIllustration from '../../../assets/all-notifs.react.js';
 import BadgeNotifsIllustration from '../../../assets/badge-notifs.react.js';
 import MutedNotifsIllustration from '../../../assets/muted-notifs.react.js';
 import Button from '../../../components/button.react.js';
 import EnumSettingsOption from '../../../components/enum-settings-option.react.js';
 import { useSelector } from '../../../redux/redux-utils.js';
 import Modal from '../../modal.react.js';
 
 type NotificationSettings = 'focused' | 'badge-only' | 'background';
 
 const BANNER_NOTIFS = 'Banner notifs';
 const BADGE_COUNT = 'Badge count';
 const IN_FOCUSED_TAB = 'Lives in Focused tab';
 const IN_BACKGROUND_TAB = 'Lives in Background tab';
 
 const focusedStatements = [
   {
     statement: BANNER_NOTIFS,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: BADGE_COUNT,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: IN_FOCUSED_TAB,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
 ];
 
 const badgeOnlyStatements = [
   {
     statement: BANNER_NOTIFS,
     isStatementValid: false,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: BADGE_COUNT,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: IN_FOCUSED_TAB,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
 ];
 
 const backgroundStatements = [
   {
     statement: BANNER_NOTIFS,
     isStatementValid: false,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: BADGE_COUNT,
     isStatementValid: false,
     styleStatementBasedOnValidity: true,
   },
   {
     statement: IN_BACKGROUND_TAB,
     isStatementValid: true,
     styleStatementBasedOnValidity: true,
   },
 ];
 
 type Props = {
   +threadID: string,
   +onClose: () => void,
 };
 function NotificationsModal(props: Props): React.Node {
   const { onClose, threadID } = props;
   const threadInfo = useSelector(state => threadInfoSelector(state)[threadID]);
   const { subscription } = threadInfo.currentUser;
   const { parentThreadID } = threadInfo;
   const parentThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
   const isSidebar = threadIsSidebar(threadInfo);
 
   const initialThreadSetting = React.useMemo<NotificationSettings>(() => {
     if (!subscription.home) {
       return 'background';
     }
     if (!subscription.pushNotifs) {
       return 'badge-only';
     }
     return 'focused';
   }, [subscription.home, subscription.pushNotifs]);
 
   const [notificationSettings, setNotificationSettings] =
     React.useState<NotificationSettings>(initialThreadSetting);
 
   const onFocusedSelected = React.useCallback(
     () => setNotificationSettings('focused'),
     [],
   );
   const onBadgeOnlySelected = React.useCallback(
     () => setNotificationSettings('badge-only'),
     [],
   );
   const onBackgroundSelected = React.useCallback(
     () => setNotificationSettings('background'),
     [],
   );
 
   const isFocusedSelected = notificationSettings === 'focused';
   const focusedItem = React.useMemo(() => {
     const icon = <AllNotifsIllustration />;
     return (
       <EnumSettingsOption
         selected={isFocusedSelected}
         title="Focused (enabled)"
         statements={focusedStatements}
         icon={icon}
         onSelect={onFocusedSelected}
       />
     );
   }, [isFocusedSelected, onFocusedSelected]);
 
   const isFocusedBadgeOnlySelected = notificationSettings === 'badge-only';
   const focusedBadgeOnlyItem = React.useMemo(() => {
     const icon = <BadgeNotifsIllustration />;
     return (
       <EnumSettingsOption
         selected={isFocusedBadgeOnlySelected}
         title="Focused (badge only)"
         statements={badgeOnlyStatements}
         icon={icon}
         onSelect={onBadgeOnlySelected}
       />
     );
   }, [isFocusedBadgeOnlySelected, onBadgeOnlySelected]);
 
   const isBackgroundSelected = notificationSettings === 'background';
   const backgroundItem = React.useMemo(() => {
     const icon = <MutedNotifsIllustration />;
     return (
       <EnumSettingsOption
         selected={isBackgroundSelected}
         title="Background"
         statements={backgroundStatements}
         icon={icon}
         disabled={isSidebar}
         onSelect={onBackgroundSelected}
       />
     );
   }, [isBackgroundSelected, onBackgroundSelected, isSidebar]);
 
   const dispatchActionPromise = useDispatchActionPromise();
 
   const callUpdateSubscription = useUpdateSubscription();
 
   const onClickSave = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       updateSubscriptionActionTypes,
       callUpdateSubscription({
         threadID: threadID,
         updatedFields: {
           home: notificationSettings !== 'background',
           pushNotifs: notificationSettings === 'focused',
         },
       }),
     );
     onClose();
   }, [
     callUpdateSubscription,
     dispatchActionPromise,
     notificationSettings,
     onClose,
     threadID,
   ]);
 
   const modalName = isSidebar
     ? 'Thread notifications'
     : 'Channel notifications';
 
   let modalContent;
   if (isSidebar && !parentThreadInfo?.currentUser.subscription.home) {
     modalContent = (
       <>
         <p>
           {'It’s not possible to change the notif settings for a thread ' +
             'whose parent is in Background. That’s because Comm’s design ' +
             'always shows threads underneath their parent in the Inbox, ' +
             'which means that if a thread’s parent is in Background, the ' +
             'thread must also be there.'}
         </p>
         <p>
           {canPromoteSidebar(threadInfo, parentThreadInfo)
             ? 'If you want to change the notif settings for this thread, ' +
               'you can either change the notif settings for the parent, ' +
               'or you can promote the thread to a channel.'
             : 'If you want to change the notif settings for this thread, ' +
               'you’ll have to change the notif settings for the parent.'}
         </p>
       </>
     );
   } else {
     let noticeText = null;
     if (isSidebar) {
       noticeText = (
         <>
           <p className={css.notice}>
             {'It’s not possible to move this thread to Background. ' +
               'That’s because Comm’s design always shows threads ' +
               'underneath their parent in the Inbox, which means ' +
               'that if a thread’s parent is in Focused, the thread ' +
               'must also be there.'}
           </p>
           <p className={css.notice}>
             {canPromoteSidebar(threadInfo, parentThreadInfo)
               ? 'If you want to move this thread to Background, ' +
                 'you can either move the parent to Background, ' +
                 'or you can promote the thread to a channel.'
               : 'If you want to move this thread to Background, ' +
                 'you’ll have to move the parent to Background.'}
           </p>
         </>
       );
     }
 
     modalContent = (
       <>
         <div className={css.optionsContainer}>
           {focusedItem}
           {focusedBadgeOnlyItem}
           {backgroundItem}
         </div>
         <Button
           variant="filled"
           onClick={onClickSave}
           disabled={notificationSettings === initialThreadSetting}
         >
           Save
         </Button>
         {noticeText}
       </>
     );
   }
 
   return (
     <Modal name={modalName} size="fit-content" onClose={onClose}>
       <div className={css.container}>{modalContent}</div>
     </Modal>
   );
 }
 
 export default NotificationsModal;
diff --git a/web/modals/threads/settings/thread-settings-delete-tab.react.js b/web/modals/threads/settings/thread-settings-delete-tab.react.js
index 7115774a7..a5c99a252 100644
--- a/web/modals/threads/settings/thread-settings-delete-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-delete-tab.react.js
@@ -1,131 +1,131 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   deleteThreadActionTypes,
   useDeleteThread,
 } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import { containedThreadInfos } from 'lib/selectors/thread-selectors.js';
 import { type SetState } from 'lib/types/hook-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import SubmitSection from './submit-section.react.js';
 import ThreadDeleteConfirmationModal from './thread-settings-delete-confirmation-modal.react.js';
 import css from './thread-settings-delete-tab.css';
 import { buttonThemes } from '../../../components/button.react.js';
 import { useSelector } from '../../../redux/redux-utils.js';
 
 type ThreadSettingsDeleteTabProps = {
   +threadSettingsOperationInProgress: boolean,
   +threadInfo: ThreadInfo,
   +setErrorMessage: SetState<?string>,
   +errorMessage?: ?string,
 };
 
 function ThreadSettingsDeleteTab(
   props: ThreadSettingsDeleteTabProps,
 ): React.Node {
   const {
     threadSettingsOperationInProgress,
     threadInfo,
     setErrorMessage,
     errorMessage,
   } = props;
 
   const modalContext = useModalContext();
   const dispatchActionPromise = useDispatchActionPromise();
   const callDeleteThread = useDeleteThread();
   const containedThreads = useSelector(
     state => containedThreadInfos(state)[threadInfo.id],
   );
   const shouldUseDeleteConfirmationModal = React.useMemo(
     () => containedThreads?.length > 0,
     [containedThreads?.length],
   );
 
   const popThreadDeleteConfirmationModal = React.useCallback(() => {
     if (shouldUseDeleteConfirmationModal) {
       modalContext.popModal();
     }
   }, [modalContext, shouldUseDeleteConfirmationModal]);
   const deleteThreadAction = React.useCallback(async () => {
     try {
       setErrorMessage('');
       const response = await callDeleteThread({ threadID: threadInfo.id });
       popThreadDeleteConfirmationModal();
       modalContext.popModal();
       return response;
     } catch (e) {
       popThreadDeleteConfirmationModal();
       setErrorMessage(
         e.message === 'invalid_credentials'
           ? 'permission not granted'
           : 'unknown error',
       );
       throw e;
     }
   }, [
     callDeleteThread,
     modalContext,
     popThreadDeleteConfirmationModal,
     setErrorMessage,
     threadInfo.id,
   ]);
   const dispatchDeleteThreadAction = React.useCallback(() => {
-    dispatchActionPromise(deleteThreadActionTypes, deleteThreadAction());
+    void dispatchActionPromise(deleteThreadActionTypes, deleteThreadAction());
   }, [dispatchActionPromise, deleteThreadAction]);
   const onDelete = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
       if (shouldUseDeleteConfirmationModal) {
         modalContext.pushModal(
           <ThreadDeleteConfirmationModal
             threadInfo={threadInfo}
             onConfirmation={dispatchDeleteThreadAction}
           />,
         );
       } else {
         dispatchDeleteThreadAction();
       }
     },
     [
       dispatchDeleteThreadAction,
       modalContext,
       shouldUseDeleteConfirmationModal,
       threadInfo,
     ],
   );
 
   return (
     <form method="POST" className={css.container}>
       <div>
         <div className={css.warning_container}>
           <SWMansionIcon
             icon="warning-circle"
             className={css.warning_icon}
             size={26}
           />
           <p className={css.deletion_warning}>
             Your chat will be permanently deleted. There is no way to reverse
             this.
           </p>
         </div>
       </div>
       <SubmitSection
         errorMessage={errorMessage}
         onClick={onDelete}
         variant="filled"
         buttonColor={buttonThemes.danger}
         disabled={threadSettingsOperationInProgress}
       >
         Delete
       </SubmitSection>
     </form>
   );
 }
 
 export default ThreadSettingsDeleteTab;
diff --git a/web/modals/threads/settings/thread-settings-general-tab.react.js b/web/modals/threads/settings/thread-settings-general-tab.react.js
index 50af1e643..b0b420bfb 100644
--- a/web/modals/threads/settings/thread-settings-general-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-general-tab.react.js
@@ -1,199 +1,199 @@
 // @flow
 
 import * as React from 'react';
 import tinycolor from 'tinycolor2';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from 'lib/actions/thread-actions.js';
 import { threadHasPermission } from 'lib/shared/thread-utils.js';
 import { type SetState } from 'lib/types/hook-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { type ThreadChanges, type ThreadInfo } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { firstLine } from 'lib/utils/string-utils.js';
 import { chatNameMaxLength } from 'lib/utils/validation-utils.js';
 
 import SubmitSection from './submit-section.react.js';
 import css from './thread-settings-general-tab.css';
 import EditThreadAvatar from '../../../avatars/edit-thread-avatar.react.js';
 import LoadingIndicator from '../../../loading-indicator.react.js';
 import Input from '../../input.react.js';
 import ColorSelector from '../color-selector.react.js';
 
 type ThreadSettingsGeneralTabProps = {
   +threadSettingsOperationInProgress: boolean,
   +threadInfo: ThreadInfo,
   +threadNamePlaceholder: string,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
   +setErrorMessage: SetState<?string>,
   +errorMessage?: ?string,
 };
 function ThreadSettingsGeneralTab(
   props: ThreadSettingsGeneralTabProps,
 ): React.Node {
   const {
     threadSettingsOperationInProgress,
     threadInfo,
     threadNamePlaceholder,
     queuedChanges,
     setQueuedChanges,
     setErrorMessage,
     errorMessage,
   } = props;
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useChangeThreadSettings();
 
   const nameInputRef = React.useRef<?HTMLInputElement>();
 
   React.useEffect(() => {
     nameInputRef.current?.focus();
   }, [threadSettingsOperationInProgress]);
 
   const changeQueued: boolean = React.useMemo(
     () => Object.values(queuedChanges).some(v => v !== null && v !== undefined),
     [queuedChanges],
   );
 
   const onChangeName = React.useCallback(
     (event: SyntheticEvent<HTMLInputElement>) => {
       const target = event.currentTarget;
       const newName = firstLine(target.value);
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           name: newName !== threadInfo.name ? newName : undefined,
         }),
       );
     },
     [setQueuedChanges, threadInfo.name],
   );
 
   const onChangeDescription = React.useCallback(
     (event: SyntheticEvent<HTMLTextAreaElement>) => {
       const target = event.currentTarget;
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           description:
             target.value !== threadInfo.description ? target.value : undefined,
         }),
       );
     },
     [setQueuedChanges, threadInfo.description],
   );
 
   const onChangeColor = React.useCallback(
     (color: string) => {
       setQueuedChanges(prevQueuedChanges =>
         Object.freeze({
           ...prevQueuedChanges,
           color: !tinycolor.equals(color, threadInfo.color) ? color : undefined,
         }),
       );
     },
     [setQueuedChanges, threadInfo.color],
   );
 
   const changeThreadSettingsAction = React.useCallback(async () => {
     try {
       setErrorMessage('');
       return await callChangeThreadSettings({
         threadID: threadInfo.id,
         changes: queuedChanges,
       });
     } catch (e) {
       setErrorMessage('unknown_error');
       throw e;
     } finally {
       setQueuedChanges(Object.freeze({}));
     }
   }, [
     callChangeThreadSettings,
     queuedChanges,
     setErrorMessage,
     setQueuedChanges,
     threadInfo.id,
   ]);
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
-      dispatchActionPromise(
+      void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         changeThreadSettingsAction(),
       );
     },
     [changeThreadSettingsAction, dispatchActionPromise],
   );
 
   const threadNameInputDisabled = !threadHasPermission(
     threadInfo,
     threadPermissions.EDIT_THREAD_NAME,
   );
 
   const saveButtonContent = React.useMemo(() => {
     if (threadSettingsOperationInProgress) {
       return <LoadingIndicator status="loading" />;
     }
     return 'Save';
   }, [threadSettingsOperationInProgress]);
 
   return (
     <form method="POST" className={css.container}>
       <div>
         <div className={css.editAvatarContainer}>
           <EditThreadAvatar threadInfo={threadInfo} />
         </div>
         <div className={css.form_title}>Chat name</div>
         <div className={css.form_content}>
           <Input
             type="text"
             maxLength={chatNameMaxLength}
             value={firstLine(queuedChanges.name ?? threadInfo.name)}
             placeholder={threadNamePlaceholder}
             onChange={onChangeName}
             disabled={
               threadSettingsOperationInProgress || threadNameInputDisabled
             }
             ref={nameInputRef}
           />
         </div>
       </div>
       <div>
         <div className={css.form_title}>Description</div>
         <div className={css.form_content}>
           <textarea
             value={queuedChanges.description ?? threadInfo.description ?? ''}
             placeholder="Chat description"
             onChange={onChangeDescription}
             disabled={threadSettingsOperationInProgress}
             rows={3}
           />
         </div>
       </div>
       <div>
         <div className={css.form_title}>Color</div>
         <div className={css.colorSelectorContainer}>
           <ColorSelector
             currentColor={queuedChanges.color ?? threadInfo.color}
             onColorSelection={onChangeColor}
           />
         </div>
       </div>
       <SubmitSection
         variant="filled"
         errorMessage={errorMessage}
         onClick={onSubmit}
         disabled={threadSettingsOperationInProgress || !changeQueued}
       >
         {saveButtonContent}
       </SubmitSection>
     </form>
   );
 }
 
 export default ThreadSettingsGeneralTab;
diff --git a/web/modals/threads/settings/thread-settings-privacy-tab.react.js b/web/modals/threads/settings/thread-settings-privacy-tab.react.js
index 76439b4f7..18658e83f 100644
--- a/web/modals/threads/settings/thread-settings-privacy-tab.react.js
+++ b/web/modals/threads/settings/thread-settings-privacy-tab.react.js
@@ -1,173 +1,173 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useChangeThreadSettings,
   changeThreadSettingsActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import { threadTypeDescriptions } from 'lib/shared/thread-utils.js';
 import { type SetState } from 'lib/types/hook-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { type ThreadChanges, type ThreadInfo } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import SubmitSection from './submit-section.react.js';
 import css from './thread-settings-privacy-tab.css';
 import EnumSettingsOption from '../../../components/enum-settings-option.react.js';
 
 const { COMMUNITY_OPEN_SUBTHREAD, COMMUNITY_SECRET_SUBTHREAD } = threadTypes;
 
 const openStatements = [
   {
     statement: threadTypeDescriptions[COMMUNITY_OPEN_SUBTHREAD],
     isStatementValid: true,
     styleStatementBasedOnValidity: false,
   },
 ];
 
 const secretStatements = [
   {
     statement: threadTypeDescriptions[COMMUNITY_SECRET_SUBTHREAD],
     isStatementValid: true,
     styleStatementBasedOnValidity: false,
   },
 ];
 
 type ThreadSettingsPrivacyTabProps = {
   +threadSettingsOperationInProgress: boolean,
   +threadInfo: ThreadInfo,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
   +setErrorMessage: SetState<?string>,
   +errorMessage?: ?string,
 };
 function ThreadSettingsPrivacyTab(
   props: ThreadSettingsPrivacyTabProps,
 ): React.Node {
   const {
     threadSettingsOperationInProgress,
     threadInfo,
     queuedChanges,
     setQueuedChanges,
     setErrorMessage,
     errorMessage,
   } = props;
 
   const modalContext = useModalContext();
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useChangeThreadSettings();
 
   const changeQueued: boolean = React.useMemo(
     () => Object.values(queuedChanges).some(v => v !== null && v !== undefined),
     [queuedChanges],
   );
 
   const changeThreadSettingsAction = React.useCallback(async () => {
     try {
       setErrorMessage('');
       const response = await callChangeThreadSettings({
         threadID: threadInfo.id,
         changes: queuedChanges,
       });
       modalContext.popModal();
       return response;
     } catch (e) {
       setErrorMessage('unknown_error');
       setQueuedChanges(Object.freeze({}));
       throw e;
     }
   }, [
     callChangeThreadSettings,
     modalContext,
     queuedChanges,
     setErrorMessage,
     setQueuedChanges,
     threadInfo.id,
   ]);
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
-      dispatchActionPromise(
+      void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         changeThreadSettingsAction(),
       );
     },
     [changeThreadSettingsAction, dispatchActionPromise],
   );
 
   const onOpenSelected = React.useCallback(() => {
     setQueuedChanges(prevQueuedChanges =>
       Object.freeze({
         ...prevQueuedChanges,
         type:
           COMMUNITY_OPEN_SUBTHREAD !== threadInfo.type
             ? COMMUNITY_OPEN_SUBTHREAD
             : undefined,
       }),
     );
   }, [setQueuedChanges, threadInfo.type]);
 
   const onSecretSelected = React.useCallback(() => {
     setQueuedChanges(prevQueuedChanges =>
       Object.freeze({
         ...prevQueuedChanges,
         type:
           COMMUNITY_SECRET_SUBTHREAD !== threadInfo.type
             ? COMMUNITY_SECRET_SUBTHREAD
             : undefined,
       }),
     );
   }, [setQueuedChanges, threadInfo.type]);
 
   const globeIcon = React.useMemo(
     () => <SWMansionIcon icon="globe-1" size={24} />,
     [],
   );
 
   const lockIcon = React.useMemo(
     () => <SWMansionIcon icon="lock-on" size={24} />,
     [],
   );
 
   return (
     <form method="POST" className={css.container}>
       <div className={css.form_title}>Chat type</div>
       <div className={css.enum_container}>
         <EnumSettingsOption
           selected={
             (queuedChanges.type ?? threadInfo.type) === COMMUNITY_OPEN_SUBTHREAD
           }
           onSelect={onOpenSelected}
           icon={globeIcon}
           title="Open"
           statements={openStatements}
         />
         <EnumSettingsOption
           selected={
             (queuedChanges.type ?? threadInfo.type) ===
             COMMUNITY_SECRET_SUBTHREAD
           }
           onSelect={onSecretSelected}
           icon={lockIcon}
           title="Secret"
           statements={secretStatements}
         />
       </div>
 
       <SubmitSection
         variant="filled"
         onClick={onSubmit}
         disabled={threadSettingsOperationInProgress || !changeQueued}
         errorMessage={errorMessage}
       >
         Save
       </SubmitSection>
     </form>
   );
 }
 
 export default ThreadSettingsPrivacyTab;
diff --git a/web/modals/threads/settings/thread-settings-relationship-button.react.js b/web/modals/threads/settings/thread-settings-relationship-button.react.js
index fc87bae23..61e0ad137 100644
--- a/web/modals/threads/settings/thread-settings-relationship-button.react.js
+++ b/web/modals/threads/settings/thread-settings-relationship-button.react.js
@@ -1,145 +1,145 @@
 // @flow
 import {
   faUserMinus,
   faUserPlus,
   faUserShield,
   faUserSlash,
 } from '@fortawesome/free-solid-svg-icons';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   updateRelationships,
   updateRelationshipsActionTypes,
 } from 'lib/actions/relationship-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import {
   getRelationshipActionText,
   getRelationshipDispatchAction,
 } from 'lib/shared/relationship-utils.js';
 import type { SetState } from 'lib/types/hook-types.js';
 import {
   relationshipButtons,
   type RelationshipButton,
 } from 'lib/types/relationship-types.js';
 import type { UserInfo } from 'lib/types/user-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 
 import css from './thread-settings-relationship-tab.css';
 import Button, { buttonThemes } from '../../../components/button.react.js';
 import { useSelector } from '../../../redux/redux-utils.js';
 
 const loadingStatusSelector = createLoadingStatusSelector(
   updateRelationshipsActionTypes,
 );
 
 type ButtonProps = {
   +relationshipButton: RelationshipButton,
   +otherUserInfo: UserInfo,
   +setErrorMessage?: SetState<?string>,
 };
 
 function ThreadSettingsRelationshipButton(props: ButtonProps): React.Node {
   const { relationshipButton, otherUserInfo, setErrorMessage } = props;
 
   const disabled = useSelector(loadingStatusSelector) === 'loading';
 
   const { username } = otherUserInfo;
   invariant(username, 'Other username should be specified');
 
   let color;
   if (relationshipButton === relationshipButtons.FRIEND) {
     color = buttonThemes.success;
   } else if (relationshipButton === relationshipButtons.UNFRIEND) {
     color = buttonThemes.danger;
   } else if (relationshipButton === relationshipButtons.BLOCK) {
     color = buttonThemes.danger;
   } else if (relationshipButton === relationshipButtons.UNBLOCK) {
     color = buttonThemes.success;
   } else if (relationshipButton === relationshipButtons.ACCEPT) {
     color = buttonThemes.success;
   } else if (relationshipButton === relationshipButtons.REJECT) {
     color = buttonThemes.danger;
   } else if (relationshipButton === relationshipButtons.WITHDRAW) {
     color = buttonThemes.danger;
   }
 
   const { text, action } = React.useMemo(() => {
     return {
       text: getRelationshipActionText(relationshipButton, username),
       action: getRelationshipDispatchAction(relationshipButton),
     };
   }, [relationshipButton, username]);
 
   const icon = React.useMemo(() => {
     let buttonIcon = null;
 
     if (relationshipButton === relationshipButtons.FRIEND) {
       buttonIcon = faUserPlus;
     } else if (relationshipButton === relationshipButtons.UNFRIEND) {
       buttonIcon = faUserMinus;
     } else if (relationshipButton === relationshipButtons.BLOCK) {
       buttonIcon = faUserShield;
     } else if (relationshipButton === relationshipButtons.UNBLOCK) {
       buttonIcon = faUserShield;
     } else if (relationshipButton === relationshipButtons.ACCEPT) {
       buttonIcon = faUserPlus;
     } else if (relationshipButton === relationshipButtons.REJECT) {
       buttonIcon = faUserSlash;
     } else if (relationshipButton === relationshipButtons.WITHDRAW) {
       buttonIcon = faUserMinus;
     }
 
     if (buttonIcon) {
       return (
         <FontAwesomeIcon
           icon={buttonIcon}
           className={css.relationshipButtonIcon}
         />
       );
     }
     return undefined;
   }, [relationshipButton]);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callUpdateRelationships = useServerCall(updateRelationships);
 
   const updateRelationshipsActionPromise = React.useCallback(async () => {
     try {
       setErrorMessage?.('');
       return await callUpdateRelationships({
         action,
         userIDs: [otherUserInfo.id],
       });
     } catch (e) {
       setErrorMessage?.('Error updating relationship');
       throw e;
     }
   }, [action, callUpdateRelationships, otherUserInfo.id, setErrorMessage]);
   const onClick = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       updateRelationshipsActionTypes,
       updateRelationshipsActionPromise(),
     );
   }, [dispatchActionPromise, updateRelationshipsActionPromise]);
 
   return (
     <Button
       variant="filled"
       buttonColor={color}
       onClick={onClick}
       disabled={disabled}
     >
       <div className={css.relationshipButtonContent}>
         {icon}
         <div className={css.relationshipButtonText}>{text}</div>
       </div>
     </Button>
   );
 }
 
 export default ThreadSettingsRelationshipButton;
diff --git a/web/push-notif/push-notifs-handler.js b/web/push-notif/push-notifs-handler.js
index 858540fc2..e320bc913 100644
--- a/web/push-notif/push-notifs-handler.js
+++ b/web/push-notif/push-notifs-handler.js
@@ -1,231 +1,231 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useSetDeviceTokenFanout,
   setDeviceTokenActionTypes,
 } from 'lib/actions/device-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { convertNonPendingIDToNewSchema } from 'lib/utils/migration-utils.js';
 import {
   shouldSkipPushPermissionAlert,
   recordNotifPermissionAlertActionType,
 } from 'lib/utils/push-alerts.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import { decryptDesktopNotification } from './notif-crypto-utils.js';
 import {
   WORKERS_MODULES_DIR_PATH,
   DEFAULT_OLM_FILENAME,
 } from '../database/utils/constants.js';
 import electron from '../electron.js';
 import PushNotifModal from '../modals/push-notif-modal.react.js';
 import { updateNavInfoActionType } from '../redux/action-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 declare var baseURL: string;
 declare var olmFilename: string;
 
 function useCreateDesktopPushSubscription() {
   const dispatchActionPromise = useDispatchActionPromise();
   const callSetDeviceToken = useSetDeviceTokenFanout();
   const staffCanSee = useStaffCanSee();
 
   React.useEffect(
     () =>
       electron?.onDeviceTokenRegistered?.((token: ?string) => {
         void dispatchActionPromise(
           setDeviceTokenActionTypes,
           callSetDeviceToken(token),
         );
       }),
     [callSetDeviceToken, dispatchActionPromise],
   );
 
   React.useEffect(() => {
     electron?.fetchDeviceToken?.();
   }, []);
 
   React.useEffect(
     () =>
       electron?.onEncryptedNotification?.(
         async ({ encryptedPayload }: { encryptedPayload: string }) => {
           const decryptedPayload = await decryptDesktopNotification(
             encryptedPayload,
             staffCanSee,
           );
           electron?.showDecryptedNotification(decryptedPayload);
         },
       ),
     [staffCanSee],
   );
 
   const dispatch = useDispatch();
 
   React.useEffect(
     () =>
       electron?.onNotificationClicked?.(
         ({ threadID }: { +threadID: string }) => {
           const convertedThreadID = convertNonPendingIDToNewSchema(
             threadID,
             ashoatKeyserverID,
           );
 
           const payload = {
             chatMode: 'view',
             activeChatThreadID: convertedThreadID,
             tab: 'chat',
           };
 
           dispatch({ type: updateNavInfoActionType, payload });
         },
       ),
     [dispatch],
   );
 }
 
 function useCreatePushSubscription(): () => Promise<void> {
   const publicKey = useSelector(state => state.pushApiPublicKey);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callSetDeviceToken = useSetDeviceTokenFanout();
   const staffCanSee = useStaffCanSee();
 
   return React.useCallback(async () => {
     if (!publicKey) {
       return;
     }
 
     const workerRegistration = await navigator.serviceWorker?.ready;
     if (!workerRegistration) {
       return;
     }
 
     const origin = window.location.origin;
     const olmWasmDirPath = `${origin}${baseURL}${WORKERS_MODULES_DIR_PATH}`;
     const olmWasmFilename = olmFilename ? olmFilename : DEFAULT_OLM_FILENAME;
     const olmWasmPath = `${olmWasmDirPath}/${olmWasmFilename}`;
     workerRegistration.active?.postMessage({ olmWasmPath, staffCanSee });
 
     const subscription = await workerRegistration.pushManager.subscribe({
       userVisibleOnly: true,
       applicationServerKey: publicKey,
     });
 
-    dispatchActionPromise(
+    void dispatchActionPromise(
       setDeviceTokenActionTypes,
       callSetDeviceToken(JSON.stringify(subscription)),
     );
   }, [callSetDeviceToken, dispatchActionPromise, publicKey, staffCanSee]);
 }
 
 function PushNotificationsHandler(): React.Node {
   useCreateDesktopPushSubscription();
   const createPushSubscription = useCreatePushSubscription();
 
   const notifPermissionAlertInfo = useSelector(
     state => state.notifPermissionAlertInfo,
   );
 
   const modalContext = useModalContext();
   const loggedIn = useSelector(isLoggedIn);
 
   const dispatch = useDispatch();
 
   const supported = 'Notification' in window && !electron;
 
   React.useEffect(() => {
-    (async () => {
+    void (async () => {
       if (!navigator.serviceWorker || !supported) {
         return;
       }
 
       await navigator.serviceWorker.register('worker/notif', { scope: '/' });
 
       if (Notification.permission === 'granted') {
         // Make sure the subscription is current if we have the permissions
         await createPushSubscription();
       } else if (
         Notification.permission === 'default' &&
         loggedIn &&
         !shouldSkipPushPermissionAlert(notifPermissionAlertInfo)
       ) {
         // Ask existing users that are already logged in for permission
         modalContext.pushModal(<PushNotifModal />);
         dispatch({
           type: recordNotifPermissionAlertActionType,
           payload: { time: Date.now() },
         });
       }
     })();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
   // Ask for permission on login
   const prevLoggedIn = React.useRef(loggedIn);
   React.useEffect(() => {
     if (!navigator.serviceWorker || !supported) {
       return;
     }
 
     if (!prevLoggedIn.current && loggedIn) {
       if (Notification.permission === 'granted') {
-        createPushSubscription();
+        void createPushSubscription();
       } else if (
         Notification.permission === 'default' &&
         !shouldSkipPushPermissionAlert(notifPermissionAlertInfo)
       ) {
         modalContext.pushModal(<PushNotifModal />);
         dispatch({
           type: recordNotifPermissionAlertActionType,
           payload: { time: Date.now() },
         });
       }
     }
     prevLoggedIn.current = loggedIn;
   }, [
     createPushSubscription,
     dispatch,
     loggedIn,
     modalContext,
     notifPermissionAlertInfo,
     prevLoggedIn,
     supported,
   ]);
 
   // Redirect to thread on notification click
   React.useEffect(() => {
     if (!navigator.serviceWorker || !supported) {
       return undefined;
     }
 
     const callback = (event: MessageEvent) => {
       if (typeof event.data !== 'object' || !event.data) {
         return;
       }
 
       if (event.data.targetThreadID) {
         const payload = {
           chatMode: 'view',
           activeChatThreadID: event.data.targetThreadID,
           tab: 'chat',
         };
 
         dispatch({ type: updateNavInfoActionType, payload });
       }
     };
 
     navigator.serviceWorker.addEventListener('message', callback);
     return () =>
       navigator.serviceWorker?.removeEventListener('message', callback);
   }, [dispatch, supported]);
 
   return null;
 }
 
 export { PushNotificationsHandler, useCreatePushSubscription };
diff --git a/web/redux/initial-state-gate.js b/web/redux/initial-state-gate.js
index 9c42cd0de..1cdd27064 100644
--- a/web/redux/initial-state-gate.js
+++ b/web/redux/initial-state-gate.js
@@ -1,142 +1,142 @@
 // @flow
 
 import * as React from 'react';
 import { PersistGate } from 'redux-persist/es/integration/react.js';
 import type { Persistor } from 'redux-persist/es/types';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import type { ThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import { allUpdatesCurrentAsOfSelector } from 'lib/selectors/keyserver-selectors.js';
 import { canUseDatabaseOnWeb } from 'lib/shared/web-database.js';
 import type { LegacyRawThreadInfo } from 'lib/types/thread-types.js';
 import { convertIDToNewSchema } from 'lib/utils/migration-utils.js';
 import { entries } from 'lib/utils/objects.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { infoFromURL } from 'lib/utils/url-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   setInitialReduxState,
   useGetInitialReduxState,
 } from './action-types.js';
 import { useSelector } from './redux-utils.js';
 import {
   getClientStore,
   processDBStoreOperations,
 } from '../database/utils/store.js';
 import Loading from '../loading.react.js';
 
 type Props = {
   +persistor: Persistor,
   +children: React.Node,
 };
 function InitialReduxStateGate(props: Props): React.Node {
   const { children, persistor } = props;
   const callGetInitialReduxState = useGetInitialReduxState();
   const dispatch = useDispatch();
 
   const [initError, setInitError] = React.useState<?Error>(null);
   React.useEffect(() => {
     if (initError) {
       throw initError;
     }
   }, [initError]);
 
   const isRehydrated = useSelector(state => !!state._persist?.rehydrated);
   const allUpdatesCurrentAsOf = useSelector(allUpdatesCurrentAsOfSelector);
 
   const prevIsRehydrated = React.useRef(false);
   React.useEffect(() => {
     if (!prevIsRehydrated.current && isRehydrated) {
       prevIsRehydrated.current = isRehydrated;
-      (async () => {
+      void (async () => {
         try {
           let urlInfo = infoFromURL(decodeURI(window.location.href));
           // Handle older links
           if (urlInfo.thread) {
             urlInfo = {
               ...urlInfo,
               thread: convertIDToNewSchema(urlInfo.thread, ashoatKeyserverID),
             };
           }
           const clientDBStore = await getClientStore();
 
           const payload = await callGetInitialReduxState({
             urlInfo,
             excludedData: {
               threadStore: !!clientDBStore.threadStore,
             },
             allUpdatesCurrentAsOf,
           });
 
           const currentLoggedInUserID = payload.currentUserInfo?.anonymous
             ? undefined
             : payload.currentUserInfo?.id;
           const useDatabase = canUseDatabaseOnWeb(currentLoggedInUserID);
 
           if (!currentLoggedInUserID || !useDatabase) {
             dispatch({ type: setInitialReduxState, payload });
             return;
           }
 
           if (clientDBStore.threadStore) {
             // If there is data in the DB, populate the store
             dispatch({
               type: setClientDBStoreActionType,
               payload: clientDBStore,
             });
             const { threadStore, ...rest } = payload;
             dispatch({ type: setInitialReduxState, payload: rest });
             return;
           } else {
             // When there is no data in the DB, it's necessary to migrate data
             // from the keyserver payload to the DB
             const {
               threadStore: { threadInfos },
             } = payload;
 
             const threadStoreOperations: ThreadStoreOperation[] = entries(
               threadInfos,
             ).map(([id, threadInfo]: [string, LegacyRawThreadInfo]) => ({
               type: 'replace',
               payload: {
                 id,
                 threadInfo,
               },
             }));
 
             await processDBStoreOperations({
               threadStoreOperations,
               draftStoreOperations: [],
               messageStoreOperations: [],
               reportStoreOperations: [],
               userStoreOperations: [],
             });
           }
           dispatch({ type: setInitialReduxState, payload });
         } catch (err) {
           setInitError(err);
         }
       })();
     }
   }, [callGetInitialReduxState, dispatch, isRehydrated, allUpdatesCurrentAsOf]);
 
   const initialStateLoaded = useSelector(state => state.initialStateLoaded);
 
   const childFunction = React.useCallback(
     // This argument is passed from `PersistGate`. It means that the state is
     // rehydrated and we can start fetching the initial info.
     (bootstrapped: boolean) => {
       if (bootstrapped && initialStateLoaded) {
         return children;
       } else {
         return <Loading />;
       }
     },
     [children, initialStateLoaded],
   );
 
   return <PersistGate persistor={persistor}>{childFunction}</PersistGate>;
 }
 
 export default InitialReduxStateGate;
diff --git a/web/redux/redux-setup.js b/web/redux/redux-setup.js
index 8a6004774..454935c17 100644
--- a/web/redux/redux-setup.js
+++ b/web/redux/redux-setup.js
@@ -1,352 +1,352 @@
 // @flow
 
 import invariant from 'invariant';
 import type { PersistState } from 'redux-persist/es/types.js';
 
 import {
   logOutActionTypes,
   deleteKeyserverAccountActionTypes,
 } from 'lib/actions/user-actions.js';
 import {
   type ThreadStoreOperation,
   threadStoreOpsHandlers,
 } from 'lib/ops/thread-store-ops.js';
 import baseReducer from 'lib/reducers/master-reducer.js';
 import { mostRecentlyReadThreadSelector } from 'lib/selectors/thread-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { invalidSessionDowngrade } from 'lib/shared/session-utils.js';
 import type { CryptoStore } from 'lib/types/crypto-types.js';
 import type { DraftStore } from 'lib/types/draft-types.js';
 import type { EnabledApps } from 'lib/types/enabled-apps.js';
 import type { EntryStore, CalendarQuery } from 'lib/types/entry-types.js';
 import { type CalendarFilter } from 'lib/types/filter-types.js';
 import type { IntegrityStore } from 'lib/types/integrity-types.js';
 import type { KeyserverStore } from 'lib/types/keyserver-types.js';
 import type { LifecycleState } from 'lib/types/lifecycle-state-types.js';
 import type { InviteLinksStore } from 'lib/types/link-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { MessageStore } from 'lib/types/message-types.js';
 import type { UserPolicies } from 'lib/types/policy-types.js';
 import type { BaseAction } from 'lib/types/redux-types.js';
 import type { ReportStore } from 'lib/types/report-types.js';
 import type { StoreOperations } from 'lib/types/store-ops-types.js';
 import type { GlobalThemeInfo } from 'lib/types/theme-types.js';
 import type { ThreadActivityStore } from 'lib/types/thread-activity-types';
 import type { ThreadStore } from 'lib/types/thread-types.js';
 import type { CurrentUserInfo, UserStore } from 'lib/types/user-types.js';
 import { setNewSessionActionType } from 'lib/utils/action-utils.js';
 import type { NotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   updateWindowActiveActionType,
   updateNavInfoActionType,
   updateWindowDimensionsActionType,
   setInitialReduxState,
 } from './action-types.js';
 import { reduceCommunityPickerStore } from './community-picker-reducer.js';
 import { reduceCryptoStore, setCryptoStore } from './crypto-store-reducer.js';
 import reduceNavInfo from './nav-reducer.js';
 import { onStateDifference } from './redux-debug-utils.js';
 import { getVisibility } from './visibility.js';
 import { processDBStoreOperations } from '../database/utils/store.js';
 import { activeThreadSelector } from '../selectors/nav-selectors.js';
 import { type NavInfo } from '../types/nav-types.js';
 import type { InitialReduxState } from '../types/redux-types.js';
 
 export type WindowDimensions = { width: number, height: number };
 
 export type CommunityPickerStore = {
   +chat: ?string,
   +calendar: ?string,
 };
 
 export type AppState = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +communityPickerStore: CommunityPickerStore,
   +windowDimensions: WindowDimensions,
   +notifPermissionAlertInfo: NotifPermissionAlertInfo,
   +actualizedCalendarQuery: CalendarQuery,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +nextLocalID: number,
   +dataLoaded: boolean,
   +windowActive: boolean,
   +userPolicies: UserPolicies,
   +cryptoStore: ?CryptoStore,
   +pushApiPublicKey: ?string,
   +_persist: ?PersistState,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +initialStateLoaded: boolean,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
   +customServer: ?string,
 };
 
 export type Action =
   | BaseAction
   | { type: 'UPDATE_NAV_INFO', payload: Partial<NavInfo> }
   | {
       type: 'UPDATE_WINDOW_DIMENSIONS',
       payload: WindowDimensions,
     }
   | {
       type: 'UPDATE_WINDOW_ACTIVE',
       payload: boolean,
     }
   | { +type: 'SET_CRYPTO_STORE', payload: CryptoStore }
   | { +type: 'SET_INITIAL_REDUX_STATE', payload: InitialReduxState };
 
 export function reducer(oldState: AppState | void, action: Action): AppState {
   invariant(oldState, 'should be set');
   let state = oldState;
   let storeOperations: StoreOperations = {
     draftStoreOperations: [],
     threadStoreOperations: [],
     messageStoreOperations: [],
     reportStoreOperations: [],
     userStoreOperations: [],
   };
 
   if (action.type === setInitialReduxState) {
     const { userInfos, keyserverInfos, ...rest } = action.payload;
     const newKeyserverInfos = { ...state.keyserverStore.keyserverInfos };
     for (const keyserverID in keyserverInfos) {
       newKeyserverInfos[keyserverID] = {
         ...newKeyserverInfos[keyserverID],
         ...keyserverInfos[keyserverID],
       };
     }
     return validateStateAndProcessDBOperations(
       oldState,
       {
         ...state,
         ...rest,
         userStore: { userInfos },
         keyserverStore: {
           ...state.keyserverStore,
           keyserverInfos: newKeyserverInfos,
         },
         initialStateLoaded: true,
       },
       storeOperations,
     );
   } else if (action.type === updateWindowDimensionsActionType) {
     return validateStateAndProcessDBOperations(
       oldState,
       {
         ...state,
         windowDimensions: action.payload,
       },
       storeOperations,
     );
   } else if (action.type === updateWindowActiveActionType) {
     return validateStateAndProcessDBOperations(
       oldState,
       {
         ...state,
         windowActive: action.payload,
       },
       storeOperations,
     );
   } else if (action.type === setNewSessionActionType) {
     const { keyserverID } = action.payload;
 
     if (
       invalidSessionDowngrade(
         oldState,
         action.payload.sessionChange.currentUserInfo,
         action.payload.preRequestUserState,
         keyserverID,
       )
     ) {
       return oldState;
     }
 
     state = {
       ...state,
       keyserverStore: {
         ...state.keyserverStore,
         keyserverInfos: {
           ...state.keyserverStore.keyserverInfos,
           [keyserverID]: {
             ...state.keyserverStore.keyserverInfos[keyserverID],
             sessionID: action.payload.sessionChange.sessionID,
           },
         },
       },
     };
   } else if (
     (action.type === logOutActionTypes.success &&
       invalidSessionDowngrade(
         oldState,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       )) ||
     (action.type === deleteKeyserverAccountActionTypes.success &&
       invalidSessionDowngrade(
         oldState,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
         ashoatKeyserverID,
       ))
   ) {
     return oldState;
   }
 
   if (
     action.type !== updateNavInfoActionType &&
     action.type !== setCryptoStore
   ) {
     const baseReducerResult = baseReducer(state, action, onStateDifference);
     state = baseReducerResult.state;
     storeOperations = baseReducerResult.storeOperations;
   }
 
   const communityPickerStore = reduceCommunityPickerStore(
     state.communityPickerStore,
     action,
   );
 
   state = {
     ...state,
     navInfo: reduceNavInfo(
       state.navInfo,
       action,
       state.threadStore.threadInfos,
     ),
     cryptoStore: reduceCryptoStore(state.cryptoStore, action),
     communityPickerStore,
   };
 
   return validateStateAndProcessDBOperations(oldState, state, storeOperations);
 }
 
 function validateStateAndProcessDBOperations(
   oldState: AppState,
   state: AppState,
   storeOperations: StoreOperations,
 ): AppState {
   const updateActiveThreadOps: ThreadStoreOperation[] = [];
   if (
     (state.navInfo.activeChatThreadID &&
       !state.navInfo.pendingThread &&
       !state.threadStore.threadInfos[state.navInfo.activeChatThreadID]) ||
     (!state.navInfo.activeChatThreadID && isLoggedIn(state))
   ) {
     // Makes sure the active thread always exists
     state = {
       ...state,
       navInfo: {
         ...state.navInfo,
         activeChatThreadID: mostRecentlyReadThreadSelector(state),
       },
     };
   }
 
   const activeThread = activeThreadSelector(state);
   if (
     activeThread &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread &&
     getVisibility().hidden()
   ) {
     console.warn(
       `thread ${activeThread} is active and unread, ` +
         'but visibilityjs reports the window is not visible',
     );
   }
   if (
     activeThread &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread &&
     typeof document !== 'undefined' &&
     document &&
     'hasFocus' in document &&
     !document.hasFocus()
   ) {
     console.warn(
       `thread ${activeThread} is active and unread, ` +
         'but document.hasFocus() is false',
     );
   }
   if (
     activeThread &&
     !getVisibility().hidden() &&
     typeof document !== 'undefined' &&
     document &&
     'hasFocus' in document &&
     document.hasFocus() &&
     !state.navInfo.pendingThread &&
     state.threadStore.threadInfos[activeThread].currentUser.unread
   ) {
     // Makes sure a currently focused thread is never unread
     updateActiveThreadOps.push({
       type: 'replace',
       payload: {
         id: activeThread,
         threadInfo: {
           ...state.threadStore.threadInfos[activeThread],
           currentUser: {
             ...state.threadStore.threadInfos[activeThread].currentUser,
             unread: false,
           },
         },
       },
     });
   }
 
   const oldActiveThread = activeThreadSelector(oldState);
   if (
     activeThread &&
     oldActiveThread !== activeThread &&
     state.messageStore.threads[activeThread]
   ) {
     const now = Date.now();
     state = {
       ...state,
       threadActivityStore: {
         ...state.threadActivityStore,
         [(activeThread: string)]: {
           ...state.threadActivityStore[activeThread],
           lastNavigatedTo: now,
         },
       },
     };
   }
 
   if (updateActiveThreadOps.length > 0) {
     state = {
       ...state,
       threadStore: threadStoreOpsHandlers.processStoreOperations(
         state.threadStore,
         updateActiveThreadOps,
       ),
     };
     storeOperations = {
       ...storeOperations,
       threadStoreOperations: [
         ...storeOperations.threadStoreOperations,
         ...updateActiveThreadOps,
       ],
     };
   }
 
-  processDBStoreOperations(storeOperations, state.currentUserInfo?.id);
+  void processDBStoreOperations(storeOperations, state.currentUserInfo?.id);
 
   return state;
 }
diff --git a/web/redux/visibility.js b/web/redux/visibility.js
index acee72739..05ac89ad3 100644
--- a/web/redux/visibility.js
+++ b/web/redux/visibility.js
@@ -1,44 +1,44 @@
 // @flow
 
 import * as React from 'react';
 
 type VisibilityModule = {
   +hidden: () => boolean,
   +change: (callback: (event: Object, state: string) => mixed) => number,
   +unbind: (callbackID: number) => void,
   ...
 };
 
 /* eslint-disable no-unused-vars */
 let visibilityModule: VisibilityModule = {
   hidden: () => false,
   change: (callback: (event: Object, state: string) => mixed) => 0,
   unbind: (callbackID: number) => {},
 };
 /* eslint-enable no-unused-vars */
 
 let callbacks = [];
 
-(async () => {
+void (async () => {
   if (typeof window === 'undefined') {
     return;
   }
   try {
     const visibilityjs = await import('visibilityjs');
     visibilityModule = visibilityjs.default;
     callbacks.forEach(callback => callback(visibilityModule));
     callbacks = [];
   } catch {}
 })();
 
 function getVisibility(): VisibilityModule {
   return visibilityModule;
 }
 
 function useVisibility(): VisibilityModule {
   const [visibility, setVisibility] = React.useState(visibilityModule);
   callbacks.push(setVisibility);
   return visibility;
 }
 
 export { getVisibility, useVisibility };
diff --git a/web/roles/create-roles-modal.react.js b/web/roles/create-roles-modal.react.js
index ad3729702..d76a9c62f 100644
--- a/web/roles/create-roles-modal.react.js
+++ b/web/roles/create-roles-modal.react.js
@@ -1,286 +1,286 @@
 // @flow
 
 import classNames from 'classnames';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   useModifyCommunityRole,
   modifyCommunityRoleActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import {
   type UserSurfacedPermission,
   type UserSurfacedPermissionOption,
   userSurfacedPermissionOptions,
 } from 'lib/types/thread-permission-types.js';
 import type {
   RoleModificationRequest,
   ThreadInfo,
 } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { values } from 'lib/utils/objects.js';
 
 import css from './create-roles-modal.css';
 import Button, { buttonThemes } from '../components/button.react.js';
 import EnumSettingsOption from '../components/enum-settings-option.react.js';
 import LoadingIndicator from '../loading-indicator.react.js';
 import Input from '../modals/input.react.js';
 import Modal from '../modals/modal.react.js';
 import UnsavedChangesModal from '../modals/unsaved-changes-modal.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 const createRolesLoadingStatusSelector = createLoadingStatusSelector(
   modifyCommunityRoleActionTypes,
 );
 
 type CreateRolesModalProps = {
   +threadInfo: ThreadInfo,
   +action: 'create_role' | 'edit_role',
   +existingRoleID?: string,
   +roleName: string,
   +rolePermissions: $ReadOnlySet<UserSurfacedPermission>,
 };
 
 type RoleCreationErrorVariant = 'already_exists' | 'unknown_error';
 
 function CreateRolesModal(props: CreateRolesModalProps): React.Node {
   const { pushModal, popModal } = useModalContext();
   const { threadInfo, action, existingRoleID, roleName, rolePermissions } =
     props;
   const modalName = action === 'create_role' ? 'Create role' : 'Edit role';
 
   const callModifyCommunityRole = useModifyCommunityRole();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const createRolesLoadingStatus: LoadingStatus = useSelector(
     createRolesLoadingStatusSelector,
   );
 
   const [pendingRoleName, setPendingRoleName] =
     React.useState<string>(roleName);
   const [pendingRolePermissions, setPendingRolePermissions] =
     React.useState<$ReadOnlySet<UserSurfacedPermission>>(rolePermissions);
 
   const [roleCreationFailed, setRoleCreationFailed] =
     React.useState<?RoleCreationErrorVariant>();
 
   const createButtonText = action === 'create_role' ? 'Create' : 'Save';
 
   const onChangeRoleName = React.useCallback(
     (event: SyntheticEvent<HTMLInputElement>) => {
       setRoleCreationFailed(null);
       setPendingRoleName(event.currentTarget.value);
     },
     [],
   );
 
   const onCloseModal = React.useCallback(() => {
     const pendingSet = new Set(pendingRolePermissions);
     const roleSet = new Set(rolePermissions);
 
     let arePermissionsEqual = true;
     if (pendingSet.size !== roleSet.size) {
       arePermissionsEqual = false;
     }
     for (const permission of pendingSet) {
       if (!roleSet.has(permission)) {
         arePermissionsEqual = false;
         break;
       }
     }
 
     if (pendingRoleName === roleName && arePermissionsEqual) {
       popModal();
       return;
     }
 
     pushModal(<UnsavedChangesModal />);
   }, [
     pendingRoleName,
     roleName,
     pendingRolePermissions,
     rolePermissions,
     pushModal,
     popModal,
   ]);
 
   const clearPermissionsClassNames = classNames({
     [css.clearPermissions]: true,
     [css.clearPermissionsDisabled]: pendingRolePermissions.size === 0,
     [css.clearPermissionsEnabled]: pendingRolePermissions.size > 0,
   });
 
   const onClearPermissions = React.useCallback(
     () => setPendingRolePermissions(new Set()),
     [],
   );
 
   const isUserSurfacedPermissionSelected = React.useCallback(
     (option: UserSurfacedPermissionOption) =>
       pendingRolePermissions.has(option.userSurfacedPermission),
     [pendingRolePermissions],
   );
 
   const onEnumValuePress = React.useCallback(
     (option: UserSurfacedPermissionOption) =>
       setPendingRolePermissions(currentPermissions => {
         if (currentPermissions.has(option.userSurfacedPermission)) {
           const newPermissions = new Set(currentPermissions);
           newPermissions.delete(option.userSurfacedPermission);
           return newPermissions;
         } else {
           return new Set([
             ...currentPermissions,
             option.userSurfacedPermission,
           ]);
         }
       }),
     [],
   );
 
   const permissionsList = React.useMemo(
     () =>
       [...userSurfacedPermissionOptions].map(permission => (
         <EnumSettingsOption
           key={permission.userSurfacedPermission}
           selected={isUserSurfacedPermissionSelected(permission)}
           onSelect={() => onEnumValuePress(permission)}
           icon={null}
           title={permission.title}
           type="checkbox"
           statements={[{ statement: permission.description }]}
         />
       )),
     [isUserSurfacedPermissionSelected, onEnumValuePress],
   );
 
   const errorMessageClassNames = classNames({
     [css.errorMessage]: true,
     [css.errorMessageVisible]: !!roleCreationFailed,
   });
 
   const threadRoleNames = React.useMemo(
     () => values(threadInfo.roles).map(role => role.name),
     [threadInfo],
   );
 
   const onClickCreateRole = React.useCallback(() => {
     if (threadRoleNames.includes(pendingRoleName) && action === 'create_role') {
       setRoleCreationFailed('already_exists');
       return;
     }
 
     let callModifyCommunityRoleParams: RoleModificationRequest;
     if (action === 'create_role') {
       callModifyCommunityRoleParams = {
         community: threadInfo.id,
         action,
         name: pendingRoleName,
         permissions: [...pendingRolePermissions],
       };
     } else {
       invariant(existingRoleID, 'existingRoleID should be defined');
       callModifyCommunityRoleParams = {
         community: threadInfo.id,
         existingRoleID,
         action,
         name: pendingRoleName,
         permissions: [...pendingRolePermissions],
       };
     }
 
-    dispatchActionPromise(
+    void dispatchActionPromise(
       modifyCommunityRoleActionTypes,
       (async () => {
         try {
           const response = await callModifyCommunityRole(
             callModifyCommunityRoleParams,
           );
           popModal();
           return response;
         } catch (e) {
           setRoleCreationFailed('unknown_error');
           throw e;
         }
       })(),
     );
   }, [
     callModifyCommunityRole,
     dispatchActionPromise,
     threadInfo,
     action,
     existingRoleID,
     pendingRoleName,
     pendingRolePermissions,
     popModal,
     threadRoleNames,
   ]);
 
   const errorMessage = React.useMemo(() => {
     if (roleCreationFailed === 'already_exists') {
       return 'There is already a role with this name in the community';
     } else {
       return 'An unknown error occurred. Please try again';
     }
   }, [roleCreationFailed]);
 
   const saveButtonContent = React.useMemo(() => {
     if (createRolesLoadingStatus === 'loading') {
       return (
         <LoadingIndicator status={createRolesLoadingStatus} size="medium" />
       );
     }
 
     return createButtonText;
   }, [createRolesLoadingStatus, createButtonText]);
 
   return (
     <Modal name={modalName} onClose={onCloseModal} size="large">
       <form method="POST" className={css.formContainer}>
         <div className={css.roleNameLabel}>Role name</div>
         <div className={css.roleNameInput}>
           <Input
             type="text"
             value={pendingRoleName}
             onChange={onChangeRoleName}
           />
         </div>
         <div className={errorMessageClassNames}>{errorMessage}</div>
       </form>
       <hr className={css.separator} />
       <div className={css.permissionsHeaderContainer}>
         <div className={css.permissionsLabel}>Permissions</div>
         <div
           className={clearPermissionsClassNames}
           onClick={onClearPermissions}
         >
           Clear Permissions
         </div>
       </div>
       <div className={css.permissionsContainer}>{permissionsList}</div>
       <div className={css.buttonsContainer}>
         <Button
           variant="outline"
           className={css.backButton}
           buttonColor={buttonThemes.outline}
           onClick={onCloseModal}
         >
           Back
         </Button>
         <Button
           variant="filled"
           className={css.createRoleButton}
           buttonColor={buttonThemes.standard}
           onClick={onClickCreateRole}
         >
           {saveButtonContent}
         </Button>
       </div>
     </Modal>
   );
 }
 
 export default CreateRolesModal;
diff --git a/web/roles/delete-role-modal.react.js b/web/roles/delete-role-modal.react.js
index cdb132e57..f2aeb8755 100644
--- a/web/roles/delete-role-modal.react.js
+++ b/web/roles/delete-role-modal.react.js
@@ -1,94 +1,94 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useDeleteCommunityRole,
   deleteCommunityRoleActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { useRoleMemberCountsForCommunity } from 'lib/shared/thread-utils.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { constructRoleDeletionMessagePrompt } from 'lib/utils/role-utils.js';
 
 import css from './delete-role-modal.css';
 import LoadingIndicator from '../loading-indicator.react.js';
 import ConfirmationAlert from '../modals/confirmation-alert.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 const deleteRoleLoadingStatusSelector = createLoadingStatusSelector(
   deleteCommunityRoleActionTypes,
 );
 
 type DeleteRoleModalProps = {
   +threadInfo: ThreadInfo,
   +defaultRoleID: string,
   +roleID: string,
 };
 
 function DeleteRoleModal(props: DeleteRoleModalProps): React.Node {
   const { threadInfo, defaultRoleID, roleID } = props;
   const { popModal } = useModalContext();
 
   const callDeleteCommunityRole = useDeleteCommunityRole();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const deleteRoleLoadingStatus: LoadingStatus = useSelector(
     deleteRoleLoadingStatusSelector,
   );
 
   const roleNamesToMemberCounts = useRoleMemberCountsForCommunity(threadInfo);
   const roleName = threadInfo.roles[roleID].name;
   const memberCount = roleNamesToMemberCounts[roleName];
   const defaultRoleName = threadInfo.roles[defaultRoleID].name;
 
   const message = constructRoleDeletionMessagePrompt(
     defaultRoleName,
     memberCount,
   );
 
   const onDeleteRole = React.useCallback(() => {
-    dispatchActionPromise(
+    void dispatchActionPromise(
       deleteCommunityRoleActionTypes,
       (async () => {
         const response = await callDeleteCommunityRole({
           community: threadInfo.id,
           roleID: roleID,
         });
         popModal();
         return response;
       })(),
     );
   }, [
     callDeleteCommunityRole,
     dispatchActionPromise,
     roleID,
     threadInfo.id,
     popModal,
   ]);
 
   const deleteButtonContent = React.useMemo(() => {
     if (deleteRoleLoadingStatus === 'loading') {
       return (
         <LoadingIndicator status={deleteRoleLoadingStatus} size="medium" />
       );
     }
     return 'Yes, delete role';
   }, [deleteRoleLoadingStatus]);
 
   return (
     <ConfirmationAlert
       title="Delete role"
       confirmationButtonContent={deleteButtonContent}
       onConfirm={onDeleteRole}
       isDestructive
     >
       <div className={css.roleDeletionText}>{message}</div>
     </ConfirmationAlert>
   );
 }
 
 export default DeleteRoleModal;
diff --git a/web/settings/account-delete-modal.react.js b/web/settings/account-delete-modal.react.js
index caba58148..88cc83e1d 100644
--- a/web/settings/account-delete-modal.react.js
+++ b/web/settings/account-delete-modal.react.js
@@ -1,93 +1,93 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useDeleteKeyserverAccount,
   deleteKeyserverAccountActionTypes,
 } from 'lib/actions/user-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import SWMansionIcon from 'lib/components/SWMansionIcon.react.js';
 import { preRequestUserStateSelector } from 'lib/selectors/account-selectors.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 
 import css from './account-delete-modal.css';
 import Button, { buttonThemes } from '../components/button.react.js';
 import Modal from '../modals/modal.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 const deleteAccountLoadingStatusSelector = createLoadingStatusSelector(
   deleteKeyserverAccountActionTypes,
 );
 
 const AccountDeleteModal: React.ComponentType<{}> = React.memo<{}>(
   function AccountDeleteModal(): React.Node {
     const preRequestUserState = useSelector(preRequestUserStateSelector);
     const inputDisabled = useSelector(
       state => deleteAccountLoadingStatusSelector(state) === 'loading',
     );
     const callDeleteAccount = useDeleteKeyserverAccount();
     const dispatchActionPromise = useDispatchActionPromise();
 
     const { popModal } = useModalContext();
 
     const [errorMessage, setErrorMessage] = React.useState('');
 
     let errorMsg;
     if (errorMessage) {
       errorMsg = <div className={css.form_error}>{errorMessage}</div>;
     }
 
     const deleteAction = React.useCallback(async () => {
       try {
         setErrorMessage('');
         const response = await callDeleteAccount(preRequestUserState);
         popModal();
         return response;
       } catch (e) {
         setErrorMessage('unknown error');
         throw e;
       }
     }, [callDeleteAccount, preRequestUserState, popModal]);
 
     const onDelete = React.useCallback(
       (event: SyntheticEvent<HTMLButtonElement>) => {
         event.preventDefault();
-        dispatchActionPromise(
+        void dispatchActionPromise(
           deleteKeyserverAccountActionTypes,
           deleteAction(),
         );
       },
       [dispatchActionPromise, deleteAction],
     );
 
     return (
       <Modal name="Delete Account" onClose={popModal} size="large">
         <div className={css.modal_body}>
           <form method="POST">
             <SWMansionIcon icon="warning-circle" size={22} />
             <p className={css.deletion_warning}>
               Your account will be permanently deleted. There is no way to
               reverse this.
             </p>
             <div className={css.form_footer}>
               <Button
                 variant="filled"
                 buttonColor={buttonThemes.danger}
                 type="submit"
                 onClick={onDelete}
                 disabled={inputDisabled}
               >
                 Delete Account
               </Button>
               {errorMsg}
             </div>
           </form>
         </div>
       </Modal>
     );
   },
 );
 
 export default AccountDeleteModal;
diff --git a/web/settings/password-change-modal.js b/web/settings/password-change-modal.js
index 1ddf85c97..412a67ef6 100644
--- a/web/settings/password-change-modal.js
+++ b/web/settings/password-change-modal.js
@@ -1,262 +1,262 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   changeUserPasswordActionTypes,
   changeUserPassword,
 } from 'lib/actions/user-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { useStringForUser } from 'lib/hooks/ens-cache.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { type PasswordUpdate } from 'lib/types/user-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 
 import css from './password-change-modal.css';
 import Button from '../components/button.react.js';
 import Input from '../modals/input.react.js';
 import Modal from '../modals/modal.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 
 type Props = {
   +inputDisabled: boolean,
   +dispatchActionPromise: DispatchActionPromise,
   +changeUserPassword: (passwordUpdate: PasswordUpdate) => Promise<void>,
   +popModal: () => void,
   +stringForUser: ?string,
 };
 type State = {
   +newPassword: string,
   +confirmNewPassword: string,
   +currentPassword: string,
   +errorMessage: string,
 };
 
 class PasswordChangeModal extends React.PureComponent<Props, State> {
   newPasswordInput: ?HTMLInputElement;
   currentPasswordInput: ?HTMLInputElement;
 
   constructor(props: Props) {
     super(props);
     this.state = {
       newPassword: '',
       confirmNewPassword: '',
       currentPassword: '',
       errorMessage: '',
     };
   }
 
   componentDidMount() {
     invariant(this.newPasswordInput, 'newPasswordInput ref unset');
     this.newPasswordInput.focus();
   }
 
   render(): React.Node {
     let errorMsg;
     if (this.state.errorMessage) {
       errorMsg = (
         <div className={css['modal-form-error']}>{this.state.errorMessage}</div>
       );
     }
 
     const { inputDisabled } = this.props;
     return (
       <Modal name="Change Password" onClose={this.props.popModal} size="large">
         <div className={css['modal-body']}>
           <form method="POST">
             <div className={css['form-content']}>
               <p className={css['username-container']}>
                 <span className={css['username-label']}>{'Logged in as '}</span>
                 <span className={css['username']}>
                   {this.props.stringForUser}
                 </span>
               </p>
               <div className={css['form-content']}>
                 <Input
                   type="password"
                   placeholder="Current password"
                   value={this.state.currentPassword}
                   onChange={this.onChangeCurrentPassword}
                   disabled={inputDisabled}
                   ref={this.currentPasswordInputRef}
                   label="Current password"
                 />
               </div>
               <Input
                 type="password"
                 placeholder="New password"
                 value={this.state.newPassword}
                 onChange={this.onChangeNewPassword}
                 ref={this.newPasswordInputRef}
                 disabled={inputDisabled}
                 label="New password"
               />
               <Input
                 type="password"
                 placeholder="Confirm new password"
                 value={this.state.confirmNewPassword}
                 onChange={this.onChangeConfirmNewPassword}
                 disabled={inputDisabled}
               />
             </div>
             <div className={css['form-footer']}>
               <Button
                 type="submit"
                 variant="filled"
                 onClick={this.onSubmit}
                 disabled={
                   inputDisabled ||
                   this.state.currentPassword.length === 0 ||
                   this.state.newPassword.length === 0 ||
                   this.state.confirmNewPassword.length === 0
                 }
               >
                 Change Password
               </Button>
               {errorMsg}
             </div>
           </form>
         </div>
       </Modal>
     );
   }
 
   newPasswordInputRef = (newPasswordInput: ?HTMLInputElement) => {
     this.newPasswordInput = newPasswordInput;
   };
 
   currentPasswordInputRef = (currentPasswordInput: ?HTMLInputElement) => {
     this.currentPasswordInput = currentPasswordInput;
   };
 
   onChangeNewPassword = (event: SyntheticEvent<HTMLInputElement>) => {
     const target = event.target;
     invariant(target instanceof HTMLInputElement, 'target not input');
     this.setState({ newPassword: target.value });
   };
 
   onChangeConfirmNewPassword = (event: SyntheticEvent<HTMLInputElement>) => {
     const target = event.target;
     invariant(target instanceof HTMLInputElement, 'target not input');
     this.setState({ confirmNewPassword: target.value });
   };
 
   onChangeCurrentPassword = (event: SyntheticEvent<HTMLInputElement>) => {
     const target = event.target;
     invariant(target instanceof HTMLInputElement, 'target not input');
     this.setState({ currentPassword: target.value });
   };
 
   onSubmit = (event: SyntheticEvent<HTMLButtonElement>) => {
     event.preventDefault();
 
     if (this.state.newPassword === '') {
       this.setState(
         {
           newPassword: '',
           confirmNewPassword: '',
           errorMessage: 'empty password',
         },
         () => {
           invariant(this.newPasswordInput, 'newPasswordInput ref unset');
           this.newPasswordInput.focus();
         },
       );
     } else if (this.state.newPassword !== this.state.confirmNewPassword) {
       this.setState(
         {
           newPassword: '',
           confirmNewPassword: '',
           errorMessage: 'passwords don’t match',
         },
         () => {
           invariant(this.newPasswordInput, 'newPasswordInput ref unset');
           this.newPasswordInput.focus();
         },
       );
       return;
     }
 
-    this.props.dispatchActionPromise(
+    void this.props.dispatchActionPromise(
       changeUserPasswordActionTypes,
       this.changeUserSettingsAction(),
     );
   };
 
   async changeUserSettingsAction(): Promise<void> {
     try {
       await this.props.changeUserPassword({
         updatedFields: {
           password: this.state.newPassword,
         },
         currentPassword: this.state.currentPassword,
       });
       this.props.popModal();
     } catch (e) {
       if (e.message === 'invalid_credentials') {
         this.setState(
           {
             currentPassword: '',
             errorMessage: 'wrong current password',
           },
           () => {
             invariant(
               this.currentPasswordInput,
               'currentPasswordInput ref unset',
             );
             this.currentPasswordInput.focus();
           },
         );
       } else {
         this.setState(
           {
             newPassword: '',
             confirmNewPassword: '',
             currentPassword: '',
             errorMessage: 'unknown error',
           },
           () => {
             invariant(this.newPasswordInput, 'newPasswordInput ref unset');
             this.newPasswordInput.focus();
           },
         );
       }
       throw e;
     }
   }
 }
 
 const changeUserPasswordLoadingStatusSelector = createLoadingStatusSelector(
   changeUserPasswordActionTypes,
 );
 const ConnectedPasswordChangeModal: React.ComponentType<{}> = React.memo<{}>(
   function ConnectedPasswordChangeModal(): React.Node {
     const inputDisabled = useSelector(
       state => changeUserPasswordLoadingStatusSelector(state) === 'loading',
     );
     const callChangeUserPassword = useServerCall(changeUserPassword);
     const dispatchActionPromise = useDispatchActionPromise();
 
     const modalContext = useModalContext();
 
     const currentUserInfo = useSelector(state => state.currentUserInfo);
     const stringForUser = useStringForUser(currentUserInfo);
 
     return (
       <PasswordChangeModal
         inputDisabled={inputDisabled}
         changeUserPassword={callChangeUserPassword}
         dispatchActionPromise={dispatchActionPromise}
         popModal={modalContext.popModal}
         stringForUser={stringForUser}
       />
     );
   },
 );
 
 export default ConnectedPasswordChangeModal;
diff --git a/web/sidebar/community-creation/community-creation-modal.react.js b/web/sidebar/community-creation/community-creation-modal.react.js
index e51415293..bfa5a5992 100644
--- a/web/sidebar/community-creation/community-creation-modal.react.js
+++ b/web/sidebar/community-creation/community-creation-modal.react.js
@@ -1,209 +1,209 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useNewThread,
   newThreadActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import type { NewThreadResult } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/action-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import CommunityCreationKeyserverLabel from './community-creation-keyserver-label.react.js';
 import CommunityCreationMembersModal from './community-creation-members-modal.react.js';
 import css from './community-creation-modal.css';
 import UserAvatar from '../../avatars/user-avatar.react.js';
 import CommIcon from '../../CommIcon.react.js';
 import Button, { buttonThemes } from '../../components/button.react.js';
 import EnumSettingsOption from '../../components/enum-settings-option.react.js';
 import LoadingIndicator from '../../loading-indicator.react.js';
 import Input from '../../modals/input.react.js';
 import Modal from '../../modals/modal.react.js';
 import { updateNavInfoActionType } from '../../redux/action-types.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { nonThreadCalendarQuery } from '../../selectors/nav-selectors.js';
 
 const announcementStatements = [
   {
     statement:
       `This option sets the community’s root channel to an ` +
       `announcement channel. Only admins and other admin-appointed ` +
       `roles can send messages in an announcement channel.`,
     isStatementValid: true,
     styleStatementBasedOnValidity: false,
   },
 ];
 
 const createNewCommunityLoadingStatusSelector =
   createLoadingStatusSelector(newThreadActionTypes);
 
 function CommunityCreationModal(): React.Node {
   const modalContext = useModalContext();
 
   const dispatch = useDispatch();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const callNewThread = useNewThread();
   const calendarQueryFunc = useSelector(nonThreadCalendarQuery);
 
   const [errorMessage, setErrorMessage] = React.useState<?string>();
 
   const [pendingCommunityName, setPendingCommunityName] =
     React.useState<string>('');
 
   const onChangePendingCommunityName = React.useCallback(
     (event: SyntheticEvent<HTMLInputElement>) => {
       setErrorMessage();
       setPendingCommunityName(event.currentTarget.value);
     },
     [],
   );
 
   const [announcementSetting, setAnnouncementSetting] = React.useState(false);
   const onAnnouncementSelected = React.useCallback(() => {
     setErrorMessage();
     setAnnouncementSetting(!announcementSetting);
   }, [announcementSetting]);
 
   const callCreateNewCommunity = React.useCallback(async () => {
     const calendarQuery = calendarQueryFunc();
 
     try {
       const newThreadResult: NewThreadResult = await callNewThread({
         name: pendingCommunityName,
         type: announcementSetting
           ? threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT
           : threadTypes.COMMUNITY_ROOT,
         calendarQuery,
       });
       return newThreadResult;
     } catch (e) {
       setErrorMessage('Community creation failed. Please try again.');
       throw e;
     }
   }, [
     announcementSetting,
     calendarQueryFunc,
     callNewThread,
     pendingCommunityName,
   ]);
 
   const createNewCommunity = React.useCallback(async () => {
     setErrorMessage();
 
     const newThreadResultPromise = callCreateNewCommunity();
-    dispatchActionPromise(newThreadActionTypes, newThreadResultPromise);
+    void dispatchActionPromise(newThreadActionTypes, newThreadResultPromise);
     const newThreadResult: NewThreadResult = await newThreadResultPromise;
 
     const { newThreadID } = newThreadResult;
     await dispatch({
       type: updateNavInfoActionType,
       payload: {
         activeChatThreadID: newThreadID,
       },
     });
 
     modalContext.popModal();
     modalContext.pushModal(
       <CommunityCreationMembersModal
         onClose={modalContext.popModal}
         threadID={newThreadID}
       />,
     );
   }, [callCreateNewCommunity, dispatch, dispatchActionPromise, modalContext]);
 
   const megaphoneIcon = React.useMemo(
     () => <CommIcon icon="megaphone" size={24} />,
     [],
   );
 
   const avatarNodeEnabled = false;
   let avatarNode;
   if (avatarNodeEnabled) {
     avatarNode = (
       <div className={css.avatarContainer}>
         <UserAvatar userID="256" size="XL" />
       </div>
     );
   }
 
   const createNewCommunityLoadingStatus: LoadingStatus = useSelector(
     createNewCommunityLoadingStatusSelector,
   );
   let buttonContent;
   if (createNewCommunityLoadingStatus === 'loading') {
     buttonContent = (
       <LoadingIndicator
         status={createNewCommunityLoadingStatus}
         size="medium"
       />
     );
   } else if (errorMessage) {
     buttonContent = errorMessage;
   } else {
     buttonContent = 'Create community';
   }
 
   return (
     <Modal
       name="Create a community"
       onClose={modalContext.popModal}
       size="large"
     >
       <div className={css.modalBody}>
         <CommunityCreationKeyserverLabel />
         {avatarNode}
         <form method="POST" className={css.formContainer}>
           <div>
             <div className={css.formTitle}>Community Name</div>
             <div className={css.formContent}>
               <Input
                 type="text"
                 value={pendingCommunityName}
                 placeholder="Community Name"
                 onChange={onChangePendingCommunityName}
               />
             </div>
           </div>
           <div className={css.formNotice}>
             You may edit your community&rsquo;s image and name later.
           </div>
           <hr />
           <div className={css.optionalSettingsContainer}>
             <div className={css.optionalSettingsLabel}>Optional settings</div>
             <EnumSettingsOption
               selected={announcementSetting}
               onSelect={onAnnouncementSelected}
               icon={megaphoneIcon}
               title="Announcement"
               statements={announcementStatements}
               iconPosition="top"
               type="checkbox"
             />
           </div>
           <div className={css.createCommunityButtonContainer}>
             <Button
               onClick={createNewCommunity}
               variant="filled"
               buttonColor={
                 errorMessage ? buttonThemes.danger : buttonThemes.standard
               }
               disabled={createNewCommunityLoadingStatus === 'loading'}
             >
               <div className={css.createCommunityButtonContent}>
                 {buttonContent}
               </div>
             </Button>
           </div>
         </form>
       </div>
     </Modal>
   );
 }
 
 export default CommunityCreationModal;