diff --git a/native/account/registration/avatar-selection.react.js b/native/account/registration/avatar-selection.react.js
index f80735a90..6f9e98765 100644
--- a/native/account/registration/avatar-selection.react.js
+++ b/native/account/registration/avatar-selection.react.js
@@ -1,218 +1,214 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import {
   EditUserAvatarContext,
   type UserAvatarSelection,
 } from 'lib/components/edit-user-avatar-provider.react.js';
 
 import RegistrationButtonContainer from './registration-button-container.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,
   type AccountSelection,
   type AvatarData,
   ensAvatarSelection,
 } from './registration-types.js';
-import { enableSIWEBackupCreation } from './registration-types.js';
 import EditUserAvatar from '../../avatars/edit-user-avatar.react.js';
 import PrimaryButton from '../../components/primary-button.react.js';
 import { useCurrentLeafRouteName } from '../../navigation/nav-selectors.js';
 import {
   type NavigationRoute,
   RegistrationTermsRouteName,
   CreateSIWEBackupMessageRouteName,
   AvatarSelectionRouteName,
   EmojiAvatarSelectionRouteName,
   RegistrationUserAvatarCameraModalRouteName,
 } from '../../navigation/route-names.js';
 import { useStyles } from '../../themes/colors.js';
 
 export type AvatarSelectionParams = {
   +userSelections: {
     +coolOrNerdMode?: ?CoolOrNerdMode,
     +keyserverURL?: ?string,
     +accountSelection: AccountSelection,
     +farcasterID: ?string,
   },
 };
 
 type Props = {
   +navigation: RegistrationNavigationProp<'AvatarSelection'>,
   +route: NavigationRoute<'AvatarSelection'>,
 };
 function AvatarSelection(props: Props): React.Node {
   const { userSelections } = props.route.params;
   const { accountSelection } = userSelections;
   const usernameOrETHAddress =
     accountSelection.accountType === 'username'
       ? accountSelection.username
       : accountSelection.address;
 
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const { cachedSelections, setCachedSelections } = registrationContext;
 
   const editUserAvatarContext = React.useContext(EditUserAvatarContext);
   invariant(editUserAvatarContext, 'editUserAvatarContext should be set');
   const { setRegistrationMode } = editUserAvatarContext;
 
   const prefetchedAvatarURI =
     accountSelection.accountType === 'ethereum'
       ? accountSelection.avatarURI
       : undefined;
 
   let initialAvatarData = cachedSelections.avatarData;
   if (!initialAvatarData && prefetchedAvatarURI) {
     initialAvatarData = ensAvatarSelection;
   }
 
   const [avatarData, setAvatarData] =
     React.useState<?AvatarData>(initialAvatarData);
 
   const setClientAvatarFromSelection = React.useCallback(
     (selection: UserAvatarSelection) => {
       if (selection.needsUpload) {
         const newAvatarData = {
           ...selection,
           clientAvatar: {
             type: 'image',
             uri: selection.mediaSelection.uri,
           },
         };
         setAvatarData(newAvatarData);
         setCachedSelections(oldUserSelections => ({
           ...oldUserSelections,
           avatarData: newAvatarData,
         }));
       } else if (selection.updateUserAvatarRequest.type !== 'remove') {
         const clientRequest = selection.updateUserAvatarRequest;
         invariant(
           clientRequest.type !== 'image' &&
             clientRequest.type !== 'encrypted_image' &&
             clientRequest.type !== 'non_keyserver_image',
           'image avatars need to be uploaded',
         );
         const newAvatarData = {
           ...selection,
           clientAvatar: clientRequest,
         };
         setAvatarData(newAvatarData);
         setCachedSelections(oldUserSelections => ({
           ...oldUserSelections,
           avatarData: newAvatarData,
         }));
       } else {
         setAvatarData(undefined);
         setCachedSelections(oldUserSelections => ({
           ...oldUserSelections,
           avatarData: undefined,
         }));
       }
     },
     [setCachedSelections],
   );
 
   const currentRouteName = useCurrentLeafRouteName();
   const avatarSelectionHappening =
     currentRouteName === AvatarSelectionRouteName ||
     currentRouteName === EmojiAvatarSelectionRouteName ||
     currentRouteName === RegistrationUserAvatarCameraModalRouteName;
   React.useEffect(() => {
     if (!avatarSelectionHappening) {
       return undefined;
     }
     setRegistrationMode({
       registrationMode: 'on',
       successCallback: setClientAvatarFromSelection,
     });
     return () => {
       setRegistrationMode({ registrationMode: 'off' });
     };
   }, [
     avatarSelectionHappening,
     setRegistrationMode,
     setClientAvatarFromSelection,
   ]);
 
   const { navigate } = props.navigation;
   const onProceed = React.useCallback(async () => {
     const newUserSelections = {
       ...userSelections,
       avatarData,
     };
-    if (
-      userSelections.accountSelection.accountType === 'ethereum' &&
-      enableSIWEBackupCreation
-    ) {
+    if (userSelections.accountSelection.accountType === 'ethereum') {
       navigate<'CreateSIWEBackupMessage'>({
         name: CreateSIWEBackupMessageRouteName,
         params: { userSelections: newUserSelections },
       });
       return;
     }
     navigate<'RegistrationTerms'>({
       name: RegistrationTermsRouteName,
       params: { userSelections: newUserSelections },
     });
   }, [userSelections, avatarData, navigate]);
 
   const clientAvatar = avatarData?.clientAvatar;
   const userInfoOverride = React.useMemo(
     () => ({
       username: usernameOrETHAddress,
       avatar: clientAvatar,
     }),
     [usernameOrETHAddress, clientAvatar],
   );
 
   const styles = useStyles(unboundStyles);
   return (
     <RegistrationContainer>
       <RegistrationContentContainer style={styles.scrollViewContentContainer}>
         <Text style={styles.header}>Pick an avatar</Text>
         <View style={styles.stagedAvatarSection}>
           <View style={styles.editUserAvatar}>
             <EditUserAvatar
               userInfo={userInfoOverride}
               prefetchedAvatarURI={prefetchedAvatarURI}
             />
           </View>
         </View>
       </RegistrationContentContainer>
       <RegistrationButtonContainer>
         <PrimaryButton onPress={onProceed} label="Next" />
       </RegistrationButtonContainer>
     </RegistrationContainer>
   );
 }
 
 const unboundStyles = {
   scrollViewContentContainer: {
     paddingHorizontal: 0,
   },
   header: {
     fontSize: 24,
     color: 'panelForegroundLabel',
     paddingBottom: 16,
     paddingHorizontal: 16,
   },
   stagedAvatarSection: {
     marginTop: 16,
     backgroundColor: 'panelForeground',
     paddingVertical: 24,
     alignItems: 'center',
   },
   editUserAvatar: {
     alignItems: 'center',
     justifyContent: 'center',
   },
 };
 
 export default AvatarSelection;
diff --git a/native/account/registration/missing-registration-data/missing-registration-data-handler.react.js b/native/account/registration/missing-registration-data/missing-registration-data-handler.react.js
index af8aa711d..3fab0409a 100644
--- a/native/account/registration/missing-registration-data/missing-registration-data-handler.react.js
+++ b/native/account/registration/missing-registration-data/missing-registration-data-handler.react.js
@@ -1,82 +1,80 @@
 // @flow
 
 import { useNavigation } from '@react-navigation/native';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { recordAlertActionType } from 'lib/actions/alert-actions.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { accountHasPassword } from 'lib/shared/account-utils.js';
 import {
   alertTypes,
   type RecordAlertActionPayload,
 } from 'lib/types/alert-types.js';
 import { shouldSkipCreateSIWEBackupMessageAlert } from 'lib/utils/push-alerts.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import { commCoreModule } from '../../../native-modules.js';
 import { CreateMissingSIWEBackupMessageRouteName } from '../../../navigation/route-names.js';
 import { useSelector } from '../../../redux/redux-utils.js';
 import { RegistrationContext } from '../registration-context.js';
-import { enableSIWEBackupCreation } from '../registration-types.js';
 
 function MissingRegistrationDataHandler(): React.Node {
   const loggedIn = useSelector(isLoggedIn);
   const navigation = useNavigation();
   const currentUserInfo = useSelector(state => state.currentUserInfo);
 
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const { cachedSelections } = registrationContext;
 
   const createSIWEBAckupMessageAlertInfo = useSelector(
     state => state.alertStore.alertInfos[alertTypes.SIWE_BACKUP_MESSAGE],
   );
   const dispatch = useDispatch();
 
   React.useEffect(() => {
     if (
-      !enableSIWEBackupCreation ||
       !loggedIn ||
       accountHasPassword(currentUserInfo) ||
       cachedSelections.siweBackupSecrets ||
       shouldSkipCreateSIWEBackupMessageAlert(createSIWEBAckupMessageAlertInfo)
     ) {
       return;
     }
 
     void (async () => {
       const nativeSIWEBackupSecrets =
         await commCoreModule.getSIWEBackupSecrets();
 
       if (nativeSIWEBackupSecrets) {
         return;
       }
 
       navigation.navigate<'CreateMissingSIWEBackupMessage'>({
         name: CreateMissingSIWEBackupMessageRouteName,
       });
 
       const payload: RecordAlertActionPayload = {
         alertType: alertTypes.SIWE_BACKUP_MESSAGE,
         time: Date.now(),
       };
 
       dispatch({
         type: recordAlertActionType,
         payload,
       });
     })();
   }, [
     currentUserInfo,
     loggedIn,
     cachedSelections.siweBackupSecrets,
     navigation,
     createSIWEBAckupMessageAlertInfo,
     dispatch,
   ]);
 
   return null;
 }
 
 export { MissingRegistrationDataHandler };
diff --git a/native/account/registration/registration-types.js b/native/account/registration/registration-types.js
index e35f1c490..c5b55c02e 100644
--- a/native/account/registration/registration-types.js
+++ b/native/account/registration/registration-types.js
@@ -1,69 +1,67 @@
 // @flow
 
 import type {
   UpdateUserAvatarRequest,
   ClientAvatar,
 } from 'lib/types/avatar-types.js';
 import type { NativeMediaSelection } from 'lib/types/media-types.js';
 import type { SIWEResult, SIWEBackupSecrets } from 'lib/types/siwe-types.js';
 
 export type CoolOrNerdMode = 'cool' | 'nerd';
 
 export type EthereumAccountSelection = {
   +accountType: 'ethereum',
   ...SIWEResult,
   +avatarURI: ?string,
 };
 
 export type UsernameAccountSelection = {
   +accountType: 'username',
   +username: string,
   +password: string,
 };
 
 export type AccountSelection =
   | EthereumAccountSelection
   | UsernameAccountSelection;
 
 export type AvatarData =
   | {
       +needsUpload: true,
       +mediaSelection: NativeMediaSelection,
       +clientAvatar: ClientAvatar,
     }
   | {
       +needsUpload: false,
       +updateUserAvatarRequest: UpdateUserAvatarRequest,
       +clientAvatar: ClientAvatar,
     };
 
 export type RegistrationServerCallInput = {
   +coolOrNerdMode?: ?CoolOrNerdMode,
   +keyserverURL?: ?string,
   +farcasterID: ?string,
   +accountSelection: AccountSelection,
   +avatarData: ?AvatarData,
   +siweBackupSecrets?: ?SIWEBackupSecrets,
   +clearCachedSelections: () => void,
   +onNonceExpired: () => mixed,
   +onAlertAcknowledged?: () => mixed,
 };
 
 export type CachedUserSelections = {
   +coolOrNerdMode?: CoolOrNerdMode,
   +keyserverURL?: string,
   +username?: string,
   +password?: string,
   +avatarData?: ?AvatarData,
   +ethereumAccount?: ?EthereumAccountSelection,
   +farcasterID?: string,
   +siweBackupSecrets?: ?SIWEBackupSecrets,
 };
 
 export const ensAvatarSelection: AvatarData = {
   needsUpload: false,
   updateUserAvatarRequest: { type: 'ens' },
   clientAvatar: { type: 'ens' },
 };
-
-export const enableSIWEBackupCreation = __DEV__;