diff --git a/native/account/registration/avatar-selection.react.js b/native/account/registration/avatar-selection.react.js
index 6f9e98765..a1eb195ee 100644
--- a/native/account/registration/avatar-selection.react.js
+++ b/native/account/registration/avatar-selection.react.js
@@ -1,214 +1,215 @@
 // @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 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,
+    +farcasterAvatarURL: ?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') {
       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/connect-ethereum.react.js b/native/account/registration/connect-ethereum.react.js
index d05b28fb4..73bd9b078 100644
--- a/native/account/registration/connect-ethereum.react.js
+++ b/native/account/registration/connect-ethereum.react.js
@@ -1,345 +1,346 @@
 // @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 { useLegacyAshoatKeyserverCall } from 'lib/keyserver-conn/legacy-keyserver-call.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { type SIWEResult, SIWEMessageTypes } from 'lib/types/siwe-types.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 import { usingCommServicesAccessToken } from 'lib/utils/services-utils.js';
 
 import {
   useGetEthereumAccountFromSIWEResult,
   siweNonceExpired,
 } from './ethereum-utils.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 } from './registration-types.js';
 import PrimaryButton from '../../components/primary-button.react.js';
 import { commRustModule } from '../../native-modules.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 { defaultURLPrefix } from '../../utils/url-utils.js';
 import EthereumLogoDark from '../../vectors/ethereum-logo-dark.react.js';
 import { useSIWEPanelState } from '../siwe-hooks.js';
 import SIWEPanel from '../siwe-panel.react.js';
 
 const exactSearchUserLoadingStatusSelector = createLoadingStatusSelector(
   exactSearchUserActionTypes,
 );
 
 const siweSignatureRequestData = {
   messageType: SIWEMessageTypes.MSG_AUTH,
 };
 
 export type ConnectEthereumParams = {
   +userSelections: {
     +coolOrNerdMode?: ?CoolOrNerdMode,
     +keyserverURL?: ?string,
     +farcasterID: ?string,
+    +farcasterAvatarURL: ?string,
   },
 };
 
 type Props = {
   +navigation: RegistrationNavigationProp<'ConnectEthereum'>,
   +route: NavigationRoute<'ConnectEthereum'>,
 };
 function ConnectEthereum(props: Props): React.Node {
   const { params } = props.route;
 
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const { cachedSelections, setCachedSelections } = registrationContext;
 
   const userSelections = params?.userSelections;
   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 { navigate } = props.navigation;
   const onSkip = React.useCallback(() => {
     navigate<'UsernameSelection'>({
       name: UsernameSelectionRouteName,
       params: {
         userSelections,
       },
     });
   }, [navigate, userSelections]);
 
   const keyserverURL = userSelections?.keyserverURL ?? defaultURLPrefix;
   const serverCallParamOverride = React.useMemo(
     () => ({
       urlPrefix: keyserverURL,
     }),
     [keyserverURL],
   );
 
   const exactSearchUserCall = useLegacyAshoatKeyserverCall(
     exactSearchUser,
     serverCallParamOverride,
   );
   const dispatchActionPromise = useDispatchActionPromise();
 
   const getEthereumAccountFromSIWEResult =
     useGetEthereumAccountFromSIWEResult();
 
   const onSuccessfulWalletSignature = React.useCallback(
     async (result: SIWEResult) => {
       let userAlreadyExists;
       if (usingCommServicesAccessToken) {
         const findUserIDResponseString =
           await commRustModule.findUserIDForWalletAddress(result.address);
         const findUserIDResponse = JSON.parse(findUserIDResponseString);
         userAlreadyExists =
           !!findUserIDResponse.userID || findUserIDResponse.isReserved;
       } else {
         const searchPromise = exactSearchUserCall(result.address);
         void dispatchActionPromise(exactSearchUserActionTypes, searchPromise);
         const { userInfo } = await searchPromise;
         userAlreadyExists = !!userInfo;
       }
 
       if (userAlreadyExists) {
         navigate<'ExistingEthereumAccount'>({
           name: ExistingEthereumAccountRouteName,
           params: result,
         });
         return;
       }
 
       const ethereumAccount = await getEthereumAccountFromSIWEResult(result);
 
       const newUserSelections = {
         ...userSelections,
         accountSelection: ethereumAccount,
       };
       navigate<'AvatarSelection'>({
         name: AvatarSelectionRouteName,
         params: {
           userSelections: newUserSelections,
         },
       });
     },
     [
       userSelections,
       exactSearchUserCall,
       dispatchActionPromise,
       navigate,
       getEthereumAccountFromSIWEResult,
     ],
   );
 
   const {
     panelState,
     onPanelClosed,
     onPanelClosing,
     siwePanelSetLoading,
     openPanel,
   } = useSIWEPanelState();
 
   let siwePanel;
   if (panelState !== 'closed') {
     siwePanel = (
       <SIWEPanel
         onClosing={onPanelClosing}
         onClosed={onPanelClosed}
         closing={panelState === 'closing'}
         onSuccessfulWalletSignature={onSuccessfulWalletSignature}
         siweSignatureRequestData={siweSignatureRequestData}
         setLoading={siwePanelSetLoading}
         keyserverCallParamOverride={serverCallParamOverride}
       />
     );
   }
 
   const { ethereumAccount } = cachedSelections;
   invariant(
     !ethereumAccount || ethereumAccount.nonceTimestamp,
     'nonceTimestamp must be set after connecting to Ethereum account',
   );
   const nonceExpired =
     ethereumAccount &&
     ethereumAccount.nonceTimestamp &&
     siweNonceExpired(ethereumAccount.nonceTimestamp);
   const alreadyHasConnected = !!ethereumAccount && !nonceExpired;
   React.useEffect(() => {
     if (nonceExpired) {
       setCachedSelections(oldUserSelections => ({
         ...oldUserSelections,
         ethereumAccount: undefined,
       }));
     }
   }, [nonceExpired, setCachedSelections]);
 
   const exactSearchUserCallLoading = useSelector(
     state => exactSearchUserLoadingStatusSelector(state) === 'loading',
   );
   const defaultConnectButtonVariant = alreadyHasConnected
     ? 'outline'
     : 'enabled';
   const connectButtonVariant =
     exactSearchUserCallLoading || panelState === 'opening'
       ? 'loading'
       : defaultConnectButtonVariant;
   const connectButtonText = alreadyHasConnected
     ? 'Connect new Ethereum wallet'
     : 'Connect Ethereum wallet';
 
   const onUseAlreadyConnectedWallet = React.useCallback(() => {
     invariant(
       ethereumAccount,
       'ethereumAccount should be set in onUseAlreadyConnectedWallet',
     );
     const newUserSelections = {
       ...userSelections,
       accountSelection: ethereumAccount,
     };
     navigate<'AvatarSelection'>({
       name: AvatarSelectionRouteName,
       params: {
         userSelections: newUserSelections,
       },
     });
   }, [ethereumAccount, userSelections, navigate]);
 
   let alreadyConnectedButton;
   if (alreadyHasConnected) {
     alreadyConnectedButton = (
       <PrimaryButton
         onPress={onUseAlreadyConnectedWallet}
         label="Use connected Ethereum wallet"
         variant="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>
           {alreadyConnectedButton}
           <PrimaryButton
             onPress={openPanel}
             label={connectButtonText}
             variant={connectButtonVariant}
           />
           <PrimaryButton
             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/connect-farcaster.react.js b/native/account/registration/connect-farcaster.react.js
index 716c28a56..6caff3594 100644
--- a/native/account/registration/connect-farcaster.react.js
+++ b/native/account/registration/connect-farcaster.react.js
@@ -1,246 +1,261 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
+import { NeynarClientContext } from 'lib/components/neynar-client-provider.react.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import { useIsAppForegrounded } from 'lib/shared/lifecycle-utils.js';
 
 import { siweNonceExpired } from './ethereum-utils.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 } from './registration-types.js';
 import FarcasterPrompt from '../../components/farcaster-prompt.react.js';
 import FarcasterWebView from '../../components/farcaster-web-view.react.js';
 import type { FarcasterWebViewState } from '../../components/farcaster-web-view.react.js';
 import PrimaryButton from '../../components/primary-button.react.js';
 import {
   type NavigationRoute,
   ConnectEthereumRouteName,
   AvatarSelectionRouteName,
 } from '../../navigation/route-names.js';
 import {
   getFarcasterAccountAlreadyLinkedAlertDetails,
   type AlertDetails,
 } from '../../utils/alert-messages.js';
 import Alert from '../../utils/alert.js';
 
 export type ConnectFarcasterParams = ?{
   +userSelections?: {
     +coolOrNerdMode?: CoolOrNerdMode,
     +keyserverURL?: string,
   },
 };
 
 type Props = {
   +navigation: RegistrationNavigationProp<'ConnectFarcaster'>,
   +route: NavigationRoute<'ConnectFarcaster'>,
 };
 
 function ConnectFarcaster(prop: Props): React.Node {
   const { navigation, route } = prop;
 
   const { navigate } = navigation;
   const userSelections = route.params?.userSelections;
 
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const {
     cachedSelections,
     setCachedSelections,
     skipEthereumLoginOnce,
     setSkipEthereumLoginOnce,
   } = registrationContext;
 
   const [webViewState, setWebViewState] =
     React.useState<FarcasterWebViewState>('closed');
 
   const { ethereumAccount } = cachedSelections;
   const goToNextStep = React.useCallback(
-    (fid?: ?string) => {
+    (fid?: ?string, farcasterAvatarURL: ?string) => {
       setWebViewState('closed');
       invariant(
         !ethereumAccount || ethereumAccount.nonceTimestamp,
         'nonceTimestamp must be set after connecting to Ethereum account',
       );
       const nonceExpired =
         ethereumAccount &&
         ethereumAccount.nonceTimestamp &&
         siweNonceExpired(ethereumAccount.nonceTimestamp);
       if (nonceExpired) {
         setCachedSelections(oldUserSelections => ({
           ...oldUserSelections,
           ethereumAccount: undefined,
         }));
       }
 
       if (!skipEthereumLoginOnce || !ethereumAccount || nonceExpired) {
         navigate<'ConnectEthereum'>({
           name: ConnectEthereumRouteName,
           params: {
             userSelections: {
               ...userSelections,
               farcasterID: fid,
+              farcasterAvatarURL: farcasterAvatarURL,
             },
           },
         });
         return;
       }
 
       const newUserSelections = {
         ...userSelections,
         farcasterID: fid,
         accountSelection: ethereumAccount,
+        farcasterAvatarURL: farcasterAvatarURL,
       };
       setSkipEthereumLoginOnce(false);
       navigate<'AvatarSelection'>({
         name: AvatarSelectionRouteName,
         params: { userSelections: newUserSelections },
       });
     },
     [
       navigate,
       skipEthereumLoginOnce,
       setSkipEthereumLoginOnce,
       ethereumAccount,
       userSelections,
       setCachedSelections,
     ],
   );
 
   const onSkip = React.useCallback(() => goToNextStep(), [goToNextStep]);
 
   const identityServiceClient = React.useContext(IdentityClientContext);
   const getFarcasterUsers =
     identityServiceClient?.identityClient.getFarcasterUsers;
   invariant(getFarcasterUsers, 'Could not get getFarcasterUsers');
 
+  const neynarClient = React.useContext(NeynarClientContext);
+  const getFCAvatarURLs = neynarClient?.getFCAvatarURLs;
+  invariant(getFCAvatarURLs, 'Could not get getFCAvatarURLs');
+
   const [queuedAlert, setQueuedAlert] = React.useState<?AlertDetails>();
 
   const onSuccess = React.useCallback(
     async (fid: string) => {
       try {
-        const commFCUsers = await getFarcasterUsers([fid]);
+        const [commFCUsers, farcasterAvatarURLs] = await Promise.all([
+          getFarcasterUsers([fid]),
+          getFCAvatarURLs([fid]),
+        ]);
         if (commFCUsers.length > 0 && commFCUsers[0].farcasterID === fid) {
           const commUsername = commFCUsers[0].username;
 
           const alert =
             getFarcasterAccountAlreadyLinkedAlertDetails(commUsername);
 
           setQueuedAlert(alert);
           setWebViewState('closed');
         } else {
-          goToNextStep(fid);
+          const farcasterAvatarURL =
+            farcasterAvatarURLs.length > 0 && farcasterAvatarURLs[0].pfpURL
+              ? farcasterAvatarURLs[0].pfpURL
+              : null;
+          goToNextStep(fid, farcasterAvatarURL);
           setCachedSelections(oldUserSelections => ({
             ...oldUserSelections,
             farcasterID: fid,
+            farcasterAvatarURL: farcasterAvatarURL ?? null,
           }));
         }
       } catch (e) {
         setQueuedAlert({
           title: 'Failed to query Comm',
           message:
             'We failed to query Comm to see if that Farcaster account is ' +
             'already linked',
         });
         setWebViewState('closed');
       }
     },
-    [goToNextStep, setCachedSelections, getFarcasterUsers],
+    [getFarcasterUsers, getFCAvatarURLs, goToNextStep, setCachedSelections],
   );
 
   const isAppForegrounded = useIsAppForegrounded();
   React.useEffect(() => {
     if (!queuedAlert || !isAppForegrounded) {
       return;
     }
     Alert.alert(queuedAlert.title, queuedAlert.message);
     setQueuedAlert(null);
   }, [queuedAlert, isAppForegrounded]);
 
-  const { farcasterID } = cachedSelections;
+  const { farcasterID, farcasterAvatarURL } = cachedSelections;
   const alreadyHasConnected = !!farcasterID;
 
   const onPressConnectFarcaster = React.useCallback(() => {
     setWebViewState('opening');
   }, []);
 
   const defaultConnectButtonVariant = alreadyHasConnected
     ? 'outline'
     : 'enabled';
 
   const connectButtonVariant =
     webViewState === 'opening' ? 'loading' : defaultConnectButtonVariant;
 
   const connectButtonText = alreadyHasConnected
     ? 'Connect new Farcaster account'
     : 'Connect Farcaster account';
 
   const onUseAlreadyConnectedAccount = React.useCallback(() => {
     invariant(
       farcasterID,
       'farcasterID should be set in onUseAlreadyConnectedAccount',
     );
-    goToNextStep(farcasterID);
-  }, [farcasterID, goToNextStep]);
+    goToNextStep(farcasterID, farcasterAvatarURL);
+  }, [farcasterAvatarURL, farcasterID, goToNextStep]);
 
   const alreadyConnectedButton = React.useMemo(() => {
     if (!alreadyHasConnected) {
       return null;
     }
 
     return (
       <PrimaryButton
         onPress={onUseAlreadyConnectedAccount}
         label="Use connected Farcaster account"
         variant="enabled"
       />
     );
   }, [alreadyHasConnected, onUseAlreadyConnectedAccount]);
 
   const connectFarcaster = React.useMemo(
     () => (
       <RegistrationContainer>
         <RegistrationContentContainer style={styles.scrollViewContentContainer}>
           <FarcasterPrompt textType="connect" />
         </RegistrationContentContainer>
         <FarcasterWebView onSuccess={onSuccess} webViewState={webViewState} />
         <RegistrationButtonContainer>
           {alreadyConnectedButton}
           <PrimaryButton
             onPress={onPressConnectFarcaster}
             label={connectButtonText}
             variant={connectButtonVariant}
           />
           <PrimaryButton
             onPress={onSkip}
             label="Do not connect"
             variant="outline"
           />
         </RegistrationButtonContainer>
       </RegistrationContainer>
     ),
     [
       alreadyConnectedButton,
       connectButtonText,
       connectButtonVariant,
       onPressConnectFarcaster,
       onSuccess,
       webViewState,
       onSkip,
     ],
   );
 
   return connectFarcaster;
 }
 
 const styles = {
   scrollViewContentContainer: {
     flexGrow: 1,
   },
 };
 
 export default ConnectFarcaster;
diff --git a/native/account/registration/password-selection.react.js b/native/account/registration/password-selection.react.js
index 4ceff3f9a..c0e7a6bde 100644
--- a/native/account/registration/password-selection.react.js
+++ b/native/account/registration/password-selection.react.js
@@ -1,251 +1,252 @@
 // @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 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 PrimaryButton from '../../components/primary-button.react.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,
     +farcasterID: ?string,
     +username: string,
+    farcasterAvatarURL: ?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 { username, ...rest } = userSelections;
     const newUserSelections = {
       ...rest,
       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(() => {
       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"
           autoCapitalize="none"
           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"
           autoCapitalize="none"
           returnKeyType="go"
           onSubmitEditing={onProceed}
           onBlur={checkPasswordValidity}
           style={styles.confirmPassword}
           ref={confirmPasswordInputRef}
         />
         <View style={styles.error}>{errorText}</View>
       </RegistrationContentContainer>
       <RegistrationButtonContainer>
         <PrimaryButton
           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-terms.react.js b/native/account/registration/registration-terms.react.js
index 0559be041..18ff47c12 100644
--- a/native/account/registration/registration-terms.react.js
+++ b/native/account/registration/registration-terms.react.js
@@ -1,193 +1,202 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, View, Image, Linking } from 'react-native';
 
 import type { SIWEBackupSecrets } from 'lib/types/siwe-types.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,
   AccountSelection,
   AvatarData,
 } from './registration-types.js';
 import PrimaryButton from '../../components/primary-button.react.js';
 import commSwooshSource from '../../img/comm-swoosh.png';
 import { logInActionType } from '../../navigation/action-types.js';
 import type { NavigationRoute } from '../../navigation/route-names.js';
 import { useStyles } from '../../themes/colors.js';
 import Alert from '../../utils/alert.js';
 
 export type RegistrationTermsParams = {
   +userSelections: {
     +coolOrNerdMode?: ?CoolOrNerdMode,
     +keyserverURL?: ?string,
     +farcasterID: ?string,
     +accountSelection: AccountSelection,
     +avatarData: ?AvatarData,
     +siweBackupSecrets?: ?SIWEBackupSecrets,
+    +farcasterAvatarURL: ?string,
   },
 };
 
 const onTermsOfUsePressed = () => {
   void Linking.openURL('https://comm.app/terms');
 };
 
 const onPrivacyPolicyPressed = () => {
   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, setCachedSelections } = registrationContext;
 
   const [registrationInProgress, setRegistrationInProgress] =
     React.useState(false);
 
   const { userSelections } = props.route.params;
 
   const clearCachedSelections = React.useCallback(() => {
     setCachedSelections({});
   }, [setCachedSelections]);
 
   const { navigation } = props;
   const { reconnectEthereum } = navigation;
-  const { coolOrNerdMode, keyserverURL, farcasterID } = userSelections;
+  const { coolOrNerdMode, keyserverURL, farcasterID, farcasterAvatarURL } =
+    userSelections;
   const navigateToConnectEthereum = React.useCallback(() => {
     reconnectEthereum({
       userSelections: {
         coolOrNerdMode,
         keyserverURL,
         farcasterID,
+        farcasterAvatarURL,
       },
     });
-  }, [reconnectEthereum, coolOrNerdMode, keyserverURL, farcasterID]);
+  }, [
+    reconnectEthereum,
+    coolOrNerdMode,
+    keyserverURL,
+    farcasterID,
+    farcasterAvatarURL,
+  ]);
   const onNonceExpired = React.useCallback(() => {
     setCachedSelections(oldUserSelections => ({
       ...oldUserSelections,
       ethereumAccount: undefined,
     }));
     Alert.alert(
       'Registration attempt timed out',
       'Please try to connect your Ethereum wallet again',
       [{ text: 'OK', onPress: navigateToConnectEthereum }],
       {
         cancelable: false,
       },
     );
   }, [setCachedSelections, navigateToConnectEthereum]);
 
   const onProceed = React.useCallback(async () => {
     setRegistrationInProgress(true);
     try {
       await register({
         ...userSelections,
         clearCachedSelections,
         onNonceExpired,
       });
     } finally {
       setRegistrationInProgress(false);
     }
   }, [register, userSelections, clearCachedSelections, onNonceExpired]);
 
   React.useEffect(() => {
     if (!registrationInProgress) {
       return undefined;
     }
     navigation.setOptions({
       gestureEnabled: false,
       headerLeft: null,
     });
     const removeListener = navigation.addListener('beforeRemove', e => {
       if (e.data.action.type !== logInActionType) {
         e.preventDefault();
       }
     });
     return () => {
       navigation.setOptions({
         gestureEnabled: true,
         headerLeft: undefined,
       });
       removeListener();
     };
   }, [navigation, registrationInProgress]);
 
   const styles = useStyles(unboundStyles);
 
   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>
   );
 
   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>
         <PrimaryButton
           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: 'contain',
     width: '100%',
     height: '100%',
   },
   hyperlinkText: {
     color: 'purpleLink',
   },
 };
 
 export default RegistrationTerms;
