diff --git a/lib/actions/user-actions.js b/lib/actions/user-actions.js
index 929a5d3f2..695627654 100644
--- a/lib/actions/user-actions.js
+++ b/lib/actions/user-actions.js
@@ -1,860 +1,860 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import {
   extractKeyserverIDFromID,
   sortThreadIDsPerKeyserver,
   sortCalendarQueryPerKeyserver,
 } from '../keyserver-conn/keyserver-call-utils.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import { preRequestUserStateSelector } from '../selectors/account-selectors.js';
 import { getOneTimeKeyValuesFromBlob } from '../shared/crypto-utils.js';
 import { IdentityClientContext } from '../shared/identity-client-context.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type {
   LogInInfo,
   LogInResult,
   RegisterResult,
   RegisterInfo,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
   ClaimUsernameResponse,
   LogInRequest,
   KeyserverAuthResult,
   KeyserverAuthInfo,
   KeyserverAuthRequest,
   ClientLogInResponse,
   KeyserverLogOutResult,
   LogOutResult,
 } from '../types/account-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from '../types/avatar-types.js';
 import type { RawEntryInfo, CalendarQuery } from '../types/entry-types.js';
 import type { IdentityAuthResult } from '../types/identity-service-types.js';
 import type {
   RawMessageInfo,
   MessageTruncationStatuses,
 } from '../types/message-types.js';
 import type {
   GetSessionPublicKeysArgs,
   GetOlmSessionInitializationDataResponse,
 } from '../types/request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from '../types/search-types.js';
 import type {
   SessionPublicKeys,
   PreRequestUserState,
 } from '../types/session-types.js';
 import type {
   SubscriptionUpdateRequest,
   SubscriptionUpdateResult,
 } from '../types/subscription-types.js';
 import type { RawThreadInfos } from '../types/thread-types';
 import type {
   CurrentUserInfo,
   UserInfo,
   PasswordUpdate,
   LoggedOutUserInfo,
 } from '../types/user-types.js';
 import type {
   CallSingleKeyserverEndpoint,
   CallSingleKeyserverEndpointOptions,
 } from '../utils/call-single-keyserver-endpoint.js';
 import { getConfig } from '../utils/config.js';
 import { useKeyserverCall } from '../utils/keyserver-call.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { usingCommServicesAccessToken } from '../utils/services-utils.js';
 import sleep from '../utils/sleep.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 const loggedOutUserInfo: LoggedOutUserInfo = {
   anonymous: true,
 };
 
 export type KeyserverLogOutInput = {
   +preRequestUserState: PreRequestUserState,
   +keyserverIDs?: $ReadOnlyArray<string>,
 };
 
 const logOutActionTypes = Object.freeze({
   started: 'LOG_OUT_STARTED',
   success: 'LOG_OUT_SUCCESS',
   failed: 'LOG_OUT_FAILED',
 });
 const logOut =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: KeyserverLogOutInput) => Promise<KeyserverLogOutResult>) =>
   async input => {
     const { preRequestUserState } = input;
     const keyserverIDs = input.keyserverIDs ?? allKeyserverIDs;
     const requests: { [string]: {} } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {};
     }
 
     let response = null;
     try {
       response = await Promise.race([
         callKeyserverEndpoint('log_out', requests),
         (async () => {
           await sleep(500);
           throw new Error('log_out took more than 500ms');
         })(),
       ]);
     } catch {}
     const currentUserInfo = response ? loggedOutUserInfo : null;
     return { currentUserInfo, preRequestUserState, keyserverIDs };
   };
 
 function useLogOut(): (
   keyserverIDs?: $ReadOnlyArray<string>,
 ) => Promise<LogOutResult> {
   const preRequestUserState = useSelector(preRequestUserStateSelector);
   const callKeyserverLogOut = useKeyserverCall(logOut);
 
   const commServicesAccessToken = useSelector(
     state => state.commServicesAccessToken,
   );
 
   return React.useCallback(
     async (keyserverIDs?: $ReadOnlyArray<string>) => {
       const { keyserverIDs: _, ...result } = await callKeyserverLogOut({
         preRequestUserState,
         keyserverIDs,
       });
       return {
         ...result,
         preRequestUserState: {
           ...result.preRequestUserState,
           commServicesAccessToken,
         },
       };
     },
     [callKeyserverLogOut, commServicesAccessToken, preRequestUserState],
   );
 }
 
 const claimUsernameActionTypes = Object.freeze({
   started: 'CLAIM_USERNAME_STARTED',
   success: 'CLAIM_USERNAME_SUCCESS',
   failed: 'CLAIM_USERNAME_FAILED',
 });
 const claimUsernameCallSingleKeyserverEndpointOptions = { timeout: 500 };
 const claimUsername =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): (() => Promise<ClaimUsernameResponse>) =>
   async () => {
     const requests = { [ashoatKeyserverID]: {} };
     const responses = await callKeyserverEndpoint('claim_username', requests, {
       ...claimUsernameCallSingleKeyserverEndpointOptions,
     });
     const response = responses[ashoatKeyserverID];
     return {
       message: response.message,
       signature: response.signature,
     };
   };
 
 function useClaimUsername(): () => Promise<ClaimUsernameResponse> {
   return useKeyserverCall(claimUsername);
 }
 
 const deleteKeyserverAccountActionTypes = Object.freeze({
   started: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
   success: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
   failed: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
 });
 const deleteKeyserverAccount =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: KeyserverLogOutInput) => Promise<KeyserverLogOutResult>) =>
   async input => {
     const { preRequestUserState } = input;
     const keyserverIDs = input.keyserverIDs ?? allKeyserverIDs;
     const requests: { [string]: {} } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {};
     }
 
     await callKeyserverEndpoint('delete_account', requests);
     return {
       currentUserInfo: loggedOutUserInfo,
       preRequestUserState,
       keyserverIDs,
     };
   };
 
 function useDeleteKeyserverAccount(): (
   keyserverIDs?: $ReadOnlyArray<string>,
 ) => Promise<KeyserverLogOutResult> {
   const preRequestUserState = useSelector(preRequestUserStateSelector);
   const callKeyserverDeleteAccount = useKeyserverCall(deleteKeyserverAccount);
 
   return React.useCallback(
     (keyserverIDs?: $ReadOnlyArray<string>) =>
       callKeyserverDeleteAccount({ preRequestUserState, keyserverIDs }),
     [callKeyserverDeleteAccount, preRequestUserState],
   );
 }
 
 const deleteAccountActionTypes = Object.freeze({
   started: 'DELETE_ACCOUNT_STARTED',
   success: 'DELETE_ACCOUNT_SUCCESS',
   failed: 'DELETE_ACCOUNT_FAILED',
 });
 
 function useDeleteAccount(): () => Promise<LogOutResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
 
   const preRequestUserState = useSelector(preRequestUserStateSelector);
   const callKeyserverDeleteAccount = useKeyserverCall(deleteKeyserverAccount);
 
   const commServicesAccessToken = useSelector(
     state => state.commServicesAccessToken,
   );
 
   return React.useCallback(async () => {
     const identityPromise = (async () => {
       if (!usingCommServicesAccessToken) {
         return undefined;
       }
       if (!identityClient) {
         throw new Error('Identity service client is not initialized');
       }
       return await identityClient.deleteUser();
     })();
     const [keyserverResult] = await Promise.all([
       callKeyserverDeleteAccount({
         preRequestUserState,
       }),
       identityPromise,
     ]);
     const { keyserverIDs: _, ...result } = keyserverResult;
     return {
       ...result,
       preRequestUserState: {
         ...result.preRequestUserState,
         commServicesAccessToken,
       },
     };
   }, [
     callKeyserverDeleteAccount,
     commServicesAccessToken,
     identityClient,
     preRequestUserState,
   ]);
 }
 
 const keyserverRegisterActionTypes = Object.freeze({
   started: 'KEYSERVER_REGISTER_STARTED',
   success: 'KEYSERVER_REGISTER_SUCCESS',
   failed: 'KEYSERVER_REGISTER_FAILED',
 });
 const registerCallSingleKeyserverEndpointOptions = { timeout: 60000 };
 const keyserverRegister =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((
     registerInfo: RegisterInfo,
     options?: CallSingleKeyserverEndpointOptions,
   ) => Promise<RegisterResult>) =>
   async (registerInfo, options) => {
     const deviceTokenUpdateRequest =
       registerInfo.deviceTokenUpdateRequest[ashoatKeyserverID];
 
     const response = await callSingleKeyserverEndpoint(
       'create_account',
       {
         ...registerInfo,
         deviceTokenUpdateRequest,
         platformDetails: getConfig().platformDetails,
       },
       {
         ...registerCallSingleKeyserverEndpointOptions,
         ...options,
       },
     );
     return {
       currentUserInfo: response.currentUserInfo,
       rawMessageInfos: response.rawMessageInfos,
       threadInfos: response.cookieChange.threadInfos,
       userInfos: response.cookieChange.userInfos,
       calendarQuery: registerInfo.calendarQuery,
     };
   };
 
 export type KeyserverAuthInput = $ReadOnly<{
   ...KeyserverAuthInfo,
   +preRequestUserInfo: ?CurrentUserInfo,
 }>;
 
 const keyserverAuthActionTypes = Object.freeze({
   started: 'KEYSERVER_AUTH_STARTED',
   success: 'KEYSERVER_AUTH_SUCCESS',
   failed: 'KEYSERVER_AUTH_FAILED',
 });
 const keyserverAuthCallSingleKeyserverEndpointOptions = { timeout: 60000 };
 const keyserverAuth =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: KeyserverAuthInput) => Promise<KeyserverAuthResult>) =>
   async keyserverAuthInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
 
     const {
       logInActionSource,
       calendarQuery,
       keyserverData,
       deviceTokenUpdateInput,
       preRequestUserInfo,
       ...restLogInInfo
     } = keyserverAuthInfo;
 
     const keyserverIDs = Object.keys(keyserverData);
 
     const watchedIDsPerKeyserver = sortThreadIDsPerKeyserver(watchedIDs);
     const calendarQueryPerKeyserver = sortCalendarQueryPerKeyserver(
       calendarQuery,
       keyserverIDs,
     );
 
     const requests: { [string]: KeyserverAuthRequest } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {
         ...restLogInInfo,
         deviceTokenUpdateRequest: deviceTokenUpdateInput[keyserverID],
         watchedIDs: watchedIDsPerKeyserver[keyserverID] ?? [],
         calendarQuery: calendarQueryPerKeyserver[keyserverID],
         platformDetails: getConfig().platformDetails,
         initialContentEncryptedMessage:
           keyserverData[keyserverID].initialContentEncryptedMessage,
         initialNotificationsEncryptedMessage:
           keyserverData[keyserverID].initialNotificationsEncryptedMessage,
         source: logInActionSource,
       };
     }
 
     const responses: { +[string]: ClientLogInResponse } =
       await callKeyserverEndpoint(
         'keyserver_auth',
         requests,
         keyserverAuthCallSingleKeyserverEndpointOptions,
       );
 
     const userInfosArrays = [];
 
     let threadInfos: RawThreadInfos = {};
     const calendarResult: WritableCalendarResult = {
       calendarQuery: keyserverAuthInfo.calendarQuery,
       rawEntryInfos: [],
     };
     const messagesResult: WritableGenericMessagesResult = {
       messageInfos: [],
       truncationStatus: {},
       watchedIDsAtRequestTime: watchedIDs,
       currentAsOf: {},
     };
     let updatesCurrentAsOf: { +[string]: number } = {};
     for (const keyserverID in responses) {
       threadInfos = {
         ...responses[keyserverID].cookieChange.threadInfos,
         ...threadInfos,
       };
       if (responses[keyserverID].rawEntryInfos) {
         calendarResult.rawEntryInfos = calendarResult.rawEntryInfos.concat(
           responses[keyserverID].rawEntryInfos,
         );
       }
       messagesResult.messageInfos = messagesResult.messageInfos.concat(
         responses[keyserverID].rawMessageInfos,
       );
       messagesResult.truncationStatus = {
         ...messagesResult.truncationStatus,
         ...responses[keyserverID].truncationStatuses,
       };
       messagesResult.currentAsOf = {
         ...messagesResult.currentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       updatesCurrentAsOf = {
         ...updatesCurrentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       userInfosArrays.push(responses[keyserverID].userInfos);
       userInfosArrays.push(responses[keyserverID].cookieChange.userInfos);
     }
 
     const userInfos = mergeUserInfos(...userInfosArrays);
 
     return {
       threadInfos,
       currentUserInfo: responses[ashoatKeyserverID].currentUserInfo,
       calendarResult,
       messagesResult,
       userInfos,
       updatesCurrentAsOf,
       logInActionSource: keyserverAuthInfo.logInActionSource,
       notAcknowledgedPolicies:
         responses[ashoatKeyserverID].notAcknowledgedPolicies,
       preRequestUserInfo,
     };
   };
 
 function useKeyserverAuth(): (
   input: KeyserverAuthInfo,
 ) => Promise<KeyserverAuthResult> {
   const preRequestUserInfo = useSelector(state => state.currentUserInfo);
   const callKeyserverAuth = useKeyserverCall(keyserverAuth);
 
   return React.useCallback(
     (input: KeyserverAuthInfo) =>
       callKeyserverAuth({ preRequestUserInfo, ...input }),
     [callKeyserverAuth, preRequestUserInfo],
   );
 }
 
 const identityRegisterActionTypes = Object.freeze({
   started: 'IDENTITY_REGISTER_STARTED',
   success: 'IDENTITY_REGISTER_SUCCESS',
   failed: 'IDENTITY_REGISTER_FAILED',
 });
 function useIdentityRegister(): (
   username: string,
   password: string,
 ) => Promise<IdentityAuthResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   return React.useCallback(
     (username, password) => {
       if (!identityClient) {
         throw new Error('Identity service client is not initialized');
       }
-      if (!identityClient.registerUser) {
+      if (!identityClient.registerPasswordUser) {
         throw new Error('Register user method unimplemented');
       }
-      return identityClient.registerUser(username, password);
+      return identityClient.registerPasswordUser(username, password);
     },
     [identityClient],
   );
 }
 
 const identityGenerateNonceActionTypes = Object.freeze({
   started: 'IDENTITY_GENERATE_NONCE_STARTED',
   success: 'IDENTITY_GENERATE_NONCE_SUCCESS',
   failed: 'IDENTITY_GENERATE_NONCE_FAILED',
 });
 function useIdentityGenerateNonce(): () => Promise<string> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   invariant(identityClient, 'Identity client should be set');
   return identityClient.generateNonce;
 }
 
 function mergeUserInfos(
   ...userInfoArrays: Array<$ReadOnlyArray<UserInfo>>
 ): UserInfo[] {
   const merged: { [string]: UserInfo } = {};
   for (const userInfoArray of userInfoArrays) {
     for (const userInfo of userInfoArray) {
       merged[userInfo.id] = userInfo;
     }
   }
   const flattened = [];
   for (const id in merged) {
     flattened.push(merged[id]);
   }
   return flattened;
 }
 
 type WritableGenericMessagesResult = {
   messageInfos: RawMessageInfo[],
   truncationStatus: MessageTruncationStatuses,
   watchedIDsAtRequestTime: string[],
   currentAsOf: { [keyserverID: string]: number },
 };
 type WritableCalendarResult = {
   rawEntryInfos: RawEntryInfo[],
   calendarQuery: CalendarQuery,
 };
 
 const identityLogInActionTypes = Object.freeze({
   started: 'IDENTITY_LOG_IN_STARTED',
   success: 'IDENTITY_LOG_IN_SUCCESS',
   failed: 'IDENTITY_LOG_IN_FAILED',
 });
 function useIdentityPasswordLogIn(): (
   username: string,
   password: string,
 ) => Promise<IdentityAuthResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   return React.useCallback(
     (username, password) => {
       if (!identityClient) {
         throw new Error('Identity service client is not initialized');
       }
       return identityClient.logInPasswordUser(username, password);
     },
     [identityClient],
   );
 }
 function useIdentityWalletLogIn(): (
   walletAddress: string,
   siweMessage: string,
   siweSignature: string,
 ) => Promise<IdentityAuthResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   invariant(identityClient, 'Identity client should be set');
   return identityClient.logInWalletUser;
 }
 
 const logInActionTypes = Object.freeze({
   started: 'LOG_IN_STARTED',
   success: 'LOG_IN_SUCCESS',
   failed: 'LOG_IN_FAILED',
 });
 const logInCallSingleKeyserverEndpointOptions = { timeout: 60000 };
 const logIn =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: LogInInfo) => Promise<LogInResult>) =>
   async logInInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
     const {
       logInActionSource,
       calendarQuery,
       keyserverIDs: inputKeyserverIDs,
       ...restLogInInfo
     } = logInInfo;
 
     // Eventually the list of keyservers will be fetched from the
     // identity service
     const keyserverIDs = inputKeyserverIDs ?? [ashoatKeyserverID];
 
     const watchedIDsPerKeyserver = sortThreadIDsPerKeyserver(watchedIDs);
     const calendarQueryPerKeyserver = sortCalendarQueryPerKeyserver(
       calendarQuery,
       keyserverIDs,
     );
 
     const requests: { [string]: LogInRequest } = {};
     for (const keyserverID of keyserverIDs) {
       requests[keyserverID] = {
         ...restLogInInfo,
         deviceTokenUpdateRequest:
           logInInfo.deviceTokenUpdateRequest[keyserverID],
         source: logInActionSource,
         watchedIDs: watchedIDsPerKeyserver[keyserverID] ?? [],
         calendarQuery: calendarQueryPerKeyserver[keyserverID],
         platformDetails: getConfig().platformDetails,
       };
     }
 
     const responses: { +[string]: ClientLogInResponse } =
       await callKeyserverEndpoint(
         'log_in',
         requests,
         logInCallSingleKeyserverEndpointOptions,
       );
 
     const userInfosArrays = [];
 
     let threadInfos: RawThreadInfos = {};
     const calendarResult: WritableCalendarResult = {
       calendarQuery: logInInfo.calendarQuery,
       rawEntryInfos: [],
     };
     const messagesResult: WritableGenericMessagesResult = {
       messageInfos: [],
       truncationStatus: {},
       watchedIDsAtRequestTime: watchedIDs,
       currentAsOf: {},
     };
     let updatesCurrentAsOf: { +[string]: number } = {};
     for (const keyserverID in responses) {
       threadInfos = {
         ...responses[keyserverID].cookieChange.threadInfos,
         ...threadInfos,
       };
       if (responses[keyserverID].rawEntryInfos) {
         calendarResult.rawEntryInfos = calendarResult.rawEntryInfos.concat(
           responses[keyserverID].rawEntryInfos,
         );
       }
       messagesResult.messageInfos = messagesResult.messageInfos.concat(
         responses[keyserverID].rawMessageInfos,
       );
       messagesResult.truncationStatus = {
         ...messagesResult.truncationStatus,
         ...responses[keyserverID].truncationStatuses,
       };
       messagesResult.currentAsOf = {
         ...messagesResult.currentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       updatesCurrentAsOf = {
         ...updatesCurrentAsOf,
         [keyserverID]: responses[keyserverID].serverTime,
       };
       userInfosArrays.push(responses[keyserverID].userInfos);
       userInfosArrays.push(responses[keyserverID].cookieChange.userInfos);
     }
 
     const userInfos = mergeUserInfos(...userInfosArrays);
 
     return {
       threadInfos,
       currentUserInfo: responses[ashoatKeyserverID].currentUserInfo,
       calendarResult,
       messagesResult,
       userInfos,
       updatesCurrentAsOf,
       logInActionSource: logInInfo.logInActionSource,
       notAcknowledgedPolicies:
         responses[ashoatKeyserverID].notAcknowledgedPolicies,
     };
   };
 
 function useLogIn(): (input: LogInInfo) => Promise<LogInResult> {
   return useKeyserverCall(logIn);
 }
 
 const changeKeyserverUserPasswordActionTypes = Object.freeze({
   started: 'CHANGE_KEYSERVER_USER_PASSWORD_STARTED',
   success: 'CHANGE_KEYSERVER_USER_PASSWORD_SUCCESS',
   failed: 'CHANGE_KEYSERVER_USER_PASSWORD_FAILED',
 });
 const changeKeyserverUserPassword =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((passwordUpdate: PasswordUpdate) => Promise<void>) =>
   async passwordUpdate => {
     await callSingleKeyserverEndpoint('update_account', passwordUpdate);
   };
 
 const searchUsersActionTypes = Object.freeze({
   started: 'SEARCH_USERS_STARTED',
   success: 'SEARCH_USERS_SUCCESS',
   failed: 'SEARCH_USERS_FAILED',
 });
 const searchUsers =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((usernamePrefix: string) => Promise<UserSearchResult>) =>
   async usernamePrefix => {
     const response = await callSingleKeyserverEndpoint('search_users', {
       prefix: usernamePrefix,
     });
     return {
       userInfos: response.userInfos,
     };
   };
 
 const exactSearchUserActionTypes = Object.freeze({
   started: 'EXACT_SEARCH_USER_STARTED',
   success: 'EXACT_SEARCH_USER_SUCCESS',
   failed: 'EXACT_SEARCH_USER_FAILED',
 });
 const exactSearchUser =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((username: string) => Promise<ExactUserSearchResult>) =>
   async username => {
     const response = await callSingleKeyserverEndpoint('exact_search_user', {
       username,
     });
     return {
       userInfo: response.userInfo,
     };
   };
 
 const updateSubscriptionActionTypes = Object.freeze({
   started: 'UPDATE_SUBSCRIPTION_STARTED',
   success: 'UPDATE_SUBSCRIPTION_SUCCESS',
   failed: 'UPDATE_SUBSCRIPTION_FAILED',
 });
 const updateSubscription =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: SubscriptionUpdateRequest,
   ) => Promise<SubscriptionUpdateResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'update_user_subscription',
       requests,
     );
     const response = responses[keyserverID];
     return {
       threadID: input.threadID,
       subscription: response.threadSubscription,
     };
   };
 
 function useUpdateSubscription(): (
   input: SubscriptionUpdateRequest,
 ) => Promise<SubscriptionUpdateResult> {
   return useKeyserverCall(updateSubscription);
 }
 
 const setUserSettingsActionTypes = Object.freeze({
   started: 'SET_USER_SETTINGS_STARTED',
   success: 'SET_USER_SETTINGS_SUCCESS',
   failed: 'SET_USER_SETTINGS_FAILED',
 });
 
 const setUserSettings =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
     allKeyserverIDs: $ReadOnlyArray<string>,
   ): ((input: UpdateUserSettingsRequest) => Promise<void>) =>
   async input => {
     const requests: { [string]: UpdateUserSettingsRequest } = {};
     for (const keyserverID of allKeyserverIDs) {
       requests[keyserverID] = input;
     }
     await callKeyserverEndpoint('update_user_settings', requests);
   };
 
 function useSetUserSettings(): (
   input: UpdateUserSettingsRequest,
 ) => Promise<void> {
   return useKeyserverCall(setUserSettings);
 }
 
 const getSessionPublicKeys =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((data: GetSessionPublicKeysArgs) => Promise<SessionPublicKeys | null>) =>
   async data => {
     return await callSingleKeyserverEndpoint('get_session_public_keys', data);
   };
 
 const getOlmSessionInitializationDataActionTypes = Object.freeze({
   started: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
   success: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
   failed: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
 });
 
 const getOlmSessionInitializationData =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((
     options?: ?CallSingleKeyserverEndpointOptions,
   ) => Promise<GetOlmSessionInitializationDataResponse>) =>
   async options => {
     const olmInitData = await callSingleKeyserverEndpoint(
       'get_olm_session_initialization_data',
       {},
       options,
     );
     return {
       signedIdentityKeysBlob: olmInitData.signedIdentityKeysBlob,
       contentInitializationInfo: {
         ...olmInitData.contentInitializationInfo,
         oneTimeKey: getOneTimeKeyValuesFromBlob(
           olmInitData.contentInitializationInfo.oneTimeKey,
         )[0],
       },
       notifInitializationInfo: {
         ...olmInitData.notifInitializationInfo,
         oneTimeKey: getOneTimeKeyValuesFromBlob(
           olmInitData.notifInitializationInfo.oneTimeKey,
         )[0],
       },
     };
   };
 
 const policyAcknowledgmentActionTypes = Object.freeze({
   started: 'POLICY_ACKNOWLEDGMENT_STARTED',
   success: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
   failed: 'POLICY_ACKNOWLEDGMENT_FAILED',
 });
 const policyAcknowledgment =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((policyRequest: PolicyAcknowledgmentRequest) => Promise<void>) =>
   async policyRequest => {
     await callSingleKeyserverEndpoint('policy_acknowledgment', policyRequest);
   };
 
 const updateUserAvatarActionTypes = Object.freeze({
   started: 'UPDATE_USER_AVATAR_STARTED',
   success: 'UPDATE_USER_AVATAR_SUCCESS',
   failed: 'UPDATE_USER_AVATAR_FAILED',
 });
 const updateUserAvatar =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((
     avatarDBContent: UpdateUserAvatarRequest,
   ) => Promise<UpdateUserAvatarResponse>) =>
   async avatarDBContent => {
     const { updates }: UpdateUserAvatarResponse =
       await callSingleKeyserverEndpoint('update_user_avatar', avatarDBContent);
     return { updates };
   };
 
 const resetUserStateActionType = 'RESET_USER_STATE';
 
 const setAccessTokenActionType = 'SET_ACCESS_TOKEN';
 
 export {
   changeKeyserverUserPasswordActionTypes,
   changeKeyserverUserPassword,
   claimUsernameActionTypes,
   useClaimUsername,
   useDeleteKeyserverAccount,
   deleteKeyserverAccountActionTypes,
   getSessionPublicKeys,
   getOlmSessionInitializationDataActionTypes,
   getOlmSessionInitializationData,
   mergeUserInfos,
   logIn as logInRawAction,
   identityLogInActionTypes,
   useIdentityPasswordLogIn,
   useIdentityWalletLogIn,
   useLogIn,
   logInActionTypes,
   useLogOut,
   logOutActionTypes,
   keyserverRegister,
   keyserverRegisterActionTypes,
   searchUsers,
   searchUsersActionTypes,
   exactSearchUser,
   exactSearchUserActionTypes,
   useSetUserSettings,
   setUserSettingsActionTypes,
   useUpdateSubscription,
   updateSubscriptionActionTypes,
   policyAcknowledgment,
   policyAcknowledgmentActionTypes,
   updateUserAvatarActionTypes,
   updateUserAvatar,
   resetUserStateActionType,
   setAccessTokenActionType,
   deleteAccountActionTypes,
   useDeleteAccount,
   keyserverAuthActionTypes,
   useKeyserverAuth,
   identityRegisterActionTypes,
   useIdentityRegister,
   identityGenerateNonceActionTypes,
   useIdentityGenerateNonce,
 };
