diff --git a/native/avatars/avatar-hooks.js b/native/avatars/avatar-hooks.js
index 9c1501828..a50e51d69 100644
--- a/native/avatars/avatar-hooks.js
+++ b/native/avatars/avatar-hooks.js
@@ -1,556 +1,524 @@
 // @flow
 
 import { useActionSheet } from '@expo/react-native-action-sheet';
 import * as ImagePicker from 'expo-image-picker';
 import * as React from 'react';
 import { Platform } from 'react-native';
 import Alert from 'react-native/Libraries/Alert/Alert.js';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
 import {
   changeThreadSettings,
   changeThreadSettingsActionTypes,
 } from 'lib/actions/thread-actions.js';
 import { uploadMultimedia } from 'lib/actions/upload-actions.js';
 import {
   updateUserAvatar,
   updateUserAvatarActionTypes,
 } from 'lib/actions/user-actions.js';
 import {
   extensionFromFilename,
   filenameFromPathOrURI,
 } from 'lib/media/file-utils.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type {
   ImageAvatarDBContent,
   ENSAvatarDBContent,
   UpdateUserAvatarRemoveRequest,
 } from 'lib/types/avatar-types.js';
 import type { SetState } from 'lib/types/hook-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type {
   NativeMediaSelection,
   MediaLibrarySelection,
   MediaMissionFailure,
   UploadMultimediaResult,
 } from 'lib/types/media-types.js';
 import type { UpdateThreadRequest } from 'lib/types/thread-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 
 import CommIcon from '../components/comm-icon.react.js';
 import SWMansionIcon from '../components/swmansion-icon.react.js';
 import { getCompatibleMediaURI } from '../media/identifier-utils.js';
 import type { MediaResult } from '../media/media-utils.js';
 import { processMedia } from '../media/media-utils.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 function useUploadProcessedMedia(): MediaResult => Promise<UploadMultimediaResult> {
   const callUploadMultimedia = useServerCall(uploadMultimedia);
   const uploadProcessedMultimedia: MediaResult => Promise<UploadMultimediaResult> =
     React.useCallback(
       processedMedia => {
         const { uploadURI, filename, mime, dimensions } = processedMedia;
         return callUploadMultimedia(
           {
             uri: uploadURI,
             name: filename,
             type: mime,
           },
           dimensions,
         );
       },
       [callUploadMultimedia],
     );
   return uploadProcessedMultimedia;
 }
 
 function useProcessSelectedMedia(): NativeMediaSelection => Promise<
   MediaMissionFailure | MediaResult,
 > {
   const hasWiFi = useSelector(state => state.connectivity.hasWiFi);
   const staffCanSee = useStaffCanSee();
 
   const processSelectedMedia = React.useCallback(
     async (selection: NativeMediaSelection) => {
       const { resultPromise } = processMedia(selection, {
         hasWiFi,
         finalFileHeaderCheck: staffCanSee,
       });
 
       return await resultPromise;
     },
     [hasWiFi, staffCanSee],
   );
 
   return processSelectedMedia;
 }
 
 async function selectFromGallery(): Promise<?MediaLibrarySelection> {
   try {
     const { assets, canceled } = await ImagePicker.launchImageLibraryAsync({
       mediaTypes: ImagePicker.MediaTypeOptions.Images,
       allowsEditing: true,
       allowsMultipleSelection: false,
       quality: 1,
     });
 
     if (canceled || assets.length === 0) {
       return undefined;
     }
 
     const asset = assets.pop();
     const { width, height, assetId: mediaNativeID } = asset;
     const assetFilename =
       asset.fileName || filenameFromPathOrURI(asset.uri) || '';
     const uri = getCompatibleMediaURI(
       asset.uri,
       extensionFromFilename(assetFilename),
     );
 
     const currentTime = Date.now();
     const selection: MediaLibrarySelection = {
       step: 'photo_library',
       dimensions: { height, width },
       uri,
       filename: assetFilename,
       mediaNativeID,
       selectTime: currentTime,
       sendTime: currentTime,
       retries: 0,
     };
 
     return selection;
   } catch (e) {
     console.log(e);
     return undefined;
   }
 }
 
 function useUploadSelectedMedia(
   setProcessingOrUploadInProgress: SetState<boolean>,
 ): (selection: ?NativeMediaSelection) => Promise<?string> {
   const processSelectedMedia = useProcessSelectedMedia();
   const uploadProcessedMedia = useUploadProcessedMedia();
 
   return React.useCallback(
     async (selection: ?NativeMediaSelection) => {
       if (!selection) {
         Alert.alert(
           'Media selection failed',
           'Unable to select media from Media Library.',
         );
         return undefined;
       }
 
       setProcessingOrUploadInProgress(true);
 
       let processedMedia;
       try {
         processedMedia = await processSelectedMedia(selection);
       } catch (e) {
         Alert.alert(
           'Media processing failed',
           'Unable to process selected media.',
         );
         setProcessingOrUploadInProgress(false);
         return undefined;
       }
 
       if (!processedMedia.success) {
         Alert.alert(
           'Media processing failed',
           'Unable to process selected media.',
         );
         setProcessingOrUploadInProgress(false);
         return undefined;
       }
 
       let uploadedMedia: UploadMultimediaResult;
       try {
         uploadedMedia = await uploadProcessedMedia(processedMedia);
       } catch {
         Alert.alert(
           'Media upload failed',
           'Unable to upload selected media. Please try again.',
         );
         setProcessingOrUploadInProgress(false);
         return undefined;
       }
 
       return uploadedMedia.id;
     },
     [
       processSelectedMedia,
       setProcessingOrUploadInProgress,
       uploadProcessedMedia,
     ],
   );
 }
 
 const updateUserAvatarLoadingStatusSelector = createLoadingStatusSelector(
   updateUserAvatarActionTypes,
 );
 function useSelectFromGalleryAndUpdateUserAvatar(): [
   () => Promise<void>,
   boolean,
 ] {
   const dispatchActionPromise = useDispatchActionPromise();
   const updateUserAvatarCall = useServerCall(updateUserAvatar);
 
   const [processingOrUploadInProgress, setProcessingOrUploadInProgress] =
     React.useState(false);
 
   const updateUserAvatarLoadingStatus: LoadingStatus = useSelector(
     updateUserAvatarLoadingStatusSelector,
   );
 
   const inProgress = React.useMemo(
     () =>
       processingOrUploadInProgress ||
       updateUserAvatarLoadingStatus === 'loading',
     [processingOrUploadInProgress, updateUserAvatarLoadingStatus],
   );
 
   const uploadSelectedMedia = useUploadSelectedMedia(
     setProcessingOrUploadInProgress,
   );
 
   const selectFromGalleryAndUpdateUserAvatar = React.useCallback(async () => {
     const selection: ?MediaLibrarySelection = await selectFromGallery();
 
     const uploadedMediaID = await uploadSelectedMedia(selection);
 
     if (!uploadedMediaID) {
       return;
     }
 
     const imageAvatarUpdateRequest: ImageAvatarDBContent = {
       type: 'image',
       uploadID: uploadedMediaID,
     };
 
     dispatchActionPromise(
       updateUserAvatarActionTypes,
       (async () => {
         setProcessingOrUploadInProgress(false);
         try {
           return await updateUserAvatarCall(imageAvatarUpdateRequest);
         } catch (e) {
           Alert.alert('Avatar update failed', 'Unable to update avatar.');
           throw e;
         }
       })(),
     );
   }, [dispatchActionPromise, updateUserAvatarCall, uploadSelectedMedia]);
 
   return React.useMemo(
     () => [selectFromGalleryAndUpdateUserAvatar, inProgress],
     [selectFromGalleryAndUpdateUserAvatar, inProgress],
   );
 }
 
 const threadAvatarLoadingStatusSelector = createLoadingStatusSelector(
   changeThreadSettingsActionTypes,
   `${changeThreadSettingsActionTypes.started}:avatar`,
 );
 function useSelectFromGalleryAndUpdateThreadAvatar(
   threadID: string,
 ): [() => Promise<void>, boolean] {
   const dispatchActionPromise = useDispatchActionPromise();
   const changeThreadSettingsCall = useServerCall(changeThreadSettings);
 
   const [processingOrUploadInProgress, setProcessingOrUploadInProgress] =
     React.useState(false);
 
   const updateThreadAvatarLoadingStatus: LoadingStatus = useSelector(
     threadAvatarLoadingStatusSelector,
   );
 
   const inProgress = React.useMemo(
     () =>
       processingOrUploadInProgress ||
       updateThreadAvatarLoadingStatus === 'loading',
     [processingOrUploadInProgress, updateThreadAvatarLoadingStatus],
   );
 
   const uploadSelectedMedia = useUploadSelectedMedia(
     setProcessingOrUploadInProgress,
   );
 
   const selectFromGalleryAndUpdateThreadAvatar = React.useCallback(async () => {
     const selection: ?MediaLibrarySelection = await selectFromGallery();
 
     const uploadedMediaID = await uploadSelectedMedia(selection);
 
     if (!uploadedMediaID) {
       return;
     }
 
     const imageAvatarUpdateRequest: ImageAvatarDBContent = {
       type: 'image',
       uploadID: uploadedMediaID,
     };
 
     const updateThreadRequest: UpdateThreadRequest = {
       threadID,
       changes: {
         avatar: imageAvatarUpdateRequest,
       },
     };
 
     dispatchActionPromise(
       changeThreadSettingsActionTypes,
       (async () => {
         setProcessingOrUploadInProgress(false);
         try {
           return await changeThreadSettingsCall(updateThreadRequest);
         } catch (e) {
           Alert.alert('Avatar update failed', 'Unable to update avatar.');
           throw e;
         }
       })(),
       { customKeyName: `${changeThreadSettingsActionTypes.started}:avatar` },
     );
   }, [
     changeThreadSettingsCall,
     dispatchActionPromise,
     threadID,
     uploadSelectedMedia,
   ]);
 
   return React.useMemo(
     () => [selectFromGalleryAndUpdateThreadAvatar, inProgress],
     [inProgress, selectFromGalleryAndUpdateThreadAvatar],
   );
 }
 