diff --git a/native/account/registration/registration-types.js b/native/account/registration/registration-types.js
index c5b55c02e..cfff962a8 100644
--- a/native/account/registration/registration-types.js
+++ b/native/account/registration/registration-types.js
@@ -1,67 +1,69 @@
 // @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,
+  +farcasterAvatarURL: ?string,
   +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,
+  +farcasterAvatarURL?: ?string,
 };
 
 export const ensAvatarSelection: AvatarData = {
   needsUpload: false,
   updateUserAvatarRequest: { type: 'ens' },
   clientAvatar: { type: 'ens' },
 };
diff --git a/native/account/registration/siwe-backup-message-creation.react.js b/native/account/registration/siwe-backup-message-creation.react.js
index 918975c6f..24a58ebe7 100644
--- a/native/account/registration/siwe-backup-message-creation.react.js
+++ b/native/account/registration/siwe-backup-message-creation.react.js
@@ -1,326 +1,327 @@
 // @flow
 
 import Icon from '@expo/vector-icons/MaterialIcons.js';
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text } from 'react-native';
 
 import { type SIWEResult, SIWEMessageTypes } from 'lib/types/siwe-types.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,
   AccountSelection,
   AvatarData,
 } from './registration-types.js';
 import PrimaryButton from '../../components/primary-button.react.js';
 import {
   type NavigationRoute,
   RegistrationTermsRouteName,
 } from '../../navigation/route-names.js';
 import { useStyles } from '../../themes/colors.js';
 import Alert from '../../utils/alert.js';
 import { useSIWEPanelState } from '../siwe-hooks.js';
 import SIWEPanel from '../siwe-panel.react.js';
 
 const siweBackupSignatureRequestData = {
   messageType: SIWEMessageTypes.MSG_BACKUP,
 };
 
 type CreateSIWEBackupMessageBaseProps = {
   +onSuccessfulWalletSignature: (result: SIWEResult) => void,
   +onExistingWalletSignature?: () => void,
   +onSkip?: () => void,
 };
 
 const CreateSIWEBackupMessageBase: React.ComponentType<CreateSIWEBackupMessageBaseProps> =
   React.memo<CreateSIWEBackupMessageBaseProps>(
     function CreateSIWEBackupMessageBase(
       props: CreateSIWEBackupMessageBaseProps,
     ): React.Node {
       const styles = useStyles(unboundStyles);
       const { onSuccessfulWalletSignature, onExistingWalletSignature, onSkip } =
         props;
 
       const {
         panelState,
         onPanelClosed,
         onPanelClosing,
         openPanel,
         siwePanelSetLoading,
       } = useSIWEPanelState();
 
       let siwePanel;
       if (panelState !== 'closed') {
         siwePanel = (
           <SIWEPanel
             onClosing={onPanelClosing}
             onClosed={onPanelClosed}
             closing={panelState === 'closing'}
             onSuccessfulWalletSignature={onSuccessfulWalletSignature}
             siweSignatureRequestData={siweBackupSignatureRequestData}
             setLoading={siwePanelSetLoading}
           />
         );
       }
 
       const newSignatureButtonText = onExistingWalletSignature
         ? 'Encrypt with new signature'
         : 'Encrypt with Ethereum signature';
       const newSignatureButtonVariant = onExistingWalletSignature
         ? 'outline'
         : 'enabled';
 
       let useExistingSignatureButton;
       if (onExistingWalletSignature) {
         useExistingSignatureButton = (
           <PrimaryButton
             onPress={onExistingWalletSignature}
             label="Encrypt with existing signature"
             variant="enabled"
           />
         );
       }
 
       let onSkipButton;
       if (onSkip) {
         onSkipButton = (
           <PrimaryButton onPress={onSkip} label="Skip" variant="outline" />
         );
       }
 
       return (
         <>
           <RegistrationContainer>
             <RegistrationContentContainer
               style={styles.scrollViewContentContainer}
             >
               <Text style={styles.header}>Encrypting your Comm backup</Text>
               <Text style={styles.body}>
                 To make sure we can’t see your data, Comm encrypts your backup
                 using a signature from your wallet.
               </Text>
               <Text style={styles.body}>
                 This signature is private and never leaves your device, unlike
                 the prior signature, which is public.
               </Text>
               <Text style={styles.body}>
                 This signature ensures that you can always recover your data as
                 long as you still control your wallet.
               </Text>
               <View style={styles.siweBackupIconContainer}>
                 <Icon name="backup" size={200} style={styles.siweBackupIcon} />
               </View>
             </RegistrationContentContainer>
             <RegistrationButtonContainer>
               {useExistingSignatureButton}
               <PrimaryButton
                 onPress={openPanel}
                 label={newSignatureButtonText}
                 variant={newSignatureButtonVariant}
               />
               {onSkipButton}
             </RegistrationButtonContainer>
           </RegistrationContainer>
           {siwePanel}
         </>
       );
     },
   );
 
 export type CreateSIWEBackupMessageParams = {
   +userSelections: {
     +coolOrNerdMode?: ?CoolOrNerdMode,
     +keyserverURL?: ?string,
     +farcasterID: ?string,
     +accountSelection: AccountSelection,
     +avatarData: ?AvatarData,
+    +farcasterAvatarURL: ?string,
   },
 };
 
 type Props = {
   +navigation: RegistrationNavigationProp<'CreateSIWEBackupMessage'>,
   +route: NavigationRoute<'CreateSIWEBackupMessage'>,
 };
 function CreateSIWEBackupMessage(props: Props): React.Node {
   const { navigate } = props.navigation;
   const { params } = props.route;
   const { userSelections } = params;
 
   const registrationContext = React.useContext(RegistrationContext);
   invariant(registrationContext, 'registrationContext should be set');
   const { cachedSelections, setCachedSelections } = registrationContext;
 
   const onSuccessfulWalletSignature = React.useCallback(
     (result: SIWEResult) => {
       const selectedEthereumAddress = userSelections.accountSelection.address;
       const { message, signature, address } = result;
 
       if (address !== selectedEthereumAddress) {
         Alert.alert(
           'Mismatched Ethereum address',
           'You picked a different wallet than the one you use to sign in.',
         );
         return;
       }
 
       const newUserSelections = {
         ...userSelections,
         siweBackupSecrets: { message, signature },
       };
       setCachedSelections(oldUserSelections => ({
         ...oldUserSelections,
         siweBackupSecrets: { message, signature },
       }));
       navigate<'RegistrationTerms'>({
         name: RegistrationTermsRouteName,
         params: { userSelections: newUserSelections },
       });
     },
     [navigate, setCachedSelections, userSelections],
   );
 
   const { siweBackupSecrets } = cachedSelections;
   const onExistingWalletSignature = React.useCallback(() => {
     const registrationTermsParams = {
       userSelections: {
         ...userSelections,
         siweBackupSecrets,
       },
     };
 
     navigate<'RegistrationTerms'>({
       name: RegistrationTermsRouteName,
       params: registrationTermsParams,
     });
   }, [navigate, siweBackupSecrets, userSelections]);
 
   if (siweBackupSecrets) {
     return (
       <CreateSIWEBackupMessageBase
         onSuccessfulWalletSignature={onSuccessfulWalletSignature}
         onExistingWalletSignature={onExistingWalletSignature}
       />
     );
   }
 
   return (
     <CreateSIWEBackupMessageBase
       onSuccessfulWalletSignature={onSuccessfulWalletSignature}
     />
   );
 }
 
 type SignSIWEBackupMessageForRestoreBaseProps = {
   +siweNonce: string,
   +siweIssuedAt: string,
   +siweStatement: string,
   +onSuccessfulWalletSignature: (result: SIWEResult) => void,
   +onSkip: () => void,
 };
 
 function SignSIWEBackupMessageForRestore(
   props: SignSIWEBackupMessageForRestoreBaseProps,
 ): React.Node {
   const styles = useStyles(unboundStyles);
   const {
     panelState,
     openPanel,
     onPanelClosed,
     onPanelClosing,
     siwePanelSetLoading,
   } = useSIWEPanelState();
 
   const {
     siweIssuedAt,
     siweNonce,
     siweStatement,
     onSuccessfulWalletSignature,
     onSkip,
   } = props;
   const siweSignatureRequestData = React.useMemo(
     () => ({
       messageType: SIWEMessageTypes.MSG_BACKUP_RESTORE,
       siweNonce,
       siweStatement,
       siweIssuedAt,
     }),
     [siweStatement, siweIssuedAt, siweNonce],
   );
 
   let siwePanel;
   if (panelState !== 'closed') {
     siwePanel = (
       <SIWEPanel
         onClosing={onPanelClosing}
         onClosed={onPanelClosed}
         closing={panelState === 'closing'}
         onSuccessfulWalletSignature={onSuccessfulWalletSignature}
         siweSignatureRequestData={siweSignatureRequestData}
         setLoading={siwePanelSetLoading}
       />
     );
   }
 
   return (
     <>
       <RegistrationContainer>
         <RegistrationContentContainer style={styles.scrollViewContentContainer}>
           <Text style={styles.header}>Decrypting your Comm backup</Text>
           <Text style={styles.body}>
             To make sure we can’t see your data, Comm encrypts your backup using
             a signature from your wallet.
           </Text>
           <View style={styles.siweBackupIconContainer}>
             <Icon name="backup" size={200} style={styles.siweBackupIcon} />
           </View>
         </RegistrationContentContainer>
         <RegistrationButtonContainer>
           <PrimaryButton
             onPress={openPanel}
             label="Decrypt with Ethereum signature"
             variant="enabled"
           />
           <PrimaryButton onPress={onSkip} label="Skip" 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,
   },
   siweBackupIcon: {
     color: 'panelForegroundIcon',
   },
   siweBackupIconContainer: {
     flexGrow: 1,
     alignItems: 'center',
     justifyContent: 'center',
   },
 };
 
 export {
   CreateSIWEBackupMessageBase,
   CreateSIWEBackupMessage,
   SignSIWEBackupMessageForRestore,
 };