diff --git a/lib/types/identity-service-types.js b/lib/types/identity-service-types.js
index 74b0e741d..c640c3e1b 100644
--- a/lib/types/identity-service-types.js
+++ b/lib/types/identity-service-types.js
@@ -1,129 +1,129 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   identityKeysBlobValidator,
   type IdentityKeysBlob,
 } from './crypto-types.js';
 import {
   type OlmSessionInitializationInfo,
   olmSessionInitializationInfoValidator,
 } from './request-types.js';
 import { tShape } from '../utils/validation-utils.js';
 
 export type UserLoginResponse = {
   +userId: string,
   +accessToken: string,
 };
 
 // This type should not be altered without also updating
 // OutboundKeyInfoResponse in native/native_rust_library/src/lib.rs
 export type OutboundKeyInfoResponse = {
   +payload: string,
   +payloadSignature: string,
   +socialProof: ?string,
   +contentPrekey: string,
   +contentPrekeySignature: string,
   +notifPrekey: string,
   +notifPrekeySignature: string,
   +oneTimeContentPrekey: ?string,
   +oneTimeNotifPrekey: ?string,
 };
 
 export type DeviceOlmOutboundKeys = {
   +identityKeysBlob: IdentityKeysBlob,
   +contentInitializationInfo: OlmSessionInitializationInfo,
   +notifInitializationInfo: OlmSessionInitializationInfo,
   +payloadSignature: string,
   +socialProof: ?string,
 };
 export const deviceOlmOutboundKeysValidator: TInterface<DeviceOlmOutboundKeys> =
   tShape<DeviceOlmOutboundKeys>({
     identityKeysBlob: identityKeysBlobValidator,
     contentInitializationInfo: olmSessionInitializationInfoValidator,
     notifInitializationInfo: olmSessionInitializationInfoValidator,
     payloadSignature: t.String,
     socialProof: t.maybe(t.String),
   });
 
 export type UserDevicesOlmOutboundKeys = {
   +deviceID: string,
   +keys: ?DeviceOlmOutboundKeys,
 };
 
 export interface IdentityServiceClient {
   +deleteUser: () => Promise<void>;
   +getKeyserverKeys: string => Promise<DeviceOlmOutboundKeys>;
-  +registerUser?: (
+  +registerPasswordUser?: (
     username: string,
     password: string,
   ) => Promise<IdentityAuthResult>;
   +logInPasswordUser: (
     username: string,
     password: string,
   ) => Promise<IdentityAuthResult>;
   +getOutboundKeysForUser: (
     userID: string,
   ) => Promise<UserDevicesOlmOutboundKeys[]>;
   +generateNonce: () => Promise<string>;
   +logInWalletUser: (
     walletAddress: string,
     siweMessage: string,
     siweSignature: string,
   ) => Promise<IdentityAuthResult>;
 }
 
 export type IdentityServiceAuthLayer = {
   +userID: string,
   +deviceID: string,
   +commServicesAccessToken: string,
 };
 
 // This type should not be altered without also updating
 // InboundKeyInfoResponse in native/native_rust_library/src/lib.rs
 export type InboundKeyInfoResponse = {
   +payload: string,
   +payloadSignature: string,
   +socialProof?: ?string,
   +contentPrekey: string,
   +contentPrekeySignature: string,
   +notifPrekey: string,
   +notifPrekeySignature: string,
   +username?: ?string,
   +walletAddress?: ?string,
 };
 
 export type IdentityAuthResult = {
   +userID: string,
   +accessToken: string,
   +username: string,
 };
 export const identityAuthResultValidator: TInterface<IdentityAuthResult> =
   tShape<IdentityAuthResult>({
     userID: t.String,
     accessToken: t.String,
     username: t.String,
   });
 
 export type IdentityDeviceKeyUpload = {
   +keyPayload: string,
   +keyPayloadSignature: string,
   +contentPrekey: string,
   +contentPrekeySignature: string,
   +notifPrekey: string,
   +notifPrekeySignature: string,
   +contentOneTimeKeys: $ReadOnlyArray<string>,
   +notifOneTimeKeys: $ReadOnlyArray<string>,
 };
 
 export const ONE_TIME_KEYS_NUMBER = 10;
 
 export const identityDeviceTypes = Object.freeze({
   KEYSERVER: 0,
   WEB: 1,
   IOS: 2,
   ANDROID: 3,
   WINDOWS: 4,
   MAC_OS: 5,
 });
diff --git a/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp b/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
index cf7af5733..65cef61b8 100644
--- a/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
+++ b/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
@@ -1,530 +1,530 @@
 #include "CommRustModule.h"
 #include "InternalModules/RustPromiseManager.h"
 #include "JSIRust.h"
 #include "lib.rs.h"
 
 #include <ReactCommon/TurboModuleUtils.h>
 
 namespace comm {
 
 using namespace facebook::react;
 
 CommRustModule::CommRustModule(std::shared_ptr<CallInvoker> jsInvoker)
     : CommRustModuleSchemaCxxSpecJSI(jsInvoker) {
 }
 
 jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGenerateNonce(currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
-jsi::Value CommRustModule::registerUser(
+jsi::Value CommRustModule::registerPasswordUser(
     jsi::Runtime &rt,
     jsi::String username,
     jsi::String password,
     jsi::String keyPayload,
     jsi::String keyPayloadSignature,
     jsi::String contentPrekey,
     jsi::String contentPrekeySignature,
     jsi::String notifPrekey,
     jsi::String notifPrekeySignature,
     jsi::Array contentOneTimeKeys,
     jsi::Array notifOneTimeKeys) {
   auto usernameRust = jsiStringToRustString(username, rt);
   auto passwordRust = jsiStringToRustString(password, rt);
   auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
   auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
   auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
   auto contentPrekeySignatureRust =
       jsiStringToRustString(contentPrekeySignature, rt);
   auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
   auto notifPrekeySignatureRust =
       jsiStringToRustString(notifPrekeySignature, rt);
   auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
   auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
-          identityRegisterUser(
+          identityRegisterPasswordUser(
               usernameRust,
               passwordRust,
               keyPayloadRust,
               keyPayloadSignatureRust,
               contentPrekeyRust,
               contentPrekeySignatureRust,
               notifPrekeyRust,
               notifPrekeySignatureRust,
               contentOneTimeKeysRust,
               notifOneTimeKeysRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::logInPasswordUser(
     jsi::Runtime &rt,
     jsi::String username,
     jsi::String password,
     jsi::String keyPayload,
     jsi::String keyPayloadSignature,
     jsi::String contentPrekey,
     jsi::String contentPrekeySignature,
     jsi::String notifPrekey,
     jsi::String notifPrekeySignature,
     jsi::Array contentOneTimeKeys,
     jsi::Array notifOneTimeKeys) {
   auto usernameRust = jsiStringToRustString(username, rt);
   auto passwordRust = jsiStringToRustString(password, rt);
   auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
   auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
   auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
   auto contentPrekeySignatureRust =
       jsiStringToRustString(contentPrekeySignature, rt);
   auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
   auto notifPrekeySignatureRust =
       jsiStringToRustString(notifPrekeySignature, rt);
   auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
   auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityLogInPasswordUser(
               usernameRust,
               passwordRust,
               keyPayloadRust,
               keyPayloadSignatureRust,
               contentPrekeyRust,
               contentPrekeySignatureRust,
               notifPrekeyRust,
               notifPrekeySignatureRust,
               contentOneTimeKeysRust,
               notifOneTimeKeysRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::logInWalletUser(
     jsi::Runtime &rt,
     jsi::String siweMessage,
     jsi::String siweSignature,
     jsi::String keyPayload,
     jsi::String keyPayloadSignature,
     jsi::String contentPrekey,
     jsi::String contentPrekeySignature,
     jsi::String notifPrekey,
     jsi::String notifPrekeySignature,
     jsi::Array contentOneTimeKeys,
     jsi::Array notifOneTimeKeys) {
   auto siweMessageRust = jsiStringToRustString(siweMessage, rt);
   auto siweSignatureRust = jsiStringToRustString(siweSignature, rt);
   auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
   auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
   auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
   auto contentPrekeySignatureRust =
       jsiStringToRustString(contentPrekeySignature, rt);
   auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
   auto notifPrekeySignatureRust =
       jsiStringToRustString(notifPrekeySignature, rt);
   auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
   auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityLogInWalletUser(
               siweMessageRust,
               siweSignatureRust,
               keyPayloadRust,
               keyPayloadSignatureRust,
               contentPrekeyRust,
               contentPrekeySignatureRust,
               notifPrekeyRust,
               notifPrekeySignatureRust,
               contentOneTimeKeysRust,
               notifOneTimeKeysRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::updatePassword(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
     jsi::String accessToken,
     jsi::String password) {
   auto userIDRust = jsiStringToRustString(userID, rt);
   auto deviceIDRust = jsiStringToRustString(deviceID, rt);
   auto accessTokenRust = jsiStringToRustString(accessToken, rt);
   auto passwordRust = jsiStringToRustString(password, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityUpdateUserPassword(
               userIDRust,
               deviceIDRust,
               accessTokenRust,
               passwordRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::deleteUser(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
     jsi::String accessToken) {
   auto userIDRust = jsiStringToRustString(userID, rt);
   auto deviceIDRust = jsiStringToRustString(deviceID, rt);
   auto accessTokenRust = jsiStringToRustString(accessToken, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityDeleteUser(
               userIDRust, deviceIDRust, accessTokenRust, currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::getOutboundKeysForUser(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String userID) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto userIDRust = jsiStringToRustString(userID, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGetOutboundKeysForUser(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               userIDRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::getInboundKeysForUser(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String userID) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto userIDRust = jsiStringToRustString(userID, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGetInboundKeysForUser(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               userIDRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityVersionSupported(currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::uploadOneTimeKeys(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::Array contentOneTimePreKeys,
     jsi::Array notifOneTimePreKeys) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto contentOneTimePreKeysRust =
       jsiStringArrayToRustVec(contentOneTimePreKeys, rt);
   auto notifOneTimePreKeysRust =
       jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityUploadOneTimeKeys(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               contentOneTimePreKeysRust,
               notifOneTimePreKeysRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::getKeyserverKeys(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String keyserverID) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGetKeyserverKeys(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               keyserverIDRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::getDeviceListForUser(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String userID,
     std::optional<double> sinceTimestamp) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto userIDRust = jsiStringToRustString(userID, rt);
 
   auto timestampI64 = static_cast<int64_t>(sinceTimestamp.value_or(0));
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityGetDeviceListForUser(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               userIDRust,
               timestampI64,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::updateDeviceList(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken,
     jsi::String updatePayload) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   auto updatePayloadRust = jsiStringToRustString(updatePayload, rt);
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityUpdateDeviceList(
               authUserIDRust,
               authDeviceIDRust,
               authAccessTokenRust,
               updatePayloadRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
 }
 
 jsi::Value CommRustModule::uploadSecondaryDeviceKeysAndLogIn(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String challengeResponse,
     jsi::String keyPayload,
     jsi::String keyPayloadSignature,
     jsi::String contentPrekey,
     jsi::String contentPrekeySignature,
     jsi::String notifPrekey,
     jsi::String notifPrekeySignature,
     jsi::Array contentOneTimeKeys,
     jsi::Array notifOneTimeKeys) {
   auto userIDRust = jsiStringToRustString(userID, rt);
   auto challengeResponseRust = jsiStringToRustString(challengeResponse, rt);
   auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
   auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
   auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
   auto contentPrekeySignatureRust =
       jsiStringToRustString(contentPrekeySignature, rt);
   auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
   auto notifPrekeySignatureRust =
       jsiStringToRustString(notifPrekeySignature, rt);
   auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
   auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
 
   return createPromiseAsJSIValue(
       rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               {promise, this->jsInvoker_, innerRt});
           identityUploadSecondaryDeviceKeysAndLogIn(
               userIDRust,
               challengeResponseRust,
               keyPayloadRust,
               keyPayloadSignatureRust,
               contentPrekeyRust,
               contentPrekeySignatureRust,
               notifPrekeyRust,
               notifPrekeySignatureRust,
               contentOneTimeKeysRust,
               notifOneTimeKeysRust,
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
         if (!error.empty()) {
           this->jsInvoker_->invokeAsync(
               [error, promise]() { promise->reject(error); });
         }
       });
   return jsi::Value::undefined();
 }
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/NativeModules/CommRustModule.h b/native/cpp/CommonCpp/NativeModules/CommRustModule.h
index 77d416495..843b2d14f 100644
--- a/native/cpp/CommonCpp/NativeModules/CommRustModule.h
+++ b/native/cpp/CommonCpp/NativeModules/CommRustModule.h
@@ -1,118 +1,118 @@
 #pragma once
 
 #include "../_generated/rustJSI.h"
 
 #include <ReactCommon/TurboModuleUtils.h>
 #include <jsi/jsi.h>
 #include <memory>
 
 namespace comm {
 
 namespace jsi = facebook::jsi;
 
 class CommRustModule : public facebook::react::CommRustModuleSchemaCxxSpecJSI {
   virtual jsi::Value generateNonce(jsi::Runtime &rt) override;
-  virtual jsi::Value registerUser(
+  virtual jsi::Value registerPasswordUser(
       jsi::Runtime &rt,
       jsi::String username,
       jsi::String password,
       jsi::String keyPayload,
       jsi::String keyPayloadSignature,
       jsi::String contentPrekey,
       jsi::String contentPrekeySignature,
       jsi::String notifPrekey,
       jsi::String notifPrekeySignature,
       jsi::Array contentOneTimeKeys,
       jsi::Array notifOneTimeKeys) override;
   virtual jsi::Value logInPasswordUser(
       jsi::Runtime &rt,
       jsi::String username,
       jsi::String password,
       jsi::String keyPayload,
       jsi::String keyPayloadSignature,
       jsi::String contentPrekey,
       jsi::String contentPrekeySignature,
       jsi::String notifPrekey,
       jsi::String notifPrekeySignature,
       jsi::Array contentOneTimeKeys,
       jsi::Array notifOneTimeKeys) override;
   virtual jsi::Value logInWalletUser(
       jsi::Runtime &rt,
       jsi::String siweMessage,
       jsi::String siweSignature,
       jsi::String keyPayload,
       jsi::String keyPayloadSignature,
       jsi::String contentPrekey,
       jsi::String contentPrekeySignature,
       jsi::String notifPrekey,
       jsi::String notifPrekeySignature,
       jsi::Array contentOneTimeKeys,
       jsi::Array notifOneTimeKeys) override;
   virtual jsi::Value updatePassword(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String deviceID,
       jsi::String accessToken,
       jsi::String password) override;
   virtual jsi::Value deleteUser(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String deviceID,
       jsi::String accessToken) override;
   virtual jsi::Value getOutboundKeysForUser(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String userID) override;
   virtual jsi::Value getInboundKeysForUser(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String userID) override;
   virtual jsi::Value versionSupported(jsi::Runtime &rt) override;
   virtual jsi::Value uploadOneTimeKeys(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::Array contentOneTimePreKeys,
       jsi::Array notifOneTimePreKeys) override;
   virtual jsi::Value getKeyserverKeys(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String keyserverID) override;
   virtual jsi::Value getDeviceListForUser(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String userID,
       std::optional<double> sinceTimestamp) override;
   virtual jsi::Value updateDeviceList(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken,
       jsi::String updatePayload) override;
   virtual jsi::Value uploadSecondaryDeviceKeysAndLogIn(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String challengeResponse,
       jsi::String keyPayload,
       jsi::String keyPayloadSignature,
       jsi::String contentPrekey,
       jsi::String contentPrekeySignature,
       jsi::String notifPrekey,
       jsi::String notifPrekeySignature,
       jsi::Array contentOneTimeKeys,
       jsi::Array notifOneTimeKeys) override;
 
 public:
   CommRustModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
 };
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp b/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp
index 610b8eef4..d29a872cd 100644
--- a/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp
+++ b/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp
@@ -1,78 +1,78 @@
 /**
  * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
  *
  * Do not edit this file as changes may cause incorrect behavior and will be lost
  * once the code is regenerated.
  *
  * @generated by codegen project: GenerateModuleH.js
  */
 
 #include "rustJSI.h"
 
 namespace facebook {
 namespace react {
 
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_generateNonce(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->generateNonce(rt);
 }
-static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
-  return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->registerUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt));
+static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerPasswordUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->registerPasswordUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInPasswordUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInPasswordUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInWalletUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInWalletUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_updatePassword(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->updatePassword(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_deleteUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->deleteUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getOutboundKeysForUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getOutboundKeysForUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getInboundKeysForUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getInboundKeysForUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_versionSupported(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->versionSupported(rt);
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadOneTimeKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->uploadOneTimeKeys(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asObject(rt).asArray(rt), args[4].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getKeyserverKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getKeyserverKeys(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getDeviceListForUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getDeviceListForUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].isNull() || args[4].isUndefined() ? std::nullopt : std::make_optional(args[4].asNumber()));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_updateDeviceList(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->updateDeviceList(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->uploadSecondaryDeviceKeysAndLogIn(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt));
 }
 
 CommRustModuleSchemaCxxSpecJSI::CommRustModuleSchemaCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
   : TurboModule("CommRustTurboModule", jsInvoker) {
   methodMap_["generateNonce"] = MethodMetadata {0, __hostFunction_CommRustModuleSchemaCxxSpecJSI_generateNonce};
-  methodMap_["registerUser"] = MethodMetadata {10, __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerUser};
+  methodMap_["registerPasswordUser"] = MethodMetadata {10, __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerPasswordUser};
   methodMap_["logInPasswordUser"] = MethodMetadata {10, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInPasswordUser};
   methodMap_["logInWalletUser"] = MethodMetadata {10, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInWalletUser};
   methodMap_["updatePassword"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_updatePassword};
   methodMap_["deleteUser"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_deleteUser};
   methodMap_["getOutboundKeysForUser"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getOutboundKeysForUser};
   methodMap_["getInboundKeysForUser"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getInboundKeysForUser};
   methodMap_["versionSupported"] = MethodMetadata {0, __hostFunction_CommRustModuleSchemaCxxSpecJSI_versionSupported};
   methodMap_["uploadOneTimeKeys"] = MethodMetadata {5, __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadOneTimeKeys};
   methodMap_["getKeyserverKeys"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getKeyserverKeys};
   methodMap_["getDeviceListForUser"] = MethodMetadata {5, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getDeviceListForUser};
   methodMap_["updateDeviceList"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_updateDeviceList};
   methodMap_["uploadSecondaryDeviceKeysAndLogIn"] = MethodMetadata {10, __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadSecondaryDeviceKeysAndLogIn};
 }
 
 
 } // namespace react
 } // namespace facebook
diff --git a/native/cpp/CommonCpp/_generated/rustJSI.h b/native/cpp/CommonCpp/_generated/rustJSI.h
index 4426e31e8..f341aaddd 100644
--- a/native/cpp/CommonCpp/_generated/rustJSI.h
+++ b/native/cpp/CommonCpp/_generated/rustJSI.h
@@ -1,179 +1,179 @@
 /**
  * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
  *
  * Do not edit this file as changes may cause incorrect behavior and will be lost
  * once the code is regenerated.
  *
  * @generated by codegen project: GenerateModuleH.js
  */
 
 #pragma once
 
 #include <ReactCommon/TurboModule.h>
 #include <react/bridging/Bridging.h>
 
 namespace facebook {
 namespace react {
 
 class JSI_EXPORT CommRustModuleSchemaCxxSpecJSI : public TurboModule {
 protected:
   CommRustModuleSchemaCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
 
 public:
   virtual jsi::Value generateNonce(jsi::Runtime &rt) = 0;
-  virtual jsi::Value registerUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
+  virtual jsi::Value registerPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
   virtual jsi::Value logInPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
   virtual jsi::Value logInWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
   virtual jsi::Value updatePassword(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String password) = 0;
   virtual jsi::Value deleteUser(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) = 0;
   virtual jsi::Value getOutboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) = 0;
   virtual jsi::Value getInboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) = 0;
   virtual jsi::Value versionSupported(jsi::Runtime &rt) = 0;
   virtual jsi::Value uploadOneTimeKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array contentOneTimePreKeys, jsi::Array notifOneTimePreKeys) = 0;
   virtual jsi::Value getKeyserverKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String keyserverID) = 0;
   virtual jsi::Value getDeviceListForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID, std::optional<double> sinceTimestamp) = 0;
   virtual jsi::Value updateDeviceList(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String updatePayload) = 0;
   virtual jsi::Value uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, jsi::String userID, jsi::String challengeResponse, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
 
 };
 
 template <typename T>
 class JSI_EXPORT CommRustModuleSchemaCxxSpec : public TurboModule {
 public:
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
     return delegate_.get(rt, propName);
   }
 
 protected:
   CommRustModuleSchemaCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule("CommRustTurboModule", jsInvoker),
       delegate_(static_cast<T*>(this), jsInvoker) {}
 
 private:
   class Delegate : public CommRustModuleSchemaCxxSpecJSI {
   public:
     Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
       CommRustModuleSchemaCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {}
 
     jsi::Value generateNonce(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::generateNonce) == 1,
           "Expected generateNonce(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::generateNonce, jsInvoker_, instance_);
     }
-    jsi::Value registerUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
+    jsi::Value registerPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
       static_assert(
-          bridging::getParameterCount(&T::registerUser) == 11,
-          "Expected registerUser(...) to have 11 parameters");
+          bridging::getParameterCount(&T::registerPasswordUser) == 11,
+          "Expected registerPasswordUser(...) to have 11 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::registerUser, jsInvoker_, instance_, std::move(username), std::move(password), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
+          rt, &T::registerPasswordUser, jsInvoker_, instance_, std::move(username), std::move(password), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
     }
     jsi::Value logInPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
       static_assert(
           bridging::getParameterCount(&T::logInPasswordUser) == 11,
           "Expected logInPasswordUser(...) to have 11 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::logInPasswordUser, jsInvoker_, instance_, std::move(username), std::move(password), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
     }
     jsi::Value logInWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
       static_assert(
           bridging::getParameterCount(&T::logInWalletUser) == 11,
           "Expected logInWalletUser(...) to have 11 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::logInWalletUser, jsInvoker_, instance_, std::move(siweMessage), std::move(siweSignature), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
     }
     jsi::Value updatePassword(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String password) override {
       static_assert(
           bridging::getParameterCount(&T::updatePassword) == 5,
           "Expected updatePassword(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::updatePassword, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken), std::move(password));
     }
     jsi::Value deleteUser(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) override {
       static_assert(
           bridging::getParameterCount(&T::deleteUser) == 4,
           "Expected deleteUser(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::deleteUser, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken));
     }
     jsi::Value getOutboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) override {
       static_assert(
           bridging::getParameterCount(&T::getOutboundKeysForUser) == 5,
           "Expected getOutboundKeysForUser(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getOutboundKeysForUser, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userID));
     }
     jsi::Value getInboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) override {
       static_assert(
           bridging::getParameterCount(&T::getInboundKeysForUser) == 5,
           "Expected getInboundKeysForUser(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getInboundKeysForUser, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userID));
     }
     jsi::Value versionSupported(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::versionSupported) == 1,
           "Expected versionSupported(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::versionSupported, jsInvoker_, instance_);
     }
     jsi::Value uploadOneTimeKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array contentOneTimePreKeys, jsi::Array notifOneTimePreKeys) override {
       static_assert(
           bridging::getParameterCount(&T::uploadOneTimeKeys) == 6,
           "Expected uploadOneTimeKeys(...) to have 6 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::uploadOneTimeKeys, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(contentOneTimePreKeys), std::move(notifOneTimePreKeys));
     }
     jsi::Value getKeyserverKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String keyserverID) override {
       static_assert(
           bridging::getParameterCount(&T::getKeyserverKeys) == 5,
           "Expected getKeyserverKeys(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getKeyserverKeys, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(keyserverID));
     }
     jsi::Value getDeviceListForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID, std::optional<double> sinceTimestamp) override {
       static_assert(
           bridging::getParameterCount(&T::getDeviceListForUser) == 6,
           "Expected getDeviceListForUser(...) to have 6 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getDeviceListForUser, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userID), std::move(sinceTimestamp));
     }
     jsi::Value updateDeviceList(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String updatePayload) override {
       static_assert(
           bridging::getParameterCount(&T::updateDeviceList) == 5,
           "Expected updateDeviceList(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::updateDeviceList, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(updatePayload));
     }
     jsi::Value uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, jsi::String userID, jsi::String challengeResponse, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
       static_assert(
           bridging::getParameterCount(&T::uploadSecondaryDeviceKeysAndLogIn) == 11,
           "Expected uploadSecondaryDeviceKeysAndLogIn(...) to have 11 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::uploadSecondaryDeviceKeysAndLogIn, jsInvoker_, instance_, std::move(userID), std::move(challengeResponse), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
     }
 
   private:
     T *instance_;
   };
 
   Delegate delegate_;
 };
 
 } // namespace react
 } // namespace facebook
diff --git a/native/identity-service/identity-service-context-provider.react.js b/native/identity-service/identity-service-context-provider.react.js
index 4c06567a8..fb99d2fd0 100644
--- a/native/identity-service/identity-service-context-provider.react.js
+++ b/native/identity-service/identity-service-context-provider.react.js
@@ -1,322 +1,322 @@
 // @flow
 
 import * as React from 'react';
 
 import { getOneTimeKeyValues } from 'lib/shared/crypto-utils.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import {
   type IdentityKeysBlob,
   identityKeysBlobValidator,
 } from 'lib/types/crypto-types.js';
 import {
   type DeviceOlmOutboundKeys,
   deviceOlmOutboundKeysValidator,
   type IdentityServiceClient,
   type UserDevicesOlmOutboundKeys,
   type UserLoginResponse,
   ONE_TIME_KEYS_NUMBER,
   identityAuthResultValidator,
 } from 'lib/types/identity-service-types.js';
 import { assertWithValidator } from 'lib/utils/validation-utils.js';
 
 import { getCommServicesAuthMetadataEmitter } from '../event-emitters/csa-auth-metadata-emitter.js';
 import { commCoreModule, commRustModule } from '../native-modules.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { getContentSigningKey } from '../utils/crypto-utils.js';
 
 type Props = {
   +children: React.Node,
 };
 function IdentityServiceContextProvider(props: Props): React.Node {
   const { children } = props;
 
   const userIDPromiseRef = React.useRef<?Promise<?string>>();
   if (!userIDPromiseRef.current) {
     userIDPromiseRef.current = (async () => {
       const { userID } = await commCoreModule.getCommServicesAuthMetadata();
       return userID;
     })();
   }
 
   React.useEffect(() => {
     const metadataEmitter = getCommServicesAuthMetadataEmitter();
     const subscription = metadataEmitter.addListener(
       'commServicesAuthMetadata',
       (authMetadata: UserLoginResponse) => {
         userIDPromiseRef.current = Promise.resolve(authMetadata.userId);
       },
     );
     return () => subscription.remove();
   }, []);
 
   const accessToken = useSelector(state => state.commServicesAccessToken);
 
   const getAuthMetadata = React.useCallback<
     () => Promise<{
       +deviceID: string,
       +userID: string,
       +accessToken: string,
     }>,
   >(async () => {
     const deviceID = await getContentSigningKey();
     const userID = await userIDPromiseRef.current;
     if (!deviceID || !userID || !accessToken) {
       throw new Error('Identity service client is not initialized');
     }
     return { deviceID, userID, accessToken };
   }, [accessToken]);
 
   const client = React.useMemo<IdentityServiceClient>(
     () => ({
       deleteUser: async () => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         return commRustModule.deleteUser(userID, deviceID, token);
       },
       getKeyserverKeys: async (
         keyserverID: string,
       ): Promise<DeviceOlmOutboundKeys> => {
         const {
           deviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         const result = await commRustModule.getKeyserverKeys(
           userID,
           deviceID,
           token,
           keyserverID,
         );
         const resultObject = JSON.parse(result);
         const payload = resultObject?.payload;
 
         const keyserverKeys = {
           identityKeysBlob: payload ? JSON.parse(payload) : null,
           contentInitializationInfo: {
             prekey: resultObject?.contentPrekey,
             prekeySignature: resultObject?.contentPrekeySignature,
             oneTimeKey: resultObject?.oneTimeContentPrekey,
           },
           notifInitializationInfo: {
             prekey: resultObject?.notifPrekey,
             prekeySignature: resultObject?.notifPrekeySignature,
             oneTimeKey: resultObject?.oneTimeNotifPrekey,
           },
           payloadSignature: resultObject?.payloadSignature,
           socialProof: resultObject?.socialProof,
         };
 
         if (!keyserverKeys.contentInitializationInfo.oneTimeKey) {
           throw new Error('Missing content one time key');
         }
         if (!keyserverKeys.notifInitializationInfo.oneTimeKey) {
           throw new Error('Missing notif one time key');
         }
 
         return assertWithValidator(
           keyserverKeys,
           deviceOlmOutboundKeysValidator,
         );
       },
       getOutboundKeysForUser: async (
         targetUserID: string,
       ): Promise<UserDevicesOlmOutboundKeys[]> => {
         const {
           deviceID: authDeviceID,
           userID,
           accessToken: token,
         } = await getAuthMetadata();
         const result = await commRustModule.getOutboundKeysForUser(
           userID,
           authDeviceID,
           token,
           targetUserID,
         );
         const resultArray = JSON.parse(result);
 
         return resultArray
           .map(outboundKeysInfo => {
             try {
               const payload = outboundKeysInfo?.payload;
               const identityKeysBlob: IdentityKeysBlob = assertWithValidator(
                 payload ? JSON.parse(payload) : null,
                 identityKeysBlobValidator,
               );
               const deviceID =
                 identityKeysBlob.primaryIdentityPublicKeys.ed25519;
 
               if (
                 !outboundKeysInfo.oneTimeContentPrekey ||
                 !outboundKeysInfo.oneTimeNotifPrekey
               ) {
                 console.log(`Missing one time key for device ${deviceID}`);
                 return {
                   deviceID,
                   keys: null,
                 };
               }
 
               const deviceKeys = {
                 identityKeysBlob,
                 contentInitializationInfo: {
                   prekey: outboundKeysInfo?.contentPrekey,
                   prekeySignature: outboundKeysInfo?.contentPrekeySignature,
                   oneTimeKey: outboundKeysInfo?.oneTimeContentPrekey,
                 },
                 notifInitializationInfo: {
                   prekey: outboundKeysInfo?.notifPrekey,
                   prekeySignature: outboundKeysInfo?.notifPrekeySignature,
                   oneTimeKey: outboundKeysInfo?.oneTimeNotifPrekey,
                 },
                 payloadSignature: outboundKeysInfo?.payloadSignature,
                 socialProof: outboundKeysInfo?.socialProof,
               };
 
               try {
                 const validatedKeys = assertWithValidator(
                   deviceKeys,
                   deviceOlmOutboundKeysValidator,
                 );
                 return {
                   deviceID,
                   keys: validatedKeys,
                 };
               } catch (e) {
                 console.log(e);
                 return {
                   deviceID,
                   keys: null,
                 };
               }
             } catch (e) {
               console.log(e);
               return null;
             }
           })
           .filter(Boolean);
       },
-      registerUser: async (username: string, password: string) => {
+      registerPasswordUser: async (username: string, password: string) => {
         await commCoreModule.initializeCryptoAccount();
         const [
           { blobPayload, signature },
           { contentOneTimeKeys, notificationsOneTimeKeys },
           prekeys,
         ] = await Promise.all([
           commCoreModule.getUserPublicKey(),
           commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
           commCoreModule.validateAndGetPrekeys(),
         ]);
-        const registrationResult = await commRustModule.registerUser(
+        const registrationResult = await commRustModule.registerPasswordUser(
           username,
           password,
           blobPayload,
           signature,
           prekeys.contentPrekey,
           prekeys.contentPrekeySignature,
           prekeys.notifPrekey,
           prekeys.notifPrekeySignature,
           getOneTimeKeyValues(contentOneTimeKeys),
           getOneTimeKeyValues(notificationsOneTimeKeys),
         );
         const { userID, accessToken: token } = JSON.parse(registrationResult);
         const identityAuthResult = { accessToken: token, userID, username };
 
         return assertWithValidator(
           identityAuthResult,
           identityAuthResultValidator,
         );
       },
       logInPasswordUser: async (username: string, password: string) => {
         await commCoreModule.initializeCryptoAccount();
         const [
           { blobPayload, signature },
           { contentOneTimeKeys, notificationsOneTimeKeys },
           prekeys,
         ] = await Promise.all([
           commCoreModule.getUserPublicKey(),
           commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
           commCoreModule.validateAndGetPrekeys(),
         ]);
         const loginResult = await commRustModule.logInPasswordUser(
           username,
           password,
           blobPayload,
           signature,
           prekeys.contentPrekey,
           prekeys.contentPrekeySignature,
           prekeys.notifPrekey,
           prekeys.notifPrekeySignature,
           getOneTimeKeyValues(contentOneTimeKeys),
           getOneTimeKeyValues(notificationsOneTimeKeys),
         );
         const { userID, accessToken: token } = JSON.parse(loginResult);
         const identityAuthResult = { accessToken: token, userID, username };
 
         return assertWithValidator(
           identityAuthResult,
           identityAuthResultValidator,
         );
       },
       logInWalletUser: async (
         walletAddress: string,
         siweMessage: string,
         siweSignature: string,
       ) => {
         await commCoreModule.initializeCryptoAccount();
         const [
           { blobPayload, signature },
           { contentOneTimeKeys, notificationsOneTimeKeys },
           prekeys,
         ] = await Promise.all([
           commCoreModule.getUserPublicKey(),
           commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
           commCoreModule.validateAndGetPrekeys(),
         ]);
         const loginResult = await commRustModule.logInWalletUser(
           siweMessage,
           siweSignature,
           blobPayload,
           signature,
           prekeys.contentPrekey,
           prekeys.contentPrekeySignature,
           prekeys.notifPrekey,
           prekeys.notifPrekeySignature,
           getOneTimeKeyValues(contentOneTimeKeys),
           getOneTimeKeyValues(notificationsOneTimeKeys),
         );
         const { userID, accessToken: token } = JSON.parse(loginResult);
         const identityAuthResult = {
           accessToken: token,
           userID,
           username: walletAddress,
         };
 
         return assertWithValidator(
           identityAuthResult,
           identityAuthResultValidator,
         );
       },
       generateNonce: commRustModule.generateNonce,
     }),
     [getAuthMetadata],
   );
 
   const value = React.useMemo(
     () => ({
       identityClient: client,
       getAuthMetadata,
     }),
     [client, getAuthMetadata],
   );
 
   return (
     <IdentityClientContext.Provider value={value}>
       {children}
     </IdentityClientContext.Provider>
   );
 }
 
 export default IdentityServiceContextProvider;
diff --git a/native/native_rust_library/src/lib.rs b/native/native_rust_library/src/lib.rs
index cf21bed90..f9ffe8a7f 100644
--- a/native/native_rust_library/src/lib.rs
+++ b/native/native_rust_library/src/lib.rs
@@ -1,1477 +1,1477 @@
 use backup::ffi::*;
 use comm_opaque2::client::{Login, Registration};
 use comm_opaque2::grpc::opaque_error_to_grpc_status as handle_error;
 use ffi::{bool_callback, string_callback, void_callback};
 use grpc_clients::identity::protos::auth::{
   GetDeviceListRequest, UpdateDeviceListRequest,
 };
 use grpc_clients::identity::protos::authenticated::{
   InboundKeyInfo, InboundKeysForUserRequest, KeyserverKeysResponse,
   OutboundKeyInfo, OutboundKeysForUserRequest, RefreshUserPrekeysRequest,
   UpdateUserPasswordFinishRequest, UpdateUserPasswordStartRequest,
   UploadOneTimeKeysRequest,
 };
 use grpc_clients::identity::protos::unauth::{
   AuthResponse, DeviceKeyUpload, DeviceType, Empty, IdentityKeyInfo,
   OpaqueLoginFinishRequest, OpaqueLoginStartRequest, Prekey,
   RegistrationFinishRequest, RegistrationStartRequest,
   SecondaryDeviceKeysUploadRequest, WalletAuthRequest,
 };
 use grpc_clients::identity::{
   get_auth_client, get_unauthenticated_client, REQUEST_METADATA_COOKIE_KEY,
   RESPONSE_METADATA_COOKIE_KEY,
 };
 use lazy_static::lazy_static;
 use serde::Serialize;
 use std::sync::Arc;
 use tokio::runtime::{Builder, Runtime};
 use tonic::{Request, Status};
 use tracing::instrument;
 
 mod argon2_tools;
 mod backup;
 mod constants;
 
 use argon2_tools::compute_backup_key_str;
 
 mod generated {
   // We get the CODE_VERSION from this generated file
   include!(concat!(env!("OUT_DIR"), "/version.rs"));
   // We get the IDENTITY_SOCKET_ADDR from this generated file
   include!(concat!(env!("OUT_DIR"), "/socket_config.rs"));
 }
 
 pub use generated::CODE_VERSION;
 pub use generated::{BACKUP_SOCKET_ADDR, IDENTITY_SOCKET_ADDR};
 
 #[cfg(not(target_os = "android"))]
 pub const DEVICE_TYPE: DeviceType = DeviceType::Ios;
 #[cfg(target_os = "android")]
 pub const DEVICE_TYPE: DeviceType = DeviceType::Android;
 
 lazy_static! {
   static ref RUNTIME: Arc<Runtime> =
     Arc::new(Builder::new_multi_thread().enable_all().build().unwrap());
 }
 
 #[cxx::bridge]
 mod ffi {
 
   extern "Rust" {
-    #[cxx_name = "identityRegisterUser"]
-    fn register_user(
+    #[cxx_name = "identityRegisterPasswordUser"]
+    fn register_password_user(
       username: String,
       password: String,
       key_payload: String,
       key_payload_signature: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       content_one_time_keys: Vec<String>,
       notif_one_time_keys: Vec<String>,
       promise_id: u32,
     );
 
     #[cxx_name = "identityLogInPasswordUser"]
     fn log_in_password_user(
       username: String,
       password: String,
       key_payload: String,
       key_payload_signature: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       content_one_time_keys: Vec<String>,
       notif_one_time_keys: Vec<String>,
       promise_id: u32,
     );
 
     #[cxx_name = "identityLogInWalletUser"]
     fn log_in_wallet_user(
       siwe_message: String,
       siwe_signature: String,
       key_payload: String,
       key_payload_signature: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       content_one_time_keys: Vec<String>,
       notif_one_time_keys: Vec<String>,
       promise_id: u32,
     );
 
     #[cxx_name = "identityUpdateUserPassword"]
     fn update_user_password(
       user_id: String,
       device_id: String,
       access_token: String,
       password: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityDeleteUser"]
     fn delete_user(
       user_id: String,
       device_id: String,
       access_token: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGetOutboundKeysForUser"]
     fn get_outbound_keys_for_user(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       user_id: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGetInboundKeysForUser"]
     fn get_inbound_keys_for_user(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       user_id: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityRefreshUserPrekeys"]
     fn refresh_user_prekeys(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGenerateNonce"]
     fn generate_nonce(promise_id: u32);
 
     #[cxx_name = "identityVersionSupported"]
     fn version_supported(promise_id: u32);
 
     #[cxx_name = "identityUploadOneTimeKeys"]
     fn upload_one_time_keys(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       content_one_time_keys: Vec<String>,
       notif_one_time_keys: Vec<String>,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGetKeyserverKeys"]
     fn get_keyserver_keys(
       user_id: String,
       device_id: String,
       access_token: String,
       keyserver_id: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityGetDeviceListForUser"]
     fn get_device_list_for_user(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       user_id: String,
       since_timestamp: i64,
       promise_id: u32,
     );
 
     #[cxx_name = "identityUpdateDeviceList"]
     fn update_device_list(
       auth_user_id: String,
       auth_device_id: String,
       auth_access_token: String,
       update_payload: String,
       promise_id: u32,
     );
 
     #[cxx_name = "identityUploadSecondaryDeviceKeysAndLogIn"]
     fn upload_secondary_device_keys_and_log_in(
       user_id: String,
       challenge_response: String,
       key_payload: String,
       key_payload_signature: String,
       content_prekey: String,
       content_prekey_signature: String,
       notif_prekey: String,
       notif_prekey_signature: String,
       content_one_time_keys: Vec<String>,
       notif_one_time_keys: Vec<String>,
       promise_id: u32,
     );
 
     // Argon2
     #[cxx_name = "compute_backup_key"]
     fn compute_backup_key_str(
       password: &str,
       backup_id: &str,
     ) -> Result<[u8; 32]>;
   }
 
   unsafe extern "C++" {
     include!("RustCallback.h");
     #[namespace = "comm"]
     #[cxx_name = "stringCallback"]
     fn string_callback(error: String, promise_id: u32, ret: String);
 
     #[namespace = "comm"]
     #[cxx_name = "voidCallback"]
     fn void_callback(error: String, promise_id: u32);
 
     #[namespace = "comm"]
     #[cxx_name = "boolCallback"]
     fn bool_callback(error: String, promise_id: u32, ret: bool);
   }
 
   // AES cryptography
   #[namespace = "comm"]
   unsafe extern "C++" {
     include!("RustAESCrypto.h");
 
     #[allow(unused)]
     #[cxx_name = "aesGenerateKey"]
     fn generate_key(buffer: &mut [u8]) -> Result<()>;
 
     /// The first two argument aren't mutated but creation of Java ByteBuffer
     /// requires the underlying bytes to be mutable.
     #[allow(unused)]
     #[cxx_name = "aesEncrypt"]
     fn encrypt(
       key: &mut [u8],
       plaintext: &mut [u8],
       sealed_data: &mut [u8],
     ) -> Result<()>;
 
     /// The first two argument aren't mutated but creation of Java ByteBuffer
     /// requires the underlying bytes to be mutable.
     #[allow(unused)]
     #[cxx_name = "aesDecrypt"]
     fn decrypt(
       key: &mut [u8],
       sealed_data: &mut [u8],
       plaintext: &mut [u8],
     ) -> Result<()>;
   }
 
   // Comm Services Auth Metadata Emission
   #[namespace = "comm"]
   unsafe extern "C++" {
     include!("RustCSAMetadataEmitter.h");
 
     #[allow(unused)]
     #[cxx_name = "sendAuthMetadataToJS"]
     fn send_auth_metadata_to_js(
       access_token: String,
       user_id: String,
     ) -> Result<()>;
   }
 
   // Backup
   extern "Rust" {
     #[cxx_name = "startBackupHandler"]
     fn start_backup_handler() -> Result<()>;
     #[cxx_name = "stopBackupHandler"]
     fn stop_backup_handler() -> Result<()>;
 
     #[cxx_name = "triggerBackupFileUpload"]
     fn trigger_backup_file_upload();
 
     #[cxx_name = "createBackup"]
     fn create_backup_sync(
       backup_id: String,
       backup_secret: String,
       pickle_key: String,
       pickled_account: String,
       user_data: String,
       promise_id: u32,
     );
 
     #[cxx_name = "restoreBackup"]
     fn restore_backup_sync(backup_secret: String, promise_id: u32);
   }
 
   // Secure store
   #[namespace = "comm"]
   unsafe extern "C++" {
     include!("RustSecureStore.h");
 
     #[allow(unused)]
     #[cxx_name = "secureStoreSet"]
     fn secure_store_set(key: &str, value: String) -> Result<()>;
 
     #[cxx_name = "secureStoreGet"]
     fn secure_store_get(key: &str) -> Result<String>;
   }
 
   // C++ Backup creation
   #[namespace = "comm"]
   unsafe extern "C++" {
     include!("RustBackupExecutor.h");
 
     #[allow(unused)]
     #[cxx_name = "getBackupDirectoryPath"]
     fn get_backup_directory_path() -> Result<String>;
 
     #[allow(unused)]
     #[cxx_name = "getBackupFilePath"]
     fn get_backup_file_path(
       backup_id: &str,
       is_attachments: bool,
     ) -> Result<String>;
 
     #[allow(unused)]
     #[cxx_name = "getBackupLogFilePath"]
     fn get_backup_log_file_path(
       backup_id: &str,
       log_id: &str,
       is_attachments: bool,
     ) -> Result<String>;
 
     #[allow(unused)]
     #[cxx_name = "getBackupUserKeysFilePath"]
     fn get_backup_user_keys_file_path(backup_id: &str) -> Result<String>;
 
     #[cxx_name = "createMainCompaction"]
     fn create_main_compaction(backup_id: String) -> Result<()>;
 
     #[allow(unused)]
     #[cxx_name = "restoreFromMainCompaction"]
     fn restore_from_main_compaction(
       main_compaction_path: String,
       main_compaction_encryption_key: String,
     ) -> Result<()>;
 
     #[allow(unused)]
     #[cxx_name = "restoreFromBackupLog"]
     fn restore_from_backup_log(backup_log: Vec<u8>) -> Result<()>;
   }
 }
 
 fn handle_string_result_as_callback<E>(
   result: Result<String, E>,
   promise_id: u32,
 ) where
   E: std::fmt::Display,
 {
   match result {
     Err(e) => string_callback(e.to_string(), promise_id, "".to_string()),
     Ok(r) => string_callback("".to_string(), promise_id, r),
   }
 }
 
 fn handle_void_result_as_callback<E>(result: Result<(), E>, promise_id: u32)
 where
   E: std::fmt::Display,
 {
   match result {
     Err(e) => void_callback(e.to_string(), promise_id),
     Ok(_) => void_callback("".to_string(), promise_id),
   }
 }
 
 fn handle_bool_result_as_callback<E>(result: Result<bool, E>, promise_id: u32)
 where
   E: std::fmt::Display,
 {
   match result {
     Err(e) => bool_callback(e.to_string(), promise_id, false),
     Ok(r) => bool_callback("".to_string(), promise_id, r),
   }
 }
 
 fn generate_nonce(promise_id: u32) {
   RUNTIME.spawn(async move {
     let result = fetch_nonce().await;
     handle_string_result_as_callback(result, promise_id);
   });
 }
 
 async fn fetch_nonce() -> Result<String, Error> {
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
   let nonce = identity_client
     .generate_nonce(Empty {})
     .await?
     .into_inner()
     .nonce;
   Ok(nonce)
 }
 
 fn version_supported(promise_id: u32) {
   RUNTIME.spawn(async move {
     let result = version_supported_helper().await;
     handle_bool_result_as_callback(result, promise_id);
   });
 }
 
 async fn version_supported_helper() -> Result<bool, Error> {
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
   let response = identity_client.ping(Empty {}).await;
   match response {
     Ok(_) => Ok(true),
     Err(e) => {
       if grpc_clients::error::is_version_unsupported(&e) {
         Ok(false)
       } else {
         Err(e.into())
       }
     }
   }
 }
 
 fn get_keyserver_keys(
   user_id: String,
   device_id: String,
   access_token: String,
   keyserver_id: String,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let get_keyserver_keys_request = OutboundKeysForUserRequest {
       user_id: keyserver_id,
     };
     let auth_info = AuthInfo {
       access_token,
       user_id,
       device_id,
     };
     let result =
       get_keyserver_keys_helper(get_keyserver_keys_request, auth_info).await;
     handle_string_result_as_callback(result, promise_id);
   });
 }
 
 async fn get_keyserver_keys_helper(
   get_keyserver_keys_request: OutboundKeysForUserRequest,
   auth_info: AuthInfo,
 ) -> Result<String, Error> {
   let mut identity_client = get_auth_client(
     IDENTITY_SOCKET_ADDR,
     auth_info.user_id,
     auth_info.device_id,
     auth_info.access_token,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
   let response = identity_client
     .get_keyserver_keys(get_keyserver_keys_request)
     .await?
     .into_inner();
 
   let keyserver_keys = OutboundKeyInfoResponse::try_from(response)?;
 
   Ok(serde_json::to_string(&keyserver_keys)?)
 }
 
 struct AuthInfo {
   user_id: String,
   device_id: String,
   access_token: String,
 }
 
 #[instrument]
-fn register_user(
+fn register_password_user(
   username: String,
   password: String,
   key_payload: String,
   key_payload_signature: String,
   content_prekey: String,
   content_prekey_signature: String,
   notif_prekey: String,
   notif_prekey_signature: String,
   content_one_time_keys: Vec<String>,
   notif_one_time_keys: Vec<String>,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let password_user_info = PasswordUserInfo {
       username,
       password,
       key_payload,
       key_payload_signature,
       content_prekey,
       content_prekey_signature,
       notif_prekey,
       notif_prekey_signature,
       content_one_time_keys,
       notif_one_time_keys,
     };
-    let result = register_user_helper(password_user_info).await;
+    let result = register_password_user_helper(password_user_info).await;
     handle_string_result_as_callback(result, promise_id);
   });
 }
 
 struct PasswordUserInfo {
   username: String,
   password: String,
   key_payload: String,
   key_payload_signature: String,
   content_prekey: String,
   content_prekey_signature: String,
   notif_prekey: String,
   notif_prekey_signature: String,
   content_one_time_keys: Vec<String>,
   notif_one_time_keys: Vec<String>,
 }
 
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct UserIDAndDeviceAccessToken {
   #[serde(rename = "userID")]
   user_id: String,
   access_token: String,
 }
 
 impl From<AuthResponse> for UserIDAndDeviceAccessToken {
   fn from(value: AuthResponse) -> Self {
     let AuthResponse {
       user_id,
       access_token,
     } = value;
     Self {
       user_id,
       access_token,
     }
   }
 }
 
-async fn register_user_helper(
+async fn register_password_user_helper(
   password_user_info: PasswordUserInfo,
 ) -> Result<String, Error> {
   let mut client_registration = Registration::new();
   let opaque_registration_request = client_registration
     .start(&password_user_info.password)
     .map_err(handle_error)?;
   let registration_start_request = RegistrationStartRequest {
     opaque_registration_request,
     username: password_user_info.username,
     device_key_upload: Some(DeviceKeyUpload {
       device_key_info: Some(IdentityKeyInfo {
         payload: password_user_info.key_payload,
         payload_signature: password_user_info.key_payload_signature,
         social_proof: None,
       }),
       content_upload: Some(Prekey {
         prekey: password_user_info.content_prekey,
         prekey_signature: password_user_info.content_prekey_signature,
       }),
       notif_upload: Some(Prekey {
         prekey: password_user_info.notif_prekey,
         prekey_signature: password_user_info.notif_prekey_signature,
       }),
       one_time_content_prekeys: password_user_info.content_one_time_keys,
       one_time_notif_prekeys: password_user_info.notif_one_time_keys,
       device_type: DEVICE_TYPE.into(),
     }),
   };
 
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
   let response = identity_client
     .register_password_user_start(registration_start_request)
     .await?;
 
   // We need to get the load balancer cookie from from the response and send it
   // in the subsequent request to ensure it is routed to the same identity
   // service instance as the first request
   let cookie = response
     .metadata()
     .get(RESPONSE_METADATA_COOKIE_KEY)
     .cloned();
 
   let registration_start_response = response.into_inner();
 
   let opaque_registration_upload = client_registration
     .finish(
       &password_user_info.password,
       &registration_start_response.opaque_registration_response,
     )
     .map_err(handle_error)?;
 
   let registration_finish_request = RegistrationFinishRequest {
     session_id: registration_start_response.session_id,
     opaque_registration_upload,
   };
 
   let mut finish_request = Request::new(registration_finish_request);
 
   // Cookie won't be available in local dev environments
   if let Some(cookie_metadata) = cookie {
     finish_request
       .metadata_mut()
       .insert(REQUEST_METADATA_COOKIE_KEY, cookie_metadata);
   }
 
   let registration_finish_response = identity_client
     .register_password_user_finish(finish_request)
     .await?
     .into_inner();
   let user_id_and_access_token =
     UserIDAndDeviceAccessToken::from(registration_finish_response);
   Ok(serde_json::to_string(&user_id_and_access_token)?)
 }
 
 #[instrument]
 fn log_in_password_user(
   username: String,
   password: String,
   key_payload: String,
   key_payload_signature: String,
   content_prekey: String,
   content_prekey_signature: String,
   notif_prekey: String,
   notif_prekey_signature: String,
   content_one_time_keys: Vec<String>,
   notif_one_time_keys: Vec<String>,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let password_user_info = PasswordUserInfo {
       username,
       password,
       key_payload,
       key_payload_signature,
       content_prekey,
       content_prekey_signature,
       notif_prekey,
       notif_prekey_signature,
       content_one_time_keys,
       notif_one_time_keys,
     };
     let result = log_in_password_user_helper(password_user_info).await;
     handle_string_result_as_callback(result, promise_id);
   });
 }
 
 async fn log_in_password_user_helper(
   password_user_info: PasswordUserInfo,
 ) -> Result<String, Error> {
   let mut client_login = Login::new();
   let opaque_login_request = client_login
     .start(&password_user_info.password)
     .map_err(handle_error)?;
   let login_start_request = OpaqueLoginStartRequest {
     opaque_login_request,
     username: password_user_info.username,
     device_key_upload: Some(DeviceKeyUpload {
       device_key_info: Some(IdentityKeyInfo {
         payload: password_user_info.key_payload,
         payload_signature: password_user_info.key_payload_signature,
         social_proof: None,
       }),
       content_upload: Some(Prekey {
         prekey: password_user_info.content_prekey,
         prekey_signature: password_user_info.content_prekey_signature,
       }),
       notif_upload: Some(Prekey {
         prekey: password_user_info.notif_prekey,
         prekey_signature: password_user_info.notif_prekey_signature,
       }),
       one_time_content_prekeys: password_user_info.content_one_time_keys,
       one_time_notif_prekeys: password_user_info.notif_one_time_keys,
       device_type: DEVICE_TYPE.into(),
     }),
   };
 
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let response = identity_client
     .log_in_password_user_start(login_start_request)
     .await?;
 
   // We need to get the load balancer cookie from from the response and send it
   // in the subsequent request to ensure it is routed to the same identity
   // service instance as the first request
   let cookie = response
     .metadata()
     .get(RESPONSE_METADATA_COOKIE_KEY)
     .cloned();
 
   let login_start_response = response.into_inner();
 
   let opaque_login_upload = client_login
     .finish(&login_start_response.opaque_login_response)
     .map_err(handle_error)?;
 
   let login_finish_request = OpaqueLoginFinishRequest {
     session_id: login_start_response.session_id,
     opaque_login_upload,
   };
 
   let mut finish_request = Request::new(login_finish_request);
 
   // Cookie won't be available in local dev environments
   if let Some(cookie_metadata) = cookie {
     finish_request
       .metadata_mut()
       .insert(REQUEST_METADATA_COOKIE_KEY, cookie_metadata);
   }
 
   let login_finish_response = identity_client
     .log_in_password_user_finish(finish_request)
     .await?
     .into_inner();
   let user_id_and_access_token =
     UserIDAndDeviceAccessToken::from(login_finish_response);
   Ok(serde_json::to_string(&user_id_and_access_token)?)
 }
 
 struct WalletUserInfo {
   siwe_message: String,
   siwe_signature: String,
   key_payload: String,
   key_payload_signature: String,
   content_prekey: String,
   content_prekey_signature: String,
   notif_prekey: String,
   notif_prekey_signature: String,
   content_one_time_keys: Vec<String>,
   notif_one_time_keys: Vec<String>,
 }
 
 #[instrument]
 fn log_in_wallet_user(
   siwe_message: String,
   siwe_signature: String,
   key_payload: String,
   key_payload_signature: String,
   content_prekey: String,
   content_prekey_signature: String,
   notif_prekey: String,
   notif_prekey_signature: String,
   content_one_time_keys: Vec<String>,
   notif_one_time_keys: Vec<String>,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let wallet_user_info = WalletUserInfo {
       siwe_message,
       siwe_signature,
       key_payload,
       key_payload_signature,
       content_prekey,
       content_prekey_signature,
       notif_prekey,
       notif_prekey_signature,
       content_one_time_keys,
       notif_one_time_keys,
     };
     let result = log_in_wallet_user_helper(wallet_user_info).await;
     handle_string_result_as_callback(result, promise_id);
   });
 }
 
 async fn log_in_wallet_user_helper(
   wallet_user_info: WalletUserInfo,
 ) -> Result<String, Error> {
   let login_request = WalletAuthRequest {
     siwe_message: wallet_user_info.siwe_message,
     siwe_signature: wallet_user_info.siwe_signature,
     device_key_upload: Some(DeviceKeyUpload {
       device_key_info: Some(IdentityKeyInfo {
         payload: wallet_user_info.key_payload,
         payload_signature: wallet_user_info.key_payload_signature,
         social_proof: None, // The SIWE message and signature are the social proof
       }),
       content_upload: Some(Prekey {
         prekey: wallet_user_info.content_prekey,
         prekey_signature: wallet_user_info.content_prekey_signature,
       }),
       notif_upload: Some(Prekey {
         prekey: wallet_user_info.notif_prekey,
         prekey_signature: wallet_user_info.notif_prekey_signature,
       }),
       one_time_content_prekeys: wallet_user_info.content_one_time_keys,
       one_time_notif_prekeys: wallet_user_info.notif_one_time_keys,
       device_type: DEVICE_TYPE.into(),
     }),
   };
 
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let login_response = identity_client
     .log_in_wallet_user(login_request)
     .await?
     .into_inner();
 
   let user_id_and_access_token =
     UserIDAndDeviceAccessToken::from(login_response);
   Ok(serde_json::to_string(&user_id_and_access_token)?)
 }
 
 struct UpdatePasswordInfo {
   user_id: String,
   device_id: String,
   access_token: String,
   password: String,
 }
 
 fn update_user_password(
   user_id: String,
   device_id: String,
   access_token: String,
   password: String,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let update_password_info = UpdatePasswordInfo {
       access_token,
       user_id,
       device_id,
       password,
     };
     let result = update_user_password_helper(update_password_info).await;
     handle_void_result_as_callback(result, promise_id);
   });
 }
 
 async fn update_user_password_helper(
   update_password_info: UpdatePasswordInfo,
 ) -> Result<(), Error> {
   let mut client_registration = Registration::new();
   let opaque_registration_request = client_registration
     .start(&update_password_info.password)
     .map_err(handle_error)?;
   let update_password_start_request = UpdateUserPasswordStartRequest {
     opaque_registration_request,
   };
   let mut identity_client = get_auth_client(
     IDENTITY_SOCKET_ADDR,
     update_password_info.user_id,
     update_password_info.device_id,
     update_password_info.access_token,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let response = identity_client
     .update_user_password_start(update_password_start_request)
     .await?;
 
   // We need to get the load balancer cookie from from the response and send it
   // in the subsequent request to ensure it is routed to the same identity
   // service instance as the first request
   let cookie = response
     .metadata()
     .get(RESPONSE_METADATA_COOKIE_KEY)
     .cloned();
 
   let update_password_start_response = response.into_inner();
 
   let opaque_registration_upload = client_registration
     .finish(
       &update_password_info.password,
       &update_password_start_response.opaque_registration_response,
     )
     .map_err(handle_error)?;
 
   let update_password_finish_request = UpdateUserPasswordFinishRequest {
     session_id: update_password_start_response.session_id,
     opaque_registration_upload,
   };
 
   let mut finish_request = Request::new(update_password_finish_request);
 
   // Cookie won't be available in local dev environments
   if let Some(cookie_metadata) = cookie {
     finish_request
       .metadata_mut()
       .insert(REQUEST_METADATA_COOKIE_KEY, cookie_metadata);
   }
 
   identity_client
     .update_user_password_finish(finish_request)
     .await?;
 
   Ok(())
 }
 
 fn delete_user(
   user_id: String,
   device_id: String,
   access_token: String,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let auth_info = AuthInfo {
       access_token,
       user_id,
       device_id,
     };
     let result = delete_user_helper(auth_info).await;
     handle_void_result_as_callback(result, promise_id);
   });
 }
 
 async fn delete_user_helper(auth_info: AuthInfo) -> Result<(), Error> {
   let mut identity_client = get_auth_client(
     IDENTITY_SOCKET_ADDR,
     auth_info.user_id,
     auth_info.device_id,
     auth_info.access_token,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
   identity_client.delete_user(Empty {}).await?;
 
   Ok(())
 }
 
 struct GetOutboundKeysRequestInfo {
   user_id: String,
 }
 
 struct GetInboundKeysRequestInfo {
   user_id: String,
 }
 
 // This struct should not be altered without also updating
 // OutboundKeyInfoResponse in lib/types/identity-service-types.js
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct OutboundKeyInfoResponse {
   pub payload: String,
   pub payload_signature: String,
   pub social_proof: Option<String>,
   pub content_prekey: String,
   pub content_prekey_signature: String,
   pub notif_prekey: String,
   pub notif_prekey_signature: String,
   pub one_time_content_prekey: Option<String>,
   pub one_time_notif_prekey: Option<String>,
 }
 
 // This struct should not be altered without also updating
 // InboundKeyInfoResponse in lib/types/identity-service-types.js
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct InboundKeyInfoResponse {
   pub payload: String,
   pub payload_signature: String,
   pub social_proof: Option<String>,
   pub content_prekey: String,
   pub content_prekey_signature: String,
   pub notif_prekey: String,
   pub notif_prekey_signature: String,
 }
 
 impl TryFrom<OutboundKeyInfo> for OutboundKeyInfoResponse {
   type Error = Error;
 
   fn try_from(key_info: OutboundKeyInfo) -> Result<Self, Error> {
     let identity_info =
       key_info.identity_info.ok_or(Error::MissingResponseData)?;
 
     let IdentityKeyInfo {
       payload,
       payload_signature,
       social_proof,
     } = identity_info;
 
     let content_prekey =
       key_info.content_prekey.ok_or(Error::MissingResponseData)?;
 
     let Prekey {
       prekey: content_prekey_value,
       prekey_signature: content_prekey_signature,
     } = content_prekey;
 
     let notif_prekey =
       key_info.notif_prekey.ok_or(Error::MissingResponseData)?;
 
     let Prekey {
       prekey: notif_prekey_value,
       prekey_signature: notif_prekey_signature,
     } = notif_prekey;
 
     let one_time_content_prekey = key_info.one_time_content_prekey;
     let one_time_notif_prekey = key_info.one_time_notif_prekey;
 
     Ok(Self {
       payload,
       payload_signature,
       social_proof,
       content_prekey: content_prekey_value,
       content_prekey_signature,
       notif_prekey: notif_prekey_value,
       notif_prekey_signature,
       one_time_content_prekey,
       one_time_notif_prekey,
     })
   }
 }
 
 impl TryFrom<KeyserverKeysResponse> for OutboundKeyInfoResponse {
   type Error = Error;
 
   fn try_from(response: KeyserverKeysResponse) -> Result<Self, Error> {
     let key_info = response.keyserver_info.ok_or(Error::MissingResponseData)?;
     Self::try_from(key_info)
   }
 }
 
 fn get_outbound_keys_for_user(
   auth_user_id: String,
   auth_device_id: String,
   auth_access_token: String,
   user_id: String,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let get_outbound_keys_request_info = GetOutboundKeysRequestInfo { user_id };
     let auth_info = AuthInfo {
       access_token: auth_access_token,
       user_id: auth_user_id,
       device_id: auth_device_id,
     };
     let result = get_outbound_keys_for_user_helper(
       get_outbound_keys_request_info,
       auth_info,
     )
     .await;
     handle_string_result_as_callback(result, promise_id);
   });
 }
 
 async fn get_outbound_keys_for_user_helper(
   get_outbound_keys_request_info: GetOutboundKeysRequestInfo,
   auth_info: AuthInfo,
 ) -> Result<String, Error> {
   let mut identity_client = get_auth_client(
     IDENTITY_SOCKET_ADDR,
     auth_info.user_id,
     auth_info.device_id,
     auth_info.access_token,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
   let response = identity_client
     .get_outbound_keys_for_user(OutboundKeysForUserRequest {
       user_id: get_outbound_keys_request_info.user_id,
     })
     .await?
     .into_inner();
 
   let outbound_key_info: Vec<OutboundKeyInfoResponse> = response
     .devices
     .into_values()
     .map(OutboundKeyInfoResponse::try_from)
     .collect::<Result<Vec<_>, _>>()?;
 
   Ok(serde_json::to_string(&outbound_key_info)?)
 }
 
 impl TryFrom<InboundKeyInfo> for InboundKeyInfoResponse {
   type Error = Error;
 
   fn try_from(key_info: InboundKeyInfo) -> Result<Self, Error> {
     let identity_info =
       key_info.identity_info.ok_or(Error::MissingResponseData)?;
 
     let IdentityKeyInfo {
       payload,
       payload_signature,
       social_proof,
     } = identity_info;
 
     let content_prekey =
       key_info.content_prekey.ok_or(Error::MissingResponseData)?;
 
     let Prekey {
       prekey: content_prekey_value,
       prekey_signature: content_prekey_signature,
     } = content_prekey;
 
     let notif_prekey =
       key_info.notif_prekey.ok_or(Error::MissingResponseData)?;
 
     let Prekey {
       prekey: notif_prekey_value,
       prekey_signature: notif_prekey_signature,
     } = notif_prekey;
 
     Ok(Self {
       payload,
       payload_signature,
       social_proof,
       content_prekey: content_prekey_value,
       content_prekey_signature,
       notif_prekey: notif_prekey_value,
       notif_prekey_signature,
     })
   }
 }
 
 fn get_inbound_keys_for_user(
   auth_user_id: String,
   auth_device_id: String,
   auth_access_token: String,
   user_id: String,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let get_inbound_keys_request_info = GetInboundKeysRequestInfo { user_id };
     let auth_info = AuthInfo {
       access_token: auth_access_token,
       user_id: auth_user_id,
       device_id: auth_device_id,
     };
     let result = get_inbound_keys_for_user_helper(
       get_inbound_keys_request_info,
       auth_info,
     )
     .await;
     handle_string_result_as_callback(result, promise_id);
   });
 }
 
 async fn get_inbound_keys_for_user_helper(
   get_inbound_keys_request_info: GetInboundKeysRequestInfo,
   auth_info: AuthInfo,
 ) -> Result<String, Error> {
   let mut identity_client = get_auth_client(
     IDENTITY_SOCKET_ADDR,
     auth_info.user_id,
     auth_info.device_id,
     auth_info.access_token,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
   let response = identity_client
     .get_inbound_keys_for_user(InboundKeysForUserRequest {
       user_id: get_inbound_keys_request_info.user_id,
     })
     .await?
     .into_inner();
 
   let inbound_key_info: Vec<InboundKeyInfoResponse> = response
     .devices
     .into_values()
     .map(InboundKeyInfoResponse::try_from)
     .collect::<Result<Vec<_>, _>>()?;
 
   Ok(serde_json::to_string(&inbound_key_info)?)
 }
 
 fn refresh_user_prekeys(
   auth_user_id: String,
   auth_device_id: String,
   auth_access_token: String,
   content_prekey: String,
   content_prekey_signature: String,
   notif_prekey: String,
   notif_prekey_signature: String,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let refresh_request = RefreshUserPrekeysRequest {
       new_content_prekeys: Some(Prekey {
         prekey: content_prekey,
         prekey_signature: content_prekey_signature,
       }),
       new_notif_prekeys: Some(Prekey {
         prekey: notif_prekey,
         prekey_signature: notif_prekey_signature,
       }),
     };
 
     let auth_info = AuthInfo {
       access_token: auth_access_token,
       user_id: auth_user_id,
       device_id: auth_device_id,
     };
     let result = refresh_user_prekeys_helper(refresh_request, auth_info).await;
     handle_void_result_as_callback(result, promise_id);
   });
 }
 
 async fn refresh_user_prekeys_helper(
   refresh_request: RefreshUserPrekeysRequest,
   auth_info: AuthInfo,
 ) -> Result<(), Error> {
   get_auth_client(
     IDENTITY_SOCKET_ADDR,
     auth_info.user_id,
     auth_info.device_id,
     auth_info.access_token,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?
   .refresh_user_prekeys(refresh_request)
   .await?;
 
   Ok(())
 }
 
 #[instrument]
 fn upload_one_time_keys(
   auth_user_id: String,
   auth_device_id: String,
   auth_access_token: String,
   content_one_time_keys: Vec<String>,
   notif_one_time_keys: Vec<String>,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let upload_request = UploadOneTimeKeysRequest {
       content_one_time_prekeys: content_one_time_keys,
       notif_one_time_prekeys: notif_one_time_keys,
     };
     let auth_info = AuthInfo {
       access_token: auth_access_token,
       user_id: auth_user_id,
       device_id: auth_device_id,
     };
     let result = upload_one_time_keys_helper(auth_info, upload_request).await;
     handle_void_result_as_callback(result, promise_id);
   });
 }
 
 async fn upload_one_time_keys_helper(
   auth_info: AuthInfo,
   upload_request: UploadOneTimeKeysRequest,
 ) -> Result<(), Error> {
   let mut identity_client = get_auth_client(
     IDENTITY_SOCKET_ADDR,
     auth_info.user_id,
     auth_info.device_id,
     auth_info.access_token,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   identity_client.upload_one_time_keys(upload_request).await?;
 
   Ok(())
 }
 
 fn get_device_list_for_user(
   auth_user_id: String,
   auth_device_id: String,
   auth_access_token: String,
   user_id: String,
   since_timestamp: i64,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let auth_info = AuthInfo {
       access_token: auth_access_token,
       user_id: auth_user_id,
       device_id: auth_device_id,
     };
     let since_timestamp = Option::from(since_timestamp).filter(|&t| t > 0);
     let result =
       get_device_list_for_user_helper(auth_info, user_id, since_timestamp)
         .await;
     handle_string_result_as_callback(result, promise_id);
   });
 }
 
 async fn get_device_list_for_user_helper(
   auth_info: AuthInfo,
   user_id: String,
   since_timestamp: Option<i64>,
 ) -> Result<String, Error> {
   let mut identity_client = get_auth_client(
     IDENTITY_SOCKET_ADDR,
     auth_info.user_id,
     auth_info.device_id,
     auth_info.access_token,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let response = identity_client
     .get_device_list_for_user(GetDeviceListRequest {
       user_id,
       since_timestamp,
     })
     .await?
     .into_inner();
 
   let payload = serde_json::to_string(&response.device_list_updates)?;
   Ok(payload)
 }
 
 fn update_device_list(
   auth_user_id: String,
   auth_device_id: String,
   auth_access_token: String,
   update_payload: String,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let auth_info = AuthInfo {
       access_token: auth_access_token,
       user_id: auth_user_id,
       device_id: auth_device_id,
     };
     let result = update_device_list_helper(auth_info, update_payload).await;
     handle_void_result_as_callback(result, promise_id);
   });
 }
 
 async fn update_device_list_helper(
   auth_info: AuthInfo,
   update_payload: String,
 ) -> Result<(), Error> {
   let mut identity_client = get_auth_client(
     IDENTITY_SOCKET_ADDR,
     auth_info.user_id,
     auth_info.device_id,
     auth_info.access_token,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let update_request = UpdateDeviceListRequest {
     new_device_list: update_payload,
   };
 
   identity_client
     .update_device_list_for_user(update_request)
     .await?;
 
   Ok(())
 }
 
 fn upload_secondary_device_keys_and_log_in(
   user_id: String,
   challenge_response: String,
   key_payload: String,
   key_payload_signature: String,
   content_prekey: String,
   content_prekey_signature: String,
   notif_prekey: String,
   notif_prekey_signature: String,
   content_one_time_keys: Vec<String>,
   notif_one_time_keys: Vec<String>,
   promise_id: u32,
 ) {
   RUNTIME.spawn(async move {
     let device_key_upload = DeviceKeyUpload {
       device_key_info: Some(IdentityKeyInfo {
         payload: key_payload,
         payload_signature: key_payload_signature,
         social_proof: None,
       }),
       content_upload: Some(Prekey {
         prekey: content_prekey,
         prekey_signature: content_prekey_signature,
       }),
       notif_upload: Some(Prekey {
         prekey: notif_prekey,
         prekey_signature: notif_prekey_signature,
       }),
       one_time_content_prekeys: content_one_time_keys,
       one_time_notif_prekeys: notif_one_time_keys,
       device_type: DEVICE_TYPE.into(),
     };
 
     let result = upload_secondary_device_keys_and_log_in_helper(
       user_id,
       challenge_response,
       device_key_upload,
     )
     .await;
     handle_string_result_as_callback(result, promise_id);
   });
 }
 
 async fn upload_secondary_device_keys_and_log_in_helper(
   user_id: String,
   challenge_response: String,
   device_key_upload: DeviceKeyUpload,
 ) -> Result<String, Error> {
   let mut identity_client = get_unauthenticated_client(
     IDENTITY_SOCKET_ADDR,
     CODE_VERSION,
     DEVICE_TYPE.as_str_name().to_lowercase(),
   )
   .await?;
 
   let request = SecondaryDeviceKeysUploadRequest {
     user_id,
     challenge_response,
     device_key_upload: Some(device_key_upload),
   };
 
   let response = identity_client
     .upload_keys_for_registered_device_and_log_in(request)
     .await?
     .into_inner();
 
   let user_id_and_access_token = UserIDAndDeviceAccessToken::from(response);
   Ok(serde_json::to_string(&user_id_and_access_token)?)
 }
 
 #[derive(
   Debug, derive_more::Display, derive_more::From, derive_more::Error,
 )]
 pub enum Error {
   #[display(fmt = "{}", "_0.message()")]
   TonicGRPC(Status),
   #[display(fmt = "{}", "_0")]
   SerdeJson(serde_json::Error),
   #[display(fmt = "Missing response data")]
   MissingResponseData,
   #[display(fmt = "{}", "_0")]
   GRPClient(grpc_clients::error::Error),
 }
 
 #[cfg(test)]
 mod tests {
   use super::{BACKUP_SOCKET_ADDR, CODE_VERSION, IDENTITY_SOCKET_ADDR};
 
   #[test]
   fn test_code_version_exists() {
     assert!(CODE_VERSION > 0);
   }
 
   #[test]
   fn test_identity_socket_addr_exists() {
     assert!(IDENTITY_SOCKET_ADDR.len() > 0);
     assert!(BACKUP_SOCKET_ADDR.len() > 0);
   }
 }
diff --git a/native/schema/CommRustModuleSchema.js b/native/schema/CommRustModuleSchema.js
index 8488e96ad..8d420f2d4 100644
--- a/native/schema/CommRustModuleSchema.js
+++ b/native/schema/CommRustModuleSchema.js
@@ -1,112 +1,112 @@
 // @flow
 
 'use strict';
 
 import { TurboModuleRegistry } from 'react-native';
 import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport.js';
 
 export interface Spec extends TurboModule {
   +generateNonce: () => Promise<string>;
-  +registerUser: (
+  +registerPasswordUser: (
     username: string,
     password: string,
     keyPayload: string,
     keyPayloadSignature: string,
     contentPrekey: string,
     contentPrekeySignature: string,
     notifPrekey: string,
     notifPrekeySignature: string,
     contentOneTimeKeys: $ReadOnlyArray<string>,
     notifOneTimeKeys: $ReadOnlyArray<string>,
   ) => Promise<string>;
   +logInPasswordUser: (
     username: string,
     password: string,
     keyPayload: string,
     keyPayloadSignature: string,
     contentPrekey: string,
     contentPrekeySignature: string,
     notifPrekey: string,
     notifPrekeySignature: string,
     contentOneTimeKeys: $ReadOnlyArray<string>,
     notifOneTimeKeys: $ReadOnlyArray<string>,
   ) => Promise<string>;
   +logInWalletUser: (
     siweMessage: string,
     siweSignature: string,
     keyPayload: string,
     keyPayloadSignature: string,
     contentPrekey: string,
     contentPrekeySignature: string,
     notifPrekey: string,
     notifPrekeySignature: string,
     contentOneTimeKeys: $ReadOnlyArray<string>,
     notifOneTimeKeys: $ReadOnlyArray<string>,
   ) => Promise<string>;
   +updatePassword: (
     userID: string,
     deviceID: string,
     accessToken: string,
     password: string,
   ) => Promise<void>;
   +deleteUser: (
     userID: string,
     deviceID: string,
     accessToken: string,
   ) => Promise<void>;
   +getOutboundKeysForUser: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     userID: string,
   ) => Promise<string>;
   +getInboundKeysForUser: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     userID: string,
   ) => Promise<string>;
   +versionSupported: () => Promise<boolean>;
   +uploadOneTimeKeys: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     contentOneTimePreKeys: $ReadOnlyArray<string>,
     notifOneTimePreKeys: $ReadOnlyArray<string>,
   ) => Promise<void>;
   +getKeyserverKeys: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     keyserverID: string,
   ) => Promise<string>;
   +getDeviceListForUser: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     userID: string,
     sinceTimestamp: ?number,
   ) => Promise<string>;
   +updateDeviceList: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
     updatePayload: string,
   ) => Promise<void>;
   +uploadSecondaryDeviceKeysAndLogIn: (
     userID: string,
     challengeResponse: string,
     keyPayload: string,
     keyPayloadSignature: string,
     contentPrekey: string,
     contentPrekeySignature: string,
     notifPrekey: string,
     notifPrekeySignature: string,
     contentOneTimeKeys: $ReadOnlyArray<string>,
     notifOneTimeKeys: $ReadOnlyArray<string>,
   ) => Promise<string>;
 }
 
 export default (TurboModuleRegistry.getEnforcing<Spec>(
   'CommRustTurboModule',
 ): Spec);