-function useRemoveUserAvatar(): [() => void, boolean] {
-  const dispatchActionPromise = useDispatchActionPromise();
-  const updateUserAvatarCall = useServerCall(updateUserAvatar);
-  const updateUserAvatarLoadingStatus: LoadingStatus = useSelector(
-    updateUserAvatarLoadingStatusSelector,
-  );
-
-  const removeUserAvatar = React.useCallback(() => {
-    const removeAvatarRequest: UpdateUserAvatarRemoveRequest = {
-      type: 'remove',
-    };
-
-    dispatchActionPromise(
-      updateUserAvatarActionTypes,
-      (async () => {
-        try {
-          return await updateUserAvatarCall(removeAvatarRequest);
-        } catch (e) {
-          Alert.alert('Avatar update failed', 'Unable to update avatar.');
-          throw e;
-        }
-      })(),
-    );
-  }, [dispatchActionPromise, updateUserAvatarCall]);
-
-  return React.useMemo(
-    () => [removeUserAvatar, updateUserAvatarLoadingStatus === 'loading'],
-    [removeUserAvatar, updateUserAvatarLoadingStatus],
-  );
-}
-
 function useRemoveThreadAvatar(threadID: string): [() => void, boolean] {
   const dispatchActionPromise = useDispatchActionPromise();
   const changeThreadSettingsCall = useServerCall(changeThreadSettings);
   const updateThreadAvatarLoadingStatus: LoadingStatus = useSelector(
     threadAvatarLoadingStatusSelector,
   );
 
   const removeThreadAvatar = React.useCallback(() => {
     const removeAvatarRequest: UpdateUserAvatarRemoveRequest = {
       type: 'remove',
     };
 
     const updateThreadRequest: UpdateThreadRequest = {
       threadID,
       changes: {
         avatar: removeAvatarRequest,
       },
     };
 
     dispatchActionPromise(
       changeThreadSettingsActionTypes,
       (async () => {
         try {
           return await changeThreadSettingsCall(updateThreadRequest);
         } catch (e) {
           Alert.alert('Avatar update failed', 'Unable to update avatar.');
           throw e;
         }
       })(),
       { customKeyName: `${changeThreadSettingsActionTypes.started}:avatar` },
     );
   }, [changeThreadSettingsCall, dispatchActionPromise, threadID]);
 
   return React.useMemo(
     () => [removeThreadAvatar, updateThreadAvatarLoadingStatus === 'loading'],
     [removeThreadAvatar, updateThreadAvatarLoadingStatus],
   );
 }
 
 function useENSUserAvatar(): [() => void, boolean] {
   const dispatchActionPromise = useDispatchActionPromise();
   const updateUserAvatarCall = useServerCall(updateUserAvatar);
 
   const updateUserAvatarLoadingStatus: LoadingStatus = useSelector(
     updateUserAvatarLoadingStatusSelector,
   );
 
   const saveENSUserAvatar = React.useCallback(() => {
     const ensAvatarRequest: ENSAvatarDBContent = {
       type: 'ens',
     };
 
     dispatchActionPromise(
       updateUserAvatarActionTypes,
       (async () => {
         try {
           return await updateUserAvatarCall(ensAvatarRequest);
         } catch (e) {
           Alert.alert('Avatar update failed', 'Unable to update avatar.');
           throw e;
         }
       })(),
     );
   }, [dispatchActionPromise, updateUserAvatarCall]);
 
   return React.useMemo(
     () => [saveENSUserAvatar, updateUserAvatarLoadingStatus === 'loading'],
     [saveENSUserAvatar, updateUserAvatarLoadingStatus],
   );
 }
 
 type ShowAvatarActionSheetOptions = {
   +id: 'emoji' | 'image' | 'ens' | 'cancel' | 'remove',
   +onPress?: () => mixed,
 };
 function useShowAvatarActionSheet(
   options: $ReadOnlyArray<ShowAvatarActionSheetOptions>,
 ): () => void {
   options = Platform.OS === 'ios' ? [...options, { id: 'cancel' }] : options;
 
   const insets = useSafeAreaInsets();
   const { showActionSheetWithOptions } = useActionSheet();
   const styles = useStyles(unboundStyles);
 
   const showAvatarActionSheet = React.useCallback(() => {
     const texts = options.map((option: ShowAvatarActionSheetOptions) => {
       if (option.id === 'emoji') {
         return 'Use Emoji';
       } else if (option.id === 'image') {
         return 'Select image';
       } else if (option.id === 'ens') {
         return 'Use ENS Avatar';
       } else if (option.id === 'remove') {
         return 'Remove avatar';
       } else {
         return 'Cancel';
       }
     });
 
     const cancelButtonIndex = options.findIndex(
       option => option.id === 'cancel',
     );
 
     const containerStyle = {
       paddingBotton: insets.bottom,
     };
 
     const icons = options.map(option => {
       if (option.id === 'emoji') {
         return (
           <SWMansionIcon
             name="emote-smile"
             size={22}
             style={styles.bottomSheetIcon}
           />
         );
       } else if (option.id === 'image') {
         return (
           <SWMansionIcon
             name="image-1"
             size={22}
             style={styles.bottomSheetIcon}
           />
         );
       } else if (option.id === 'ens') {
         return (
           <CommIcon
             name="ethereum-outline"
             size={18}
             style={styles.bottomSheetIcon}
           />
         );
       } else if (option.id === 'remove') {
         return (
           <SWMansionIcon
             name="trash-2"
             size={22}
             style={styles.bottomSheetIcon}
           />
         );
       } else {
         return undefined;
       }
     });
 
     const onPressAction = (selectedIndex: ?number) => {
       if (
         selectedIndex === null ||
         selectedIndex === undefined ||
         selectedIndex < 0
       ) {
         return;
       }
       const option = options[selectedIndex];
       if (option.onPress) {
         option.onPress();
       }
     };
 
     showActionSheetWithOptions(
       {
         options: texts,
         cancelButtonIndex,
         containerStyle,
         icons,
       },
       onPressAction,
     );
   }, [
     insets.bottom,
     options,
     showActionSheetWithOptions,
     styles.bottomSheetIcon,
   ]);
 
   return showAvatarActionSheet;
 }
 
 const unboundStyles = {
   bottomSheetIcon: {
     color: '#000000',
   },
 };
 
 export {
   useUploadProcessedMedia,
   useProcessSelectedMedia,
   useShowAvatarActionSheet,
   useSelectFromGalleryAndUpdateUserAvatar,
   useSelectFromGalleryAndUpdateThreadAvatar,
-  useRemoveUserAvatar,
   useRemoveThreadAvatar,
   useENSUserAvatar,
 };