diff --git a/native/account/registration/username-selection.react.js b/native/account/registration/username-selection.react.js
index 7840937c9..2b4f426b7 100644
--- a/native/account/registration/username-selection.react.js
+++ b/native/account/registration/username-selection.react.js
@@ -1,240 +1,241 @@
 // @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 { useLegacyAshoatKeyserverCall } from 'lib/keyserver-conn/legacy-keyserver-call.js';
 import { validUsernameRegex } from 'lib/shared/account-utils.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 import { usingCommServicesAccessToken } from 'lib/utils/services-utils.js';
 import { isValidEthereumAddress } from 'lib/utils/siwe-utils.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 RegistrationTextInput from './registration-text-input.react.js';
 import type { CoolOrNerdMode } from './registration-types.js';
 import PrimaryButton from '../../components/primary-button.react.js';
 import { commRustModule } from '../../native-modules.js';
 import {
   type NavigationRoute,
   PasswordSelectionRouteName,
 } from '../../navigation/route-names.js';
 import { useStyles } from '../../themes/colors.js';
 
 export type UsernameSelectionParams = {
   +userSelections: {
     +coolOrNerdMode?: ?CoolOrNerdMode,
     +keyserverURL?: ?string,
     +farcasterID: ?string,
+    +farcasterAvatarURL: ?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 &&
     !isValidEthereumAddress(username.toLowerCase());
 
   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(() => {
     if (keyserverURL) {
       return { urlPrefix: keyserverURL };
     }
     return undefined;
   }, [keyserverURL]);
 
   const [usernameSearchLoading, setUsernameSearchLoading] =
     React.useState(false);
 
   const exactSearchUserCall = useLegacyAshoatKeyserverCall(
     exactSearchUser,
     serverCallParamOverride,
   );
   const dispatchActionPromise = useDispatchActionPromise();
   const { navigate } = props.navigation;
   const onProceed = React.useCallback(async () => {
     if (!checkUsernameValidity()) {
       return;
     }
 
     setUsernameSearchLoading(true);
 
     let userAlreadyExists;
     try {
       if (usingCommServicesAccessToken) {
         const findUserIDResponseString =
           await commRustModule.findUserIDForUsername(username);
         const findUserIDResponse = JSON.parse(findUserIDResponseString);
         userAlreadyExists =
           !!findUserIDResponse.userID || findUserIDResponse.isReserved;
       } else {
         const searchPromise = exactSearchUserCall(username);
         void dispatchActionPromise(exactSearchUserActionTypes, searchPromise);
         const { userInfo } = await searchPromise;
         userAlreadyExists = !!userInfo;
       }
     } finally {
       setUsernameSearchLoading(false);
     }
 
     if (userAlreadyExists) {
       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,
   ]);
 
   let buttonVariant = 'disabled';
   if (usernameSearchLoading) {
     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={!usernameSearchLoading}
           onBlur={checkUsernameValidity}
         />
         <View style={styles.error}>{errorText}</View>
       </RegistrationContentContainer>
       <RegistrationButtonContainer>
         <PrimaryButton
           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;