diff --git a/lib/components/base-edit-user-avatar-provider.react.js b/lib/components/base-edit-user-avatar-provider.react.js
index f21dc6292..64b0b5009 100644
--- a/lib/components/base-edit-user-avatar-provider.react.js
+++ b/lib/components/base-edit-user-avatar-provider.react.js
@@ -1,171 +1,161 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   updateUserAvatar,
   updateUserAvatarActionTypes,
 } from '../actions/user-actions.js';
 import { createLoadingStatusSelector } from '../selectors/loading-selectors.js';
 import type {
   ImageAvatarDBContent,
   UpdateUserAvatarRequest,
 } from '../types/avatar-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 = {
   +userAvatarSaveInProgress: boolean,
   +updateImageUserAvatar: (selection: NativeMediaSelection) => Promise<void>,
   +setUserAvatar: (avatarRequest: UpdateUserAvatarRequest) => Promise<void>,
   +setRegistrationMode: (registrationMode: RegistrationMode) => void,
   +getRegistrationModeEnabled: () => boolean,
 };
 
 const EditUserAvatarContext: React.Context<?EditUserAvatarContextType> =
   React.createContext<?EditUserAvatarContextType>();
 
 const updateUserAvatarLoadingStatusSelector = createLoadingStatusSelector(
   updateUserAvatarActionTypes,
 );
 
 type Props = {
   +displayFailureAlert?: () => mixed,
   +useUploadSelectedMedia: (
     setProcessingOrUploadInProgress?: (inProgress: boolean) => mixed,
   ) => (selection: NativeMediaSelection) => Promise<?ImageAvatarDBContent>,
   +children: React.Node,
 };
 function BaseEditUserAvatarProvider(props: Props): React.Node {
   const { displayFailureAlert, useUploadSelectedMedia, 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';
 
   const uploadSelectedMedia = useUploadSelectedMedia(
     setUserAvatarMediaUploadInProgress,
   );
 
   const updateImageUserAvatar = React.useCallback(
     async (selection: NativeMediaSelection) => {
       if (registrationModeRef.current.registrationMode === 'on') {
         registrationModeRef.current.successCallback({
           needsUpload: true,
           mediaSelection: selection,
         });
         return;
       }
 
       const imageAvatarUpdateRequest = await uploadSelectedMedia(selection);
       if (!imageAvatarUpdateRequest) {
         return;
       }
 
       const promise = (async () => {
         setUserAvatarMediaUploadInProgress(false);
-        try {
-          return await updateUserAvatarCall(imageAvatarUpdateRequest);
-        } catch (e) {
-          displayFailureAlert && displayFailureAlert();
-          throw e;
-        }
+        return await updateUserAvatarCall(imageAvatarUpdateRequest);
       })();
       dispatchActionPromise(updateUserAvatarActionTypes, promise);
       await promise;
     },
-    [
-      uploadSelectedMedia,
-      dispatchActionPromise,
-      updateUserAvatarCall,
-      displayFailureAlert,
-    ],
+    [uploadSelectedMedia, dispatchActionPromise, updateUserAvatarCall],
   );
 
   const setUserAvatar = React.useCallback(
     async (request: UpdateUserAvatarRequest) => {
       const regMode = registrationModeRef.current;
       if (regMode.registrationMode === 'on') {
         regMode.successCallback({
           needsUpload: false,
           updateUserAvatarRequest: request,
         });
         return;
       }
 
       const promise = (async () => {
         try {
           return await updateUserAvatarCall(request);
         } catch (e) {
           displayFailureAlert && displayFailureAlert();
           throw e;
         }
       })();
       dispatchActionPromise(updateUserAvatarActionTypes, promise);
       await promise;
     },
     [dispatchActionPromise, updateUserAvatarCall, displayFailureAlert],
   );
 
   const setRegistrationMode = React.useCallback((mode: RegistrationMode) => {
     registrationModeRef.current = mode;
   }, []);
   const getRegistrationModeEnabled = React.useCallback(
     () => registrationModeRef.current.registrationMode === 'on',
     [],
   );
 
   const context = React.useMemo(
     () => ({
       userAvatarSaveInProgress,
       updateImageUserAvatar,
       setUserAvatar,
       setRegistrationMode,
       getRegistrationModeEnabled,
     }),
     [
       userAvatarSaveInProgress,
       updateImageUserAvatar,
       setUserAvatar,
       setRegistrationMode,
       getRegistrationModeEnabled,
     ],
   );
 
   return (
     <EditUserAvatarContext.Provider value={context}>
       {children}
     </EditUserAvatarContext.Provider>
   );
 }
 
 export { EditUserAvatarContext, BaseEditUserAvatarProvider };
diff --git a/native/avatars/avatar-hooks.js b/native/avatars/avatar-hooks.js
index 1213da926..e6a3f3df3 100644
--- a/native/avatars/avatar-hooks.js
+++ b/native/avatars/avatar-hooks.js
@@ -1,333 +1,365 @@
 // @flow
 
 import { useActionSheet } from '@expo/react-native-action-sheet';
 import * as ImagePicker from 'expo-image-picker';
 import invariant from 'invariant';
 import * as React from 'react';
 import { Platform } from 'react-native';
 import Alert from 'react-native/Libraries/Alert/Alert.js';
 import filesystem from 'react-native-fs';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
 import { uploadMultimedia } from 'lib/actions/upload-actions.js';
 import { EditUserAvatarContext } from 'lib/components/base-edit-user-avatar-provider.react.js';
 import {
   extensionFromFilename,
   filenameFromPathOrURI,
 } from 'lib/media/file-utils.js';
 import type { ImageAvatarDBContent } from 'lib/types/avatar-types.js';
 import type {
   NativeMediaSelection,
   MediaLibrarySelection,
   MediaMissionFailure,
   UploadMultimediaResult,
 } from 'lib/types/media-types.js';
 import { 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 displayAvatarUpdateFailureAlert(): void {
+  Alert.alert(
+    'Couldn’t save avatar',
+    'Please try again later',
+    [{ text: 'OK' }],
+    { cancelable: true },
+  );
+}
+
 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?: (inProgress: boolean) => mixed,
 ): (selection: NativeMediaSelection) => Promise<?ImageAvatarDBContent> {
   const processSelectedMedia = useProcessSelectedMedia();
   const uploadProcessedMedia = useUploadProcessedMedia();
 
   return React.useCallback(
     async (selection: NativeMediaSelection) => {
       setProcessingOrUploadInProgress?.(true);
       const urisToBeDisposed: Set<string> = new Set([selection.uri]);
 
       let processedMedia;
       try {
         processedMedia = await processSelectedMedia(selection);
         if (processedMedia.uploadURI) {
           urisToBeDisposed.add(processedMedia.uploadURI);
         }
       } catch (e) {
         urisToBeDisposed.forEach(filesystem.unlink);
         Alert.alert(
           'Media processing failed',
           'Unable to process selected media.',
         );
         setProcessingOrUploadInProgress?.(false);
         return undefined;
       }
 
       if (!processedMedia.success) {
         urisToBeDisposed.forEach(filesystem.unlink);
         Alert.alert(
           'Media processing failed',
           'Unable to process selected media.',
         );
         setProcessingOrUploadInProgress?.(false);
         return undefined;
       }
 
       let uploadedMedia: UploadMultimediaResult;
       try {
         uploadedMedia = await uploadProcessedMedia(processedMedia);
         urisToBeDisposed.forEach(filesystem.unlink);
       } catch {
         urisToBeDisposed.forEach(filesystem.unlink);
         Alert.alert(
           'Media upload failed',
           'Unable to upload selected media. Please try again.',
         );
         setProcessingOrUploadInProgress?.(false);
         return undefined;
       }
 
       if (!uploadedMedia.id) {
         return undefined;
       }
 
       return {
         type: 'image',
         uploadID: uploadedMedia.id,
       };
     },
     [
       processSelectedMedia,
       setProcessingOrUploadInProgress,
       uploadProcessedMedia,
     ],
   );
 }
 
+function useNativeUpdateUserImageAvatar(): (
+  selection: NativeMediaSelection,
+) => Promise<void> {
+  const editUserAvatarContext = React.useContext(EditUserAvatarContext);
+  invariant(editUserAvatarContext, 'editUserAvatarContext must be defined');
+  const { updateImageUserAvatar } = editUserAvatarContext;
+
+  const nativeUpdateUserImageAvatar = React.useCallback(
+    async (selection: NativeMediaSelection) => {
+      try {
+        await updateImageUserAvatar(selection);
+      } catch {
+        displayAvatarUpdateFailureAlert();
+      }
+    },
+    [updateImageUserAvatar],
+  );
+
+  return nativeUpdateUserImageAvatar;
+}
+
 function useSelectFromGalleryAndUpdateUserAvatar(): () => Promise<void> {
   const editUserAvatarContext = React.useContext(EditUserAvatarContext);
   invariant(editUserAvatarContext, 'updateImageUserAvatar must be defined');
   const { updateImageUserAvatar } = editUserAvatarContext;
 
   const selectFromGalleryAndUpdateUserAvatar =
     React.useCallback(async (): Promise<void> => {
       const selection = await selectFromGallery();
       if (!selection) {
         return;
       }
       await updateImageUserAvatar(selection);
     }, [updateImageUserAvatar]);
 
   return selectFromGalleryAndUpdateUserAvatar;
 }
 
 type ShowAvatarActionSheetOptions = {
   +id: 'emoji' | 'image' | 'camera' | '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 'Select emoji';
       } else if (option.id === 'image') {
         return 'Select image';
       } else if (option.id === 'camera') {
         return 'Open camera';
       } else if (option.id === 'ens') {
         return 'Use ENS avatar';
       } else if (option.id === 'remove') {
         return 'Reset to default';
       } 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 === 'camera') {
         return (
           <SWMansionIcon
             name="camera"
             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 {
+  displayAvatarUpdateFailureAlert,
   selectFromGallery,
   useUploadSelectedMedia,
   useUploadProcessedMedia,
   useProcessSelectedMedia,
   useShowAvatarActionSheet,
   useSelectFromGalleryAndUpdateUserAvatar,
+  useNativeUpdateUserImageAvatar,
 };
diff --git a/native/avatars/native-edit-user-avatar-provider.react.js b/native/avatars/native-edit-user-avatar-provider.react.js
index 60908d3c0..88c27733a 100644
--- a/native/avatars/native-edit-user-avatar-provider.react.js
+++ b/native/avatars/native-edit-user-avatar-provider.react.js
@@ -1,33 +1,27 @@
 // @flow
 
 import * as React from 'react';
-import { Alert } from 'react-native';
 
 import { BaseEditUserAvatarProvider } from 'lib/components/base-edit-user-avatar-provider.react.js';
 
-import { useUploadSelectedMedia } from './avatar-hooks.js';
-
-const displayAvatarUpdateFailureAlert = () =>
-  Alert.alert(
-    'Couldn’t save avatar',
-    'Please try again later',
-    [{ text: 'OK' }],
-    { cancelable: true },
-  );
+import {
+  useUploadSelectedMedia,
+  displayAvatarUpdateFailureAlert,
+} from './avatar-hooks.js';
 
 type Props = {
   +children: React.Node,
 };
 function NativeEditUserAvatarProvider(props: Props): React.Node {
   const { children } = props;
   return (
     <BaseEditUserAvatarProvider
       displayFailureAlert={displayAvatarUpdateFailureAlert}
       useUploadSelectedMedia={useUploadSelectedMedia}
     >
       {children}
     </BaseEditUserAvatarProvider>
   );
 }
 
 export default NativeEditUserAvatarProvider;
diff --git a/native/media/registration-user-avatar-camera-modal.react.js b/native/media/registration-user-avatar-camera-modal.react.js
index 9e24a3f88..73353e3d2 100644
--- a/native/media/registration-user-avatar-camera-modal.react.js
+++ b/native/media/registration-user-avatar-camera-modal.react.js
@@ -1,32 +1,28 @@
 // @flow
 
-import invariant from 'invariant';
 import * as React from 'react';
 
-import { EditUserAvatarContext } from 'lib/components/base-edit-user-avatar-provider.react.js';
-
 import type { RegistrationNavigationProp } from '../account/registration/registration-navigator.react.js';
+import { useNativeUpdateUserImageAvatar } from '../avatars/avatar-hooks.js';
 import CameraModal from '../media/camera-modal.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 
 type Props = {
   +navigation: RegistrationNavigationProp<'RegistrationUserAvatarCameraModal'>,
   +route: NavigationRoute<'RegistrationUserAvatarCameraModal'>,
 };
 
 function RegistrationUserAvatarCameraModal(props: Props): React.Node {
   const { navigation } = props;
 
-  const editUserAvatarContext = React.useContext(EditUserAvatarContext);
-  invariant(editUserAvatarContext, 'editUserAvatarContext should be set');
-  const { updateImageUserAvatar } = editUserAvatarContext;
+  const nativeUpdateUserImageAvatar = useNativeUpdateUserImageAvatar();
 
   return (
     <CameraModal
-      handlePhotoCapture={updateImageUserAvatar}
+      handlePhotoCapture={nativeUpdateUserImageAvatar}
       navigation={navigation}
     />
   );
 }
 
 export default RegistrationUserAvatarCameraModal;
diff --git a/native/media/user-avatar-camera-modal.react.js b/native/media/user-avatar-camera-modal.react.js
index 16ce65949..1302f7ce8 100644
--- a/native/media/user-avatar-camera-modal.react.js
+++ b/native/media/user-avatar-camera-modal.react.js
@@ -1,32 +1,28 @@
 // @flow
 
-import invariant from 'invariant';
 import * as React from 'react';
 
-import { EditUserAvatarContext } from 'lib/components/base-edit-user-avatar-provider.react.js';
-
+import { useNativeUpdateUserImageAvatar } from '../avatars/avatar-hooks.js';
 import CameraModal from '../media/camera-modal.react.js';
 import type { AppNavigationProp } from '../navigation/app-navigator.react.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 
 type Props = {
   +navigation: AppNavigationProp<'UserAvatarCameraModal'>,
   +route: NavigationRoute<'UserAvatarCameraModal'>,
 };
 
 function UserAvatarCameraModal(props: Props): React.Node {
   const { navigation } = props;
 
-  const editUserAvatarContext = React.useContext(EditUserAvatarContext);
-  invariant(editUserAvatarContext, 'editUserAvatarContext should be set');
-  const { updateImageUserAvatar } = editUserAvatarContext;
+  const nativeUpdateUserImageAvatar = useNativeUpdateUserImageAvatar();
 
   return (
     <CameraModal
-      handlePhotoCapture={updateImageUserAvatar}
+      handlePhotoCapture={nativeUpdateUserImageAvatar}
       navigation={navigation}
     />
   );
 }
 
 export default UserAvatarCameraModal;