diff --git a/native/avatars/edit-user-avatar-provider.react.js b/native/avatars/edit-user-avatar-provider.react.js
new file mode 100644
index 000000000..b1e6d8fb0
--- /dev/null
+++ b/native/avatars/edit-user-avatar-provider.react.js
@@ -0,0 +1,80 @@
+// @flow
+
+import * as React from 'react';
+import { Alert } from 'react-native';
+
+import {
+  updateUserAvatar,
+  updateUserAvatarActionTypes,
+} from 'lib/actions/user-actions.js';
+import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
+import type { UpdateUserAvatarRemoveRequest } from 'lib/types/avatar-types.js';
+import type { LoadingStatus } from 'lib/types/loading-types.js';
+import {
+  useDispatchActionPromise,
+  useServerCall,
+} from 'lib/utils/action-utils.js';
+
+import { useSelector } from '../redux/redux-utils.js';
+
+export type EditUserAvatarContextType = {
+  +userAvatarSaveInProgress: boolean,
+  +removeUserAvatar: () => void,
+};
+
+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 dispatchActionPromise = useDispatchActionPromise();
+  const updateUserAvatarCall = useServerCall(updateUserAvatar);
+
+  const updateUserAvatarLoadingStatus: LoadingStatus = useSelector(
+    updateUserAvatarLoadingStatusSelector,
+  );
+
+  const userAvatarSaveInProgress = updateUserAvatarLoadingStatus === 'loading';
+
+  const removeUserAvatar = React.useCallback(() => {
+    const removeAvatarRequest: UpdateUserAvatarRemoveRequest = {
+      type: 'remove',
+    };
+
+    dispatchActionPromise(
+      updateUserAvatarActionTypes,
+      (async () => {
+        try {
+          return await updateUserAvatarCall(removeAvatarRequest);
+        } catch (e) {
+          Alert.alert('Avatar update failed', 'Unable to update avatar.');
+          throw e;
+        }
+      })(),
+    );
+  }, [dispatchActionPromise, updateUserAvatarCall]);
+
+  const context = React.useMemo(
+    () => ({
+      userAvatarSaveInProgress,
+      removeUserAvatar,
+    }),
+    [removeUserAvatar, userAvatarSaveInProgress],
+  );
+
+  return (
+    <EditUserAvatarContext.Provider value={context}>
+      {children}
+    </EditUserAvatarContext.Provider>
+  );
+}
+
+export { EditUserAvatarContext, EditUserAvatarProvider };
diff --git a/native/avatars/edit-user-avatar.react.js b/native/avatars/edit-user-avatar.react.js
index 49b31ac56..ad0322eee 100644
--- a/native/avatars/edit-user-avatar.react.js
+++ b/native/avatars/edit-user-avatar.react.js
@@ -1,100 +1,104 @@
 // @flow
 
+import invariant from 'invariant';
 import * as React from 'react';
 import { ActivityIndicator, TouchableOpacity, View } from 'react-native';
 
 import { useENSAvatar } from 'lib/hooks/ens-cache.js';
 import { getETHAddressForUserInfo } from 'lib/shared/account-utils.js';
 
 import {
   useENSUserAvatar,
-  useRemoveUserAvatar,
   useSelectFromGalleryAndUpdateUserAvatar,
   useShowAvatarActionSheet,
 } from './avatar-hooks.js';
 import EditAvatarBadge from './edit-avatar-badge.react.js';
+import { EditUserAvatarContext } from './edit-user-avatar-provider.react.js';
 import UserAvatar from './user-avatar.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 
 type Props = {
   +userID: ?string,
   +onPressEmojiAvatarFlow: () => mixed,
   +disabled?: boolean,
 };
 function EditUserAvatar(props: Props): React.Node {
   const styles = useStyles(unboundStyles);
   const { userID, onPressEmojiAvatarFlow, disabled } = props;
 
+  const editUserAvatarContext = React.useContext(EditUserAvatarContext);
+  invariant(editUserAvatarContext, 'editUserAvatarContext should be set');
+  const { userAvatarSaveInProgress, removeUserAvatar } = editUserAvatarContext;
+
   const currentUserInfo = useSelector(state => state.currentUserInfo);
   const ethAddress = React.useMemo(
     () => getETHAddressForUserInfo(currentUserInfo),
     [currentUserInfo],
   );
   const ensAvatarURI = useENSAvatar(ethAddress);
 
   const [selectFromGalleryAndUpdateUserAvatar, isGalleryAvatarUpdateLoading] =
     useSelectFromGalleryAndUpdateUserAvatar();
 
   const [saveENSUserAvatar, isENSAvatarUpdateLoading] = useENSUserAvatar();
-  const [removeUserAvatar, isRemoveAvatarUpdateLoading] = useRemoveUserAvatar();
 
   const isAvatarUpdateInProgress =
     isGalleryAvatarUpdateLoading ||
-    isRemoveAvatarUpdateLoading ||
-    isENSAvatarUpdateLoading;
+    isENSAvatarUpdateLoading ||
+    userAvatarSaveInProgress;
 
   const actionSheetConfig = React.useMemo(() => {
     const configOptions = [
       { id: 'emoji', onPress: onPressEmojiAvatarFlow },
       { id: 'image', onPress: selectFromGalleryAndUpdateUserAvatar },
     ];
 
     if (ensAvatarURI) {
       configOptions.push({ id: 'ens', onPress: saveENSUserAvatar });
     }
 
     configOptions.push({ id: 'remove', onPress: removeUserAvatar });
 
     return configOptions;
   }, [
     ensAvatarURI,
     onPressEmojiAvatarFlow,
     removeUserAvatar,
     saveENSUserAvatar,
     selectFromGalleryAndUpdateUserAvatar,
   ]);
 
   const showAvatarActionSheet = useShowAvatarActionSheet(actionSheetConfig);
 
   let spinner;
   if (isAvatarUpdateInProgress) {
     spinner = (
       <View style={styles.spinnerContainer}>
         <ActivityIndicator color="white" size="large" />
       </View>
     );
   }
 
   return (
     <TouchableOpacity onPress={showAvatarActionSheet} disabled={disabled}>
       <UserAvatar userID={userID} size="profile" />
       {spinner}
       {!disabled ? <EditAvatarBadge /> : null}
     </TouchableOpacity>
   );
 }
 
 const unboundStyles = {
   spinnerContainer: {
     position: 'absolute',
     alignItems: 'center',
     justifyContent: 'center',
     top: 0,
     bottom: 0,
     left: 0,
     right: 0,
   },
 };
 
 export default EditUserAvatar;
diff --git a/native/root.react.js b/native/root.react.js
index 1629072f0..de652e8df 100644
--- a/native/root.react.js
+++ b/native/root.react.js
@@ -1,304 +1,307 @@
 // @flow
 
 import { ActionSheetProvider } from '@expo/react-native-action-sheet';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { useReduxDevToolsExtension } from '@react-navigation/devtools';
 import { NavigationContainer } from '@react-navigation/native';
 import type { PossiblyStaleNavigationState } 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 { ENSCacheProvider } from 'lib/components/ens-cache-provider.react.js';
 import { MediaCacheProvider } from 'lib/components/media-cache-provider.react.js';
 import { actionLogger } from 'lib/utils/action-logger.js';
 
+import { EditUserAvatarProvider } from './avatars/edit-user-avatar-provider.react.js';
 import ChatContextProvider from './chat/chat-context-provider.react.js';
 import { FeatureFlagsProvider } from './components/feature-flags-provider.react.js';
 import PersistedStateGate from './components/persisted-state-gate.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 { 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 } 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 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';
 
 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();
   const navDispatchRef = React.useRef();
   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(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 () => {
       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([]);
   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 () => {
         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();
   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 => {
       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 gated: React.Node = (
     <>
       <LifecycleHandler />
       <DisconnectedBarVisibilityHandler />
       <DimensionsUpdater />
       <ConnectivityUpdater />
       <ThemeHandler />
       <OrientationHandler />
     </>
   );
   let navigation;
   if (initialState) {
     navigation = (
       <NavigationContainer
         initialState={initialState}
         onStateChange={onNavigationStateChange}
         theme={theme}
         ref={containerRef}
       >
         <RootNavigator />
         <NavigationHandler />
       </NavigationContainer>
     );
   }
   return (
     <GestureHandlerRootView style={styles.app}>
       <StaffContextProvider>
         <FeatureFlagsProvider>
           <NavContext.Provider value={navContext}>
             <RootContext.Provider value={rootContext}>
               <InputStateContainer>
                 <SafeAreaProvider initialMetrics={initialWindowMetrics}>
                   <ActionSheetProvider>
                     <ENSCacheProvider provider={provider}>
                       <MediaCacheProvider persistence={filesystemMediaCache}>
-                        <MarkdownContextProvider>
-                          <ChatContextProvider>
-                            <SQLiteDataHandler />
-                            <ConnectedStatusBar />
-                            <ReduxPersistGate persistor={getPersistor()}>
-                              {gated}
-                            </ReduxPersistGate>
-                            <PersistedStateGate>
-                              <Socket
-                                detectUnsupervisedBackgroundRef={
-                                  detectUnsupervisedBackgroundRef
-                                }
-                              />
-                            </PersistedStateGate>
-                            {navigation}
-                          </ChatContextProvider>
-                        </MarkdownContextProvider>
+                        <EditUserAvatarProvider>
+                          <MarkdownContextProvider>
+                            <ChatContextProvider>
+                              <SQLiteDataHandler />
+                              <ConnectedStatusBar />
+                              <ReduxPersistGate persistor={getPersistor()}>
+                                {gated}
+                              </ReduxPersistGate>
+                              <PersistedStateGate>
+                                <Socket
+                                  detectUnsupervisedBackgroundRef={
+                                    detectUnsupervisedBackgroundRef
+                                  }
+                                />
+                              </PersistedStateGate>
+                              {navigation}
+                            </ChatContextProvider>
+                          </MarkdownContextProvider>
+                        </EditUserAvatarProvider>
                       </MediaCacheProvider>
                     </ENSCacheProvider>
                   </ActionSheetProvider>
                 </SafeAreaProvider>
               </InputStateContainer>
             </RootContext.Provider>
           </NavContext.Provider>
         </FeatureFlagsProvider>
       </StaffContextProvider>
     </GestureHandlerRootView>
   );
 }
 
 const styles = StyleSheet.create({
   app: {
     flex: 1,
   },
 });
 
 function AppRoot(): React.Node {
   return (
     <Provider store={store}>
       <ErrorBoundary>
         <Root />
       </ErrorBoundary>
     </Provider>
   );
 }
 export default AppRoot;