diff --git a/lib/actions/user-actions.js b/lib/actions/user-actions.js
index 6c09a02dc..5e2bbc30e 100644
--- a/lib/actions/user-actions.js
+++ b/lib/actions/user-actions.js
@@ -1,896 +1,896 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import type {
   CallSingleKeyserverEndpoint,
   CallSingleKeyserverEndpointOptions,
 } from '../keyserver-conn/call-single-keyserver-endpoint.js';
 import {
   extractKeyserverIDFromID,
   sortThreadIDsPerKeyserver,
   sortCalendarQueryPerKeyserver,
 } from '../keyserver-conn/keyserver-call-utils.js';
 import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import { usePreRequestUserState } from '../selectors/account-selectors.js';
 import {
   getOneTimeKeyValuesFromBlob,
   getPrekeyValueFromBlob,
 } from '../shared/crypto-utils.js';
 import { IdentityClientContext } from '../shared/identity-client-context.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import { permissionsAndAuthRelatedRequestTimeout } from '../shared/timeouts.js';
 import type {
   LogInInfo,
   LogInResult,
-  RegisterResult,
-  RegisterInfo,
+  LegacyRegisterResult,
+  LegacyRegisterInfo,
   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 { GetOlmSessionInitializationDataResponse } from '../types/request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from '../types/search-types.js';
 import type { 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 { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
 import { getConfig } from '../utils/config.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { usingCommServicesAccessToken } from '../utils/services-utils.js';
 import sleep from '../utils/sleep.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 keyserverLogOut =
   (
     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('keyserver log_out took more than 500ms');
         })(),
       ]);
     } catch {}
     const currentUserInfo = response ? loggedOutUserInfo : null;
     return { currentUserInfo, preRequestUserState, keyserverIDs };
   };
 
 function useLogOut(): (
   keyserverIDs?: $ReadOnlyArray<string>,
 ) => Promise<LogOutResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
 
   const preRequestUserState = usePreRequestUserState();
   const callKeyserverLogOut = useKeyserverCall(keyserverLogOut);
 
   const commServicesAccessToken = useSelector(
     state => state.commServicesAccessToken,
   );
 
   return React.useCallback(
     async (keyserverIDs?: $ReadOnlyArray<string>) => {
       const identityPromise = (async () => {
         if (!usingCommServicesAccessToken) {
           return;
         }
         invariant(identityClient, 'Identity client should be set');
         try {
           await Promise.race([
             identityClient.logOut(),
             (async () => {
               await sleep(500);
               throw new Error('identity log_out took more than 500ms');
             })(),
           ]);
         } catch {}
       })();
 
       const [{ keyserverIDs: _, ...result }] = await Promise.all([
         callKeyserverLogOut({
           preRequestUserState,
           keyserverIDs,
         }),
         identityPromise,
       ]);
       return {
         ...result,
         preRequestUserState: {
           ...result.preRequestUserState,
           commServicesAccessToken,
         },
       };
     },
     [
       callKeyserverLogOut,
       commServicesAccessToken,
       identityClient,
       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 = { [authoritativeKeyserverID()]: {} };
     const responses = await callKeyserverEndpoint('claim_username', requests, {
       ...claimUsernameCallSingleKeyserverEndpointOptions,
     });
     const response = responses[authoritativeKeyserverID()];
     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 = usePreRequestUserState();
   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 = usePreRequestUserState();
   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');
       }
       if (!identityClient.deleteWalletUser) {
         throw new Error('Delete wallet user method unimplemented');
       }
       return await identityClient.deleteWalletUser();
     })();
     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 legacyKeyserverRegisterActionTypes = Object.freeze({
+  started: 'LEGACY_KEYSERVER_REGISTER_STARTED',
+  success: 'LEGACY_KEYSERVER_REGISTER_SUCCESS',
+  failed: 'LEGACY_KEYSERVER_REGISTER_FAILED',
 });
-const registerCallSingleKeyserverEndpointOptions = {
+const legacyKeyserverRegisterCallSingleKeyserverEndpointOptions = {
   timeout: permissionsAndAuthRelatedRequestTimeout,
 };
-const keyserverRegister =
+const legacyKeyserverRegister =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
   ): ((
-    registerInfo: RegisterInfo,
+    registerInfo: LegacyRegisterInfo,
     options?: CallSingleKeyserverEndpointOptions,
-  ) => Promise<RegisterResult>) =>
+  ) => Promise<LegacyRegisterResult>) =>
   async (registerInfo, options) => {
     const deviceTokenUpdateRequest =
       registerInfo.deviceTokenUpdateRequest[authoritativeKeyserverID()];
     const { preRequestUserInfo, ...rest } = registerInfo;
 
     const response = await callSingleKeyserverEndpoint(
       'create_account',
       {
         ...rest,
         deviceTokenUpdateRequest,
         platformDetails: getConfig().platformDetails,
       },
       {
-        ...registerCallSingleKeyserverEndpointOptions,
+        ...legacyKeyserverRegisterCallSingleKeyserverEndpointOptions,
         ...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: permissionsAndAuthRelatedRequestTimeout,
 };
 const keyserverAuth =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: KeyserverAuthInput) => Promise<KeyserverAuthResult>) =>
   async keyserverAuthInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
 
     const {
       authActionSource,
       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: authActionSource,
       };
     }
 
     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[authoritativeKeyserverID()]?.currentUserInfo,
       calendarResult,
       messagesResult,
       userInfos,
       updatesCurrentAsOf,
       authActionSource: keyserverAuthInfo.authActionSource,
       notAcknowledgedPolicies:
         responses[authoritativeKeyserverID()]?.notAcknowledgedPolicies,
       preRequestUserInfo,
     };
   };
 
 const identityRegisterActionTypes = Object.freeze({
   started: 'IDENTITY_REGISTER_STARTED',
   success: 'IDENTITY_REGISTER_SUCCESS',
   failed: 'IDENTITY_REGISTER_FAILED',
 });
 function useIdentityPasswordRegister(): (
   username: string,
   password: string,
   fid: ?string,
 ) => Promise<IdentityAuthResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   invariant(identityClient, 'Identity client should be set');
   if (!identityClient.registerPasswordUser) {
     throw new Error('Register password user method unimplemented');
   }
   return identityClient.registerPasswordUser;
 }
 function useIdentityWalletRegister(): (
   walletAddress: string,
   siweMessage: string,
   siweSignature: string,
   fid: ?string,
 ) => Promise<IdentityAuthResult> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   invariant(identityClient, 'Identity client should be set');
   if (!identityClient.registerWalletUser) {
     throw new Error('Register wallet user method unimplemented');
   }
   return identityClient.registerWalletUser;
 }
 
 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;
   const preRequestUserState = useSelector(state => state.currentUserInfo);
 
   return React.useCallback(
     (username, password) => {
       if (!identityClient) {
         throw new Error('Identity service client is not initialized');
       }
       return (async () => {
         const result = await identityClient.logInPasswordUser(
           username,
           password,
         );
         return {
           ...result,
           preRequestUserState,
         };
       })();
     },
     [identityClient, preRequestUserState],
   );
 }
 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 legacyLogInActionTypes = Object.freeze({
   started: 'LEGACY_LOG_IN_STARTED',
   success: 'LEGACY_LOG_IN_SUCCESS',
   failed: 'LEGACY_LOG_IN_FAILED',
 });
 const legacyLogInCallSingleKeyserverEndpointOptions = {
   timeout: permissionsAndAuthRelatedRequestTimeout,
 };
 const legacyLogIn =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: LogInInfo) => Promise<LogInResult>) =>
   async logInInfo => {
     const watchedIDs = threadWatcher.getWatchedIDs();
     const {
       authActionSource,
       calendarQuery,
       keyserverIDs: inputKeyserverIDs,
       preRequestUserInfo,
       ...restLogInInfo
     } = logInInfo;
 
     // Eventually the list of keyservers will be fetched from the
     // identity service
     const keyserverIDs = inputKeyserverIDs ?? [authoritativeKeyserverID()];
 
     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: authActionSource,
         watchedIDs: watchedIDsPerKeyserver[keyserverID] ?? [],
         calendarQuery: calendarQueryPerKeyserver[keyserverID],
         platformDetails: getConfig().platformDetails,
       };
     }
 
     const responses: { +[string]: ClientLogInResponse } =
       await callKeyserverEndpoint(
         'log_in',
         requests,
         legacyLogInCallSingleKeyserverEndpointOptions,
       );
 
     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[authoritativeKeyserverID()].currentUserInfo,
       calendarResult,
       messagesResult,
       userInfos,
       updatesCurrentAsOf,
       authActionSource: logInInfo.authActionSource,
       notAcknowledgedPolicies:
         responses[authoritativeKeyserverID()].notAcknowledgedPolicies,
       preRequestUserInfo,
     };
   };
 
 function useLegacyLogIn(): (input: LogInInfo) => Promise<LogInResult> {
   return useKeyserverCall(legacyLogIn);
 }
 
 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 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],
         prekey: getPrekeyValueFromBlob(
           olmInitData.contentInitializationInfo.prekey,
         ),
       },
       notifInitializationInfo: {
         ...olmInitData.notifInitializationInfo,
         oneTimeKey: getOneTimeKeyValuesFromBlob(
           olmInitData.notifInitializationInfo.oneTimeKey,
         )[0],
         prekey: getPrekeyValueFromBlob(
           olmInitData.notifInitializationInfo.prekey,
         ),
       },
     };
   };
 
 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 };
   };
 
 export {
   changeKeyserverUserPasswordActionTypes,
   changeKeyserverUserPassword,
   claimUsernameActionTypes,
   useClaimUsername,
   useDeleteKeyserverAccount,
   deleteKeyserverAccountActionTypes,
   getOlmSessionInitializationDataActionTypes,
   getOlmSessionInitializationData,
   mergeUserInfos,
   legacyLogIn as legacyLogInRawAction,
   identityLogInActionTypes,
   useIdentityPasswordLogIn,
   useIdentityWalletLogIn,
   useLegacyLogIn,
   legacyLogInActionTypes,
   useLogOut,
   logOutActionTypes,
-  keyserverRegister,
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegister,
+  legacyKeyserverRegisterActionTypes,
   searchUsers,
   searchUsersActionTypes,
   exactSearchUser,
   exactSearchUserActionTypes,
   useSetUserSettings,
   setUserSettingsActionTypes,
   useUpdateSubscription,
   updateSubscriptionActionTypes,
   policyAcknowledgment,
   policyAcknowledgmentActionTypes,
   updateUserAvatarActionTypes,
   updateUserAvatar,
   deleteAccountActionTypes,
   useDeleteAccount,
   keyserverAuthActionTypes,
   keyserverAuth as keyserverAuthRawAction,
   identityRegisterActionTypes,
   useIdentityPasswordRegister,
   useIdentityWalletRegister,
   identityGenerateNonceActionTypes,
   useIdentityGenerateNonce,
 };
diff --git a/lib/reducers/calendar-filters-reducer.js b/lib/reducers/calendar-filters-reducer.js
index da119c3e7..c9e20c440 100644
--- a/lib/reducers/calendar-filters-reducer.js
+++ b/lib/reducers/calendar-filters-reducer.js
@@ -1,215 +1,215 @@
 // @flow
 
 import {
   updateCalendarCommunityFilter,
   clearCalendarCommunityFilter,
 } from '../actions/community-actions.js';
 import { legacySiweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   newThreadActionTypes,
   joinThreadActionTypes,
   leaveThreadActionTypes,
   deleteThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   keyserverAuthActionTypes,
   deleteKeyserverAccountActionTypes,
   legacyLogInActionTypes,
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
 } from '../actions/user-actions.js';
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js';
 import {
   filteredThreadIDs,
   nonThreadCalendarFilters,
   nonExcludeDeletedCalendarFilters,
 } from '../selectors/calendar-filter-selectors.js';
 import { threadInFilterList } from '../shared/thread-utils.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import {
   type CalendarFilter,
   defaultCalendarFilters,
   updateCalendarThreadFilter,
   clearCalendarThreadFilter,
   setCalendarDeletedFilter,
   calendarThreadFilterTypes,
 } from '../types/filter-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type { RawThreadInfos, ThreadStore } from '../types/thread-types.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { filterThreadIDsBelongingToCommunity } from '../utils/drawer-utils.react.js';
 
 export default function reduceCalendarFilters(
   state: $ReadOnlyArray<CalendarFilter>,
   action: BaseAction,
   threadStore: ThreadStore,
 ): $ReadOnlyArray<CalendarFilter> {
   if (
     action.type === legacyLogInActionTypes.success ||
     action.type === legacySiweAuthActionTypes.success ||
-    action.type === keyserverRegisterActionTypes.success
+    action.type === legacyKeyserverRegisterActionTypes.success
   ) {
     return defaultCalendarFilters;
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.cookieInvalidated
   ) {
     return removeKeyserverThreadIDsFromFilterList(state, [
       action.payload.keyserverID,
     ]);
   } else if (action.type === deleteKeyserverAccountActionTypes.success) {
     return removeKeyserverThreadIDsFromFilterList(
       state,
       action.payload.keyserverIDs,
     );
   } else if (action.type === keyserverAuthActionTypes.success) {
     const keyserverIDs = Object.keys(action.payload.updatesCurrentAsOf);
     return removeKeyserverThreadIDsFromFilterList(state, keyserverIDs);
   } else if (action.type === updateCalendarThreadFilter) {
     const nonThreadFilters = nonThreadCalendarFilters(state);
     return [
       ...nonThreadFilters,
       {
         type: calendarThreadFilterTypes.THREAD_LIST,
         threadIDs: action.payload.threadIDs,
       },
     ];
   } else if (action.type === clearCalendarThreadFilter) {
     return nonThreadCalendarFilters(state);
   } else if (action.type === setCalendarDeletedFilter) {
     const otherFilters = nonExcludeDeletedCalendarFilters(state);
     if (action.payload.includeDeleted && otherFilters.length === state.length) {
       // Attempting to remove NOT_DELETED filter, but it doesn't exist
       return state;
     } else if (action.payload.includeDeleted) {
       // Removing NOT_DELETED filter
       return otherFilters;
     } else if (otherFilters.length < state.length) {
       // Attempting to add NOT_DELETED filter, but it already exists
       return state;
     } else {
       // Adding NOT_DELETED filter
       return [...state, { type: calendarThreadFilterTypes.NOT_DELETED }];
     }
   } else if (
     action.type === newThreadActionTypes.success ||
     action.type === joinThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === processUpdatesActionType
   ) {
     return updateFilterListFromUpdateInfos(
       state,
       action.payload.updatesResult.newUpdates,
     );
   } else if (action.type === incrementalStateSyncActionType) {
     return updateFilterListFromUpdateInfos(
       state,
       action.payload.updatesResult.newUpdates,
     );
   } else if (action.type === fullStateSyncActionType) {
     return removeDeletedThreadIDsFromFilterList(
       state,
       action.payload.threadInfos,
     );
   } else if (action.type === updateCalendarCommunityFilter) {
     const nonThreadFilters = nonThreadCalendarFilters(state);
 
     const threadIDs = Array.from(
       filterThreadIDsBelongingToCommunity(
         action.payload,
         threadStore.threadInfos,
       ),
     );
     return [
       ...nonThreadFilters,
       {
         type: calendarThreadFilterTypes.THREAD_LIST,
         threadIDs,
       },
     ];
   } else if (action.type === clearCalendarCommunityFilter) {
     const nonThreadFilters = nonThreadCalendarFilters(state);
     return nonThreadFilters;
   }
   return state;
 }
 
 function updateFilterListFromUpdateInfos(
   state: $ReadOnlyArray<CalendarFilter>,
   updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
 ): $ReadOnlyArray<CalendarFilter> {
   const currentlyFilteredIDs: ?$ReadOnlySet<string> = filteredThreadIDs(state);
   if (!currentlyFilteredIDs) {
     return state;
   }
   const newFilteredThreadIDs = updateInfos.reduce(
     (reducedFilteredThreadIDs, update) => {
       const { reduceCalendarThreadFilters } = updateSpecs[update.type];
       return reduceCalendarThreadFilters
         ? reduceCalendarThreadFilters(reducedFilteredThreadIDs, update)
         : reducedFilteredThreadIDs;
     },
     currentlyFilteredIDs,
   );
   if (currentlyFilteredIDs !== newFilteredThreadIDs) {
     return [
       ...nonThreadCalendarFilters(state),
       { type: 'threads', threadIDs: [...newFilteredThreadIDs] },
     ];
   }
   return state;
 }
 
 function filterThreadIDsInFilterList(
   state: $ReadOnlyArray<CalendarFilter>,
   filterCondition: (threadID: string) => boolean,
 ): $ReadOnlyArray<CalendarFilter> {
   const currentlyFilteredIDs = filteredThreadIDs(state);
   if (!currentlyFilteredIDs) {
     return state;
   }
   const filtered = [...currentlyFilteredIDs].filter(filterCondition);
 
   if (filtered.length < currentlyFilteredIDs.size) {
     return [
       ...nonThreadCalendarFilters(state),
       { type: 'threads', threadIDs: filtered },
     ];
   }
   return state;
 }
 
 function removeDeletedThreadIDsFromFilterList(
   state: $ReadOnlyArray<CalendarFilter>,
   threadInfos: RawThreadInfos,
 ): $ReadOnlyArray<CalendarFilter> {
   const filterCondition = (threadID: string) =>
     threadInFilterList(threadInfos[threadID]);
 
   return filterThreadIDsInFilterList(state, filterCondition);
 }
 
 function removeKeyserverThreadIDsFromFilterList(
   state: $ReadOnlyArray<CalendarFilter>,
   keyserverIDs: $ReadOnlyArray<string>,
 ): $ReadOnlyArray<CalendarFilter> {
   const keyserverIDsSet = new Set<string>(keyserverIDs);
   const filterCondition = (threadID: string) =>
     !keyserverIDsSet.has(extractKeyserverIDFromID(threadID));
 
   return filterThreadIDsInFilterList(state, filterCondition);
 }
 
 export {
   filterThreadIDsInFilterList,
   removeDeletedThreadIDsFromFilterList,
   removeKeyserverThreadIDsFromFilterList,
 };
diff --git a/lib/reducers/integrity-reducer.js b/lib/reducers/integrity-reducer.js
index 1762c750d..e65a6753d 100644
--- a/lib/reducers/integrity-reducer.js
+++ b/lib/reducers/integrity-reducer.js
@@ -1,196 +1,196 @@
 // @flow
 
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import { updateIntegrityStoreActionType } from '../actions/integrity-actions.js';
 import { legacySiweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   keyserverAuthActionTypes,
   legacyLogInActionTypes,
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
 } from '../actions/user-actions.js';
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import {
   integrityStoreOpsHandlers,
   type IntegrityStoreOperation,
 } from '../ops/integrity-store-ops.js';
 import type { ThreadStoreOperation } from '../ops/thread-store-ops';
 import type { IntegrityStore, ThreadHashes } from '../types/integrity-types';
 import type { RawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { fullStateSyncActionType } from '../types/socket-types.js';
 import { getMessageForException } from '../utils/errors.js';
 import { assertObjectsAreEqual, hash } from '../utils/objects.js';
 
 const { processStoreOperations: processStoreOps } = integrityStoreOpsHandlers;
 
 function assertIntegrityStoresAreEqual(
   processedIntegrityStore: ThreadHashes,
   expectedIntegrityStore: ThreadHashes,
   location: string,
   onStateDifference?: (message: string) => mixed,
 ) {
   try {
     assertObjectsAreEqual(
       processedIntegrityStore,
       expectedIntegrityStore,
       `ThreadHashes - ${location}`,
     );
   } catch (e) {
     console.log(
       'Error processing IntegrityStore ops',
       processedIntegrityStore,
       expectedIntegrityStore,
     );
     const message = `Error processing IntegrityStore ops ${
       getMessageForException(e) ?? '{no exception message}'
     }`;
     onStateDifference?.(message);
   }
 }
 
 function reduceIntegrityStore(
   state: IntegrityStore,
   action: BaseAction,
   onStateDifference?: (message: string) => mixed,
   threadInfos: {
     +[string]: RawThreadInfo,
   },
   threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 ): {
   +integrityStore: IntegrityStore,
   +integrityStoreOperations: $ReadOnlyArray<IntegrityStoreOperation>,
 } {
   if (action.type === fullStateSyncActionType) {
     const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' };
     const threadHashesArray = Object.entries(state.threadHashes).filter(
       ([key]) => extractKeyserverIDFromID(key) !== action.payload.keyserverID,
     );
     const replaceOperation = {
       type: 'replace_integrity_thread_hashes',
       payload: { threadHashes: Object.fromEntries(threadHashesArray) },
     };
     return {
       integrityStore: {
         threadHashes: processStoreOps(state, [
           removeAllOperation,
           replaceOperation,
         ]).threadHashes,
         threadHashingStatus: 'starting',
       },
       integrityStoreOperations: [removeAllOperation, replaceOperation],
     };
   } else if (
     action.type === legacyLogInActionTypes.success ||
     action.type === legacySiweAuthActionTypes.success ||
-    action.type === keyserverRegisterActionTypes.success ||
+    action.type === legacyKeyserverRegisterActionTypes.success ||
     (action.type === setClientDBStoreActionType &&
       !!action.payload.threadStore &&
       state.threadHashingStatus !== 'completed')
   ) {
     const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' };
     return {
       integrityStore: {
         threadHashes: processStoreOps(state, [removeAllOperation]).threadHashes,
         threadHashingStatus: 'starting',
       },
       integrityStoreOperations: [removeAllOperation],
     };
   } else if (action.type === keyserverAuthActionTypes.success) {
     return {
       integrityStore: {
         threadHashes: processStoreOps(state, []).threadHashes,
         threadHashingStatus: 'starting',
       },
       integrityStoreOperations: [],
     };
   } else if (action.type === setClientDBStoreActionType) {
     assertIntegrityStoresAreEqual(
       action.payload.threadHashes ?? {},
       state.threadHashes,
       action.type,
       onStateDifference,
     );
     return {
       integrityStore: state,
       integrityStoreOperations: [],
     };
   }
 
   let newState = state;
   const integrityOperations: IntegrityStoreOperation[] = [];
   if (action.type === updateIntegrityStoreActionType) {
     if (action.payload.threadIDsToHash) {
       const newThreadHashes = Object.fromEntries(
         action.payload.threadIDsToHash
           .map(id => [id, threadInfos[id]])
           .filter(([, info]) => !!info)
           .map(([id, info]) => [id, hash(info)]),
       );
       const replaceOperation = {
         type: 'replace_integrity_thread_hashes',
         payload: { threadHashes: newThreadHashes },
       };
 
       newState = processStoreOps(state, [replaceOperation]);
       integrityOperations.push(replaceOperation);
     }
     if (action.payload.threadHashingStatus) {
       newState = {
         ...newState,
         threadHashingStatus: action.payload.threadHashingStatus,
       };
     }
   }
   if (threadStoreOperations.length === 0) {
     return {
       integrityStore: newState,
       integrityStoreOperations: integrityOperations,
     };
   }
   let groupedReplaceThreadHashes: ThreadHashes = {};
   let threadHashingStatus = newState.threadHashingStatus;
   for (const operation of threadStoreOperations) {
     if (
       operation.type !== 'replace' &&
       Object.keys(groupedReplaceThreadHashes).length > 0
     ) {
       integrityOperations.push({
         type: 'replace_integrity_thread_hashes',
         payload: { threadHashes: groupedReplaceThreadHashes },
       });
       groupedReplaceThreadHashes = {};
     }
 
     if (operation.type === 'replace') {
       const newIntegrityThreadHash = hash(operation.payload.threadInfo);
       groupedReplaceThreadHashes = {
         ...groupedReplaceThreadHashes,
         [operation.payload.id]: newIntegrityThreadHash,
       };
     } else if (operation.type === 'remove') {
       integrityOperations.push({
         type: 'remove_integrity_thread_hashes',
         payload: { ids: operation.payload.ids },
       });
     } else if (operation.type === 'remove_all') {
       integrityOperations.push({ type: 'remove_all_integrity_thread_hashes' });
       threadHashingStatus = 'completed';
     }
   }
   if (Object.keys(groupedReplaceThreadHashes).length > 0) {
     integrityOperations.push({
       type: 'replace_integrity_thread_hashes',
       payload: { threadHashes: groupedReplaceThreadHashes },
     });
   }
 
   return {
     integrityStore: {
       threadHashes: processStoreOps(newState, integrityOperations).threadHashes,
       threadHashingStatus,
     },
     integrityStoreOperations: integrityOperations,
   };
 }
 
 export { reduceIntegrityStore };
diff --git a/lib/reducers/keyserver-reducer.js b/lib/reducers/keyserver-reducer.js
index fbbda0923..629f7a417 100644
--- a/lib/reducers/keyserver-reducer.js
+++ b/lib/reducers/keyserver-reducer.js
@@ -1,689 +1,689 @@
 // @flow
 
 import { filterThreadIDsInFilterList } from './calendar-filters-reducer.js';
 import { unsupervisedBackgroundActionType } from './lifecycle-state-reducer.js';
 import { updateActivityActionTypes } from '../actions/activity-actions.js';
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import {
   updateLastCommunicatedPlatformDetailsActionType,
   setDeviceTokenActionTypes,
 } from '../actions/device-actions.js';
 import { updateCalendarQueryActionTypes } from '../actions/entry-actions.js';
 import {
   addKeyserverActionType,
   removeKeyserverActionType,
 } from '../actions/keyserver-actions.js';
 import { legacySiweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   identityLogInActionTypes,
   identityRegisterActionTypes,
   keyserverAuthActionTypes,
   logOutActionTypes,
   deleteKeyserverAccountActionTypes,
   deleteAccountActionTypes,
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
   legacyLogInActionTypes,
 } from '../actions/user-actions.js';
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import {
   setNewSessionActionType,
   updateConnectionStatusActionType,
   setLateResponseActionType,
   updateKeyserverReachabilityActionType,
   setConnectionIssueActionType,
   setActiveSessionRecoveryActionType,
 } from '../keyserver-conn/keyserver-conn-types.js';
 import {
   keyserverStoreOpsHandlers,
   type ReplaceKeyserverOperation,
   type RemoveKeyserversOperation,
   type KeyserverStoreOperation,
 } from '../ops/keyserver-store-ops.js';
 import { nonThreadCalendarFilters } from '../selectors/calendar-filter-selectors.js';
 import { queueActivityUpdatesActionType } from '../types/activity-types.js';
 import { defaultCalendarQuery } from '../types/entry-types.js';
 import type {
   KeyserverInfos,
   KeyserverStore,
 } from '../types/keyserver-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { processUpdatesActionType } from '../types/update-types.js';
 import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
 import { getConfig } from '../utils/config.js';
 import { getMessageForException } from '../utils/errors.js';
 import { assertObjectsAreEqual } from '../utils/objects.js';
 import { setURLPrefix } from '../utils/url-utils.js';
 
 function assertKeyserverStoresAreEqual(
   processedKeyserverStore: KeyserverInfos,
   expectedKeyserverStore: KeyserverInfos,
   location: string,
   onStateDifference?: (message: string) => mixed,
 ) {
   try {
     assertObjectsAreEqual(
       processedKeyserverStore,
       expectedKeyserverStore,
       `KeyserverInfos - ${location}`,
     );
   } catch (e) {
     console.log(
       'Error processing KeyserverStore ops',
       processedKeyserverStore,
       expectedKeyserverStore,
     );
     const message = `Error processing KeyserverStore ops ${
       getMessageForException(e) ?? '{no exception message}'
     }`;
     onStateDifference?.(message);
   }
 }
 
 const { processStoreOperations: processStoreOps } = keyserverStoreOpsHandlers;
 
 export default function reduceKeyserverStore(
   state: KeyserverStore,
   action: BaseAction,
   onStateDifference?: (message: string) => mixed,
 ): {
   keyserverStore: KeyserverStore,
   keyserverStoreOperations: $ReadOnlyArray<KeyserverStoreOperation>,
 } {
   if (action.type === addKeyserverActionType) {
     const replaceOperation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: action.payload.keyserverAdminUserID,
         keyserverInfo: {
           ...action.payload.newKeyserverInfo,
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [replaceOperation]),
       keyserverStoreOperations: [replaceOperation],
     };
   } else if (action.type === removeKeyserverActionType) {
     const removeOperation: RemoveKeyserversOperation = {
       type: 'remove_keyservers',
       payload: {
         ids: [action.payload.keyserverAdminUserID],
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [removeOperation]),
       keyserverStoreOperations: [removeOperation],
     };
   } else if (action.type === setNewSessionActionType) {
     const { keyserverID, sessionChange } = action.payload;
     const gotUserCookie = sessionChange.cookie?.startsWith('user=');
     if (!state.keyserverInfos[keyserverID]) {
       if (gotUserCookie) {
         console.log(
           'received sessionChange with user cookie, ' +
             `but keyserver ${keyserverID} is not in KeyserverStore!`,
         );
       }
       return {
         keyserverStore: state,
         keyserverStoreOperations: [],
       };
     }
 
     let newKeyserverInfo = state.keyserverInfos[keyserverID];
     if (sessionChange.cookie !== undefined) {
       newKeyserverInfo = {
         ...newKeyserverInfo,
         cookie: sessionChange.cookie,
         connection: {
           ...newKeyserverInfo.connection,
           activeSessionRecovery: null,
         },
       };
     }
     if (sessionChange.cookieInvalidated) {
       newKeyserverInfo = {
         ...newKeyserverInfo,
         actualizedCalendarQuery: {
           ...newKeyserverInfo.actualizedCalendarQuery,
           filters: nonThreadCalendarFilters(
             newKeyserverInfo.actualizedCalendarQuery.filters,
           ),
         },
         connection: {
           ...newKeyserverInfo.connection,
           queuedActivityUpdates: [],
         },
       };
     }
     if (action.payload.error === 'client_version_unsupported') {
       newKeyserverInfo = {
         ...newKeyserverInfo,
         connection: {
           ...newKeyserverInfo.connection,
           connectionIssue: 'client_version_unsupported',
         },
       };
     }
 
     const operations: ReplaceKeyserverOperation[] = [];
     if (newKeyserverInfo !== state.keyserverInfos[keyserverID]) {
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: newKeyserverInfo,
         },
       });
     }
 
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (
     action.type === legacyLogInActionTypes.success ||
     action.type === legacySiweAuthActionTypes.success ||
     action.type === keyserverAuthActionTypes.success
   ) {
     const { updatesCurrentAsOf } = action.payload;
 
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in updatesCurrentAsOf) {
       const calendarFilters = filterThreadIDsInFilterList(
         action.payload.calendarResult.calendarQuery.filters,
         (threadID: string) =>
           extractKeyserverIDFromID(threadID) === keyserverID,
       );
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             updatesCurrentAsOf: updatesCurrentAsOf[keyserverID],
             lastCommunicatedPlatformDetails: getConfig().platformDetails,
             actualizedCalendarQuery: {
               ...action.payload.calendarResult.calendarQuery,
               filters: calendarFilters,
             },
             connection: {
               ...state.keyserverInfos[keyserverID].connection,
               connectionIssue: null,
               activeSessionRecovery: null,
             },
           },
         },
       });
     }
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (action.type === fullStateSyncActionType) {
     const { keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           actualizedCalendarQuery: action.payload.calendarQuery,
           updatesCurrentAsOf: action.payload.updatesCurrentAsOf,
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === incrementalStateSyncActionType) {
     const { keyserverID } = action.payload;
     let { deviceToken } = state.keyserverInfos[keyserverID];
     for (const update of action.payload.updatesResult.newUpdates) {
       if (
         update.type === updateTypes.BAD_DEVICE_TOKEN &&
         update.deviceToken === state.keyserverInfos[keyserverID].deviceToken
       ) {
         deviceToken = null;
         break;
       }
     }
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           actualizedCalendarQuery: action.payload.calendarQuery,
           updatesCurrentAsOf: action.payload.updatesResult.currentAsOf,
           deviceToken,
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === processUpdatesActionType) {
     const { keyserverID } = action.payload;
     const updatesCurrentAsOf = Math.max(
       action.payload.updatesResult.currentAsOf,
       state.keyserverInfos[keyserverID].updatesCurrentAsOf,
     );
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf,
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === setURLPrefix) {
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: authoritativeKeyserverID(),
         keyserverInfo: {
           ...state.keyserverInfos[authoritativeKeyserverID()],
           urlPrefix: action.payload,
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateLastCommunicatedPlatformDetailsActionType) {
     const { keyserverID, platformDetails } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           lastCommunicatedPlatformDetails: platformDetails,
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
-  } else if (action.type === keyserverRegisterActionTypes.success) {
+  } else if (action.type === legacyKeyserverRegisterActionTypes.success) {
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: authoritativeKeyserverID(),
         keyserverInfo: {
           ...state.keyserverInfos[authoritativeKeyserverID()],
           actualizedCalendarQuery: action.payload.calendarQuery,
           lastCommunicatedPlatformDetails: getConfig().platformDetails,
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateConnectionStatusActionType) {
     const { keyserverID, status } = action.payload;
     if (!state.keyserverInfos[keyserverID]) {
       return {
         keyserverStore: state,
         keyserverStoreOperations: [],
       };
     }
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             status,
             lateResponses: [],
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === unsupervisedBackgroundActionType) {
     const { keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             status: 'disconnected',
             lateResponses: [],
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === queueActivityUpdatesActionType) {
     const { activityUpdates, keyserverID } = action.payload;
     const oldConnection = state.keyserverInfos[keyserverID].connection;
     const connection = {
       ...oldConnection,
       queuedActivityUpdates: [
         ...oldConnection.queuedActivityUpdates.filter(existingUpdate => {
           for (const activityUpdate of activityUpdates) {
             if (
               ((existingUpdate.focus && activityUpdate.focus) ||
                 (existingUpdate.focus === false &&
                   activityUpdate.focus !== undefined)) &&
               existingUpdate.threadID === activityUpdate.threadID
             ) {
               return false;
             }
           }
           return true;
         }),
         ...activityUpdates,
       ],
     };
 
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection,
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateActivityActionTypes.success) {
     const { activityUpdates } = action.payload;
 
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in activityUpdates) {
       const oldConnection = state.keyserverInfos[keyserverID].connection;
       const queuedActivityUpdates = oldConnection.queuedActivityUpdates.filter(
         activityUpdate =>
           !activityUpdates[keyserverID].includes(activityUpdate),
       );
 
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             connection: { ...oldConnection, queuedActivityUpdates },
           },
         },
       });
     }
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success ||
     action.type === identityRegisterActionTypes.success ||
     (action.type === identityLogInActionTypes.success &&
       action.payload.userID !== action.payload.preRequestUserState?.id)
   ) {
     // We want to remove all keyservers but Ashoat's keyserver
     const oldKeyserverInfo = state.keyserverInfos[authoritativeKeyserverID()];
     const oldConnection = oldKeyserverInfo.connection;
     const operations: KeyserverStoreOperation[] = [
       { type: 'remove_all_keyservers' },
     ];
 
     let cookie = oldKeyserverInfo.cookie;
     if (
       action.type === logOutActionTypes.success ||
       action.type === deleteAccountActionTypes.success ||
       cookie?.startsWith('user=')
     ) {
       // To avoid unnecessary rerenders, we won't clear the authoritative
       // keyserver's cookie unless it's a logout or an account deletion, or if
       // the cookie belongs to an actual user (as opposed to an anonymous one)
       cookie = null;
     }
 
     operations.push({
       type: 'replace_keyserver',
       payload: {
         id: authoritativeKeyserverID(),
         keyserverInfo: {
           ...state.keyserverInfos[authoritativeKeyserverID()],
           actualizedCalendarQuery: defaultCalendarQuery(
             getConfig().platformDetails.platform,
           ),
           connection: {
             ...oldConnection,
             connectionIssue: null,
             activeSessionRecovery: null,
             queuedActivityUpdates: [],
             lateResponses: [],
           },
           cookie,
         },
       },
     });
 
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (action.type === deleteKeyserverAccountActionTypes.success) {
     const operations: KeyserverStoreOperation[] = [
       {
         type: 'remove_keyservers',
         payload: { ids: action.payload.keyserverIDs },
       },
     ];
     if (action.payload.keyserverIDs.includes(authoritativeKeyserverID())) {
       const oldConnection =
         state.keyserverInfos[authoritativeKeyserverID()].connection;
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: authoritativeKeyserverID(),
           keyserverInfo: {
             ...state.keyserverInfos[authoritativeKeyserverID()],
             actualizedCalendarQuery: defaultCalendarQuery(
               getConfig().platformDetails.platform,
             ),
             connection: {
               ...oldConnection,
               connectionIssue: null,
               activeSessionRecovery: null,
               queuedActivityUpdates: [],
               lateResponses: [],
             },
             cookie: null,
           },
         },
       });
     }
 
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (action.type === setLateResponseActionType) {
     const { messageID, isLate, keyserverID } = action.payload;
     const lateResponsesSet = new Set<number>(
       state.keyserverInfos[keyserverID].connection.lateResponses,
     );
     if (isLate) {
       lateResponsesSet.add(messageID);
     } else {
       lateResponsesSet.delete(messageID);
     }
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             lateResponses: [...lateResponsesSet],
           },
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateKeyserverReachabilityActionType) {
     const { keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             unreachable: action.payload.visible,
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === setDeviceTokenActionTypes.success) {
     const { deviceTokens } = action.payload;
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in deviceTokens) {
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             deviceToken: deviceTokens[keyserverID],
           },
         },
       });
     }
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (action.type === setConnectionIssueActionType) {
     const { connectionIssue, keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             connectionIssue,
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === setActiveSessionRecoveryActionType) {
     const { activeSessionRecovery, keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             activeSessionRecovery,
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === setClientDBStoreActionType) {
     // Once the functionality is confirmed to work correctly,
     // we will proceed with returning keyserverInfos from the payload.
     assertKeyserverStoresAreEqual(
       action.payload.keyserverInfos ?? {},
       state.keyserverInfos,
       action.type,
       onStateDifference,
     );
     return {
       keyserverStore: state,
       keyserverStoreOperations: [],
     };
   } else if (action.type === updateCalendarQueryActionTypes.success) {
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID of action.payload.keyserverIDs) {
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             actualizedCalendarQuery: {
               ...action.payload.calendarQuery,
               filters: filterThreadIDsInFilterList(
                 action.payload.calendarQuery.filters,
                 (threadID: string) =>
                   extractKeyserverIDFromID(threadID) === keyserverID,
               ),
             },
           },
         },
       });
     }
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   }
 
   return {
     keyserverStore: state,
     keyserverStoreOperations: [],
   };
 }
diff --git a/lib/reducers/master-reducer.js b/lib/reducers/master-reducer.js
index 23fa6005f..bb8cdbbc5 100644
--- a/lib/reducers/master-reducer.js
+++ b/lib/reducers/master-reducer.js
@@ -1,233 +1,233 @@
 // @flow
 
 import { reduceAlertStore } from './alert-reducer.js';
 import { reduceAuxUserStore } from './aux-user-reducer.js';
 import reduceCalendarFilters from './calendar-filters-reducer.js';
 import { reduceCommunityStore } from './community-reducer.js';
 import reduceCustomerServer from './custom-server-reducer.js';
 import reduceDataLoaded from './data-loaded-reducer.js';
 import { reduceDBOpsStore } from './db-ops-reducer.js';
 import { reduceDraftStore } from './draft-reducer.js';
 import reduceEnabledApps from './enabled-apps-reducer.js';
 import { reduceEntryInfos } from './entry-reducer.js';
 import { reduceIntegrityStore } from './integrity-reducer.js';
 import reduceInviteLinks from './invite-links-reducer.js';
 import reduceKeyserverStore from './keyserver-reducer.js';
 import reduceLifecycleState from './lifecycle-state-reducer.js';
 import { reduceLoadingStatuses } from './loading-reducer.js';
 import { reduceMessageStore } from './message-reducer.js';
 import reduceBaseNavInfo from './nav-reducer.js';
 import policiesReducer from './policies-reducer.js';
 import reduceReportStore from './report-store-reducer.js';
 import { reduceSyncedMetadataStore } from './synced-metadata-reducer.js';
 import reduceGlobalThemeInfo from './theme-reducer.js';
 import { reduceThreadActivity } from './thread-activity-reducer.js';
 import { reduceThreadInfos } from './thread-reducer.js';
 import { reduceCurrentUserInfo, reduceUserInfos } from './user-reducer.js';
 import { addKeyserverActionType } from '../actions/keyserver-actions.js';
 import { legacySiweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
   legacyLogInActionTypes,
   keyserverAuthActionTypes,
 } from '../actions/user-actions.js';
 import {
   keyserverStoreOpsHandlers,
   type ReplaceKeyserverOperation,
 } from '../ops/keyserver-store-ops.js';
 import { isStaff } from '../shared/staff-utils.js';
 import type { BaseNavInfo } from '../types/nav-types.js';
 import type { BaseAppState, BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type { StoreOperations } from '../types/store-ops-types.js';
 import { isDev } from '../utils/dev-utils.js';
 
 export default function baseReducer<N: BaseNavInfo, T: BaseAppState<N>>(
   state: T,
   action: BaseAction,
   onStateDifference: (message: string) => mixed,
 ): { state: T, storeOperations: StoreOperations } {
   const { threadStore, newThreadInconsistencies, threadStoreOperations } =
     reduceThreadInfos(state.threadStore, action);
   const { threadInfos } = threadStore;
 
   const [entryStore, newEntryInconsistencies] = reduceEntryInfos(
     state.entryStore,
     action,
     threadInfos,
   );
 
   const onStateDifferenceForStaff = (message: string) => {
     const isCurrentUserStaff = state.currentUserInfo?.id
       ? isStaff(state.currentUserInfo.id)
       : false;
     if (isCurrentUserStaff || isDev) {
       onStateDifference(message);
     }
   };
 
   const [userStore, newUserInconsistencies, userStoreOperations] =
     reduceUserInfos(state.userStore, action);
 
   const newInconsistencies = [
     ...newEntryInconsistencies,
     ...newThreadInconsistencies,
     ...newUserInconsistencies,
   ];
   // Only allow checkpoints to increase if we are connected
   // or if the action is a STATE_SYNC
   const { messageStoreOperations, messageStore: reducedMessageStore } =
     reduceMessageStore(state.messageStore, action, threadInfos);
   let messageStore = reducedMessageStore;
 
   let { keyserverStore, keyserverStoreOperations } = reduceKeyserverStore(
     state.keyserverStore,
     action,
     onStateDifferenceForStaff,
   );
 
   if (
     action.type !== incrementalStateSyncActionType &&
     action.type !== fullStateSyncActionType &&
-    action.type !== keyserverRegisterActionTypes.success &&
+    action.type !== legacyKeyserverRegisterActionTypes.success &&
     action.type !== legacyLogInActionTypes.success &&
     action.type !== legacySiweAuthActionTypes.success &&
     action.type !== keyserverAuthActionTypes.success &&
     action.type !== addKeyserverActionType
   ) {
     const replaceOperations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in keyserverStore.keyserverInfos) {
       if (
         keyserverStore.keyserverInfos[keyserverID].connection.status ===
         'connected'
       ) {
         continue;
       }
       if (
         messageStore.currentAsOf[keyserverID] !==
         state.messageStore.currentAsOf[keyserverID]
       ) {
         messageStore = {
           ...messageStore,
           currentAsOf: {
             ...messageStore.currentAsOf,
             [keyserverID]: state.messageStore.currentAsOf[keyserverID],
           },
         };
       }
       if (
         state.keyserverStore.keyserverInfos[keyserverID] &&
         keyserverStore.keyserverInfos[keyserverID].updatesCurrentAsOf !==
           state.keyserverStore.keyserverInfos[keyserverID].updatesCurrentAsOf
       ) {
         replaceOperations.push({
           type: 'replace_keyserver',
           payload: {
             id: keyserverID,
             keyserverInfo: {
               ...keyserverStore.keyserverInfos[keyserverID],
               updatesCurrentAsOf:
                 state.keyserverStore.keyserverInfos[keyserverID]
                   .updatesCurrentAsOf,
             },
           },
         });
       }
     }
 
     keyserverStore = keyserverStoreOpsHandlers.processStoreOperations(
       keyserverStore,
       replaceOperations,
     );
     keyserverStoreOperations = [
       ...keyserverStoreOperations,
       ...replaceOperations,
     ];
   }
 
   const { draftStore, draftStoreOperations } = reduceDraftStore(
     state.draftStore,
     action,
   );
 
   const { reportStore, reportStoreOperations } = reduceReportStore(
     state.reportStore,
     action,
     newInconsistencies,
   );
 
   const { communityStore, communityStoreOperations } = reduceCommunityStore(
     state.communityStore,
     action,
   );
 
   const { integrityStore, integrityStoreOperations } = reduceIntegrityStore(
     state.integrityStore,
     action,
     onStateDifferenceForStaff,
     threadInfos,
     threadStoreOperations,
   );
 
   const { syncedMetadataStore, syncedMetadataStoreOperations } =
     reduceSyncedMetadataStore(state.syncedMetadataStore, action);
 
   const { auxUserStore, auxUserStoreOperations } = reduceAuxUserStore(
     state.auxUserStore,
     action,
   );
 
   const { threadActivityStore, threadActivityStoreOperations } =
     reduceThreadActivity(state.threadActivityStore, action);
 
   return {
     state: {
       ...state,
       navInfo: reduceBaseNavInfo(state.navInfo, action),
       draftStore,
       entryStore,
       loadingStatuses: reduceLoadingStatuses(state.loadingStatuses, action),
       currentUserInfo: reduceCurrentUserInfo(state.currentUserInfo, action),
       threadStore,
       userStore,
       messageStore,
       calendarFilters: reduceCalendarFilters(
         state.calendarFilters,
         action,
         threadStore,
       ),
       alertStore: reduceAlertStore(state.alertStore, action),
       lifecycleState: reduceLifecycleState(state.lifecycleState, action),
       enabledApps: reduceEnabledApps(state.enabledApps, action),
       reportStore,
       dataLoaded: reduceDataLoaded(state.dataLoaded, action),
       userPolicies: policiesReducer(state.userPolicies, action),
       inviteLinksStore: reduceInviteLinks(state.inviteLinksStore, action),
       keyserverStore,
       integrityStore,
       globalThemeInfo: reduceGlobalThemeInfo(state.globalThemeInfo, action),
       customServer: reduceCustomerServer(state.customServer, action),
       communityStore,
       dbOpsStore: reduceDBOpsStore(state.dbOpsStore, action),
       syncedMetadataStore,
       auxUserStore,
       threadActivityStore,
     },
     storeOperations: {
       draftStoreOperations,
       threadStoreOperations,
       messageStoreOperations,
       reportStoreOperations,
       userStoreOperations,
       keyserverStoreOperations,
       communityStoreOperations,
       integrityStoreOperations,
       syncedMetadataStoreOperations,
       auxUserStoreOperations,
       threadActivityStoreOperations,
     },
   };
 }
diff --git a/lib/reducers/message-reducer.js b/lib/reducers/message-reducer.js
index 058e37361..a09654e77 100644
--- a/lib/reducers/message-reducer.js
+++ b/lib/reducers/message-reducer.js
@@ -1,1723 +1,1723 @@
 // @flow
 
 import invariant from 'invariant';
 import _difference from 'lodash/fp/difference.js';
 import _flow from 'lodash/fp/flow.js';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import _map from 'lodash/fp/map.js';
 import _mapKeys from 'lodash/fp/mapKeys.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _omit from 'lodash/fp/omit.js';
 import _omitBy from 'lodash/fp/omitBy.js';
 import _pickBy from 'lodash/fp/pickBy.js';
 import _uniq from 'lodash/fp/uniq.js';
 
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import {
   createEntryActionTypes,
   saveEntryActionTypes,
   deleteEntryActionTypes,
   restoreEntryActionTypes,
 } from '../actions/entry-actions.js';
 import {
   toggleMessagePinActionTypes,
   fetchMessagesBeforeCursorActionTypes,
   fetchMostRecentMessagesActionTypes,
   sendTextMessageActionTypes,
   sendMultimediaMessageActionTypes,
   sendReactionMessageActionTypes,
   sendEditMessageActionTypes,
   saveMessagesActionType,
   processMessagesActionType,
   messageStorePruneActionType,
   createLocalMessageActionType,
   fetchSingleMostRecentMessagesFromThreadsActionTypes,
 } from '../actions/message-actions.js';
 import { sendMessageReportActionTypes } from '../actions/message-report-actions.js';
 import { legacySiweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   changeThreadSettingsActionTypes,
   deleteThreadActionTypes,
   leaveThreadActionTypes,
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
   changeThreadMemberRolesActionTypes,
   joinThreadActionTypes,
 } from '../actions/thread-actions.js';
 import { updateMultimediaMessageMediaActionType } from '../actions/upload-actions.js';
 import {
   keyserverAuthActionTypes,
   deleteKeyserverAccountActionTypes,
   legacyLogInActionTypes,
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
 } from '../actions/user-actions.js';
 import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js';
 import {
   messageStoreOpsHandlers,
   type MessageStoreOperation,
   type ReplaceMessageOperation,
 } from '../ops/message-store-ops.js';
 import { pendingToRealizedThreadIDsSelector } from '../selectors/thread-selectors.js';
 import {
   messageID,
   sortMessageInfoList,
   sortMessageIDs,
   mergeThreadMessageInfos,
   findNewestMessageTimePerKeyserver,
   localIDPrefix,
 } from '../shared/message-utils.js';
 import {
   threadHasPermission,
   threadInChatList,
   threadIsPending,
 } from '../shared/thread-utils.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import { unshimMessageInfos } from '../shared/unshim-utils.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import { recoveryFromReduxActionSources } from '../types/account-types.js';
 import type { Media, Image } from '../types/media-types.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import {
   type RawMessageInfo,
   type LocalMessageInfo,
   type MessageStore,
   type MessageTruncationStatus,
   type MessageTruncationStatuses,
   messageTruncationStatus,
   defaultNumberPerThread,
   type ThreadMessageInfo,
 } from '../types/message-types.js';
 import type { RawImagesMessageInfo } from '../types/messages/images.js';
 import type { RawMediaMessageInfo } from '../types/messages/media.js';
 import type { RawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import { type BaseAction } from '../types/redux-types.js';
 import { processServerRequestsActionType } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
 import type {
   LegacyRawThreadInfo,
   RawThreadInfos,
   MixedRawThreadInfos,
 } from '../types/thread-types.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { translateClientDBThreadMessageInfos } from '../utils/message-ops-utils.js';
 
 const _mapValuesWithKeys = _mapValues.convert({ cap: false });
 
 // Input must already be ordered!
 function mapThreadsToMessageIDsFromOrderedMessageInfos(
   orderedMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 ): { [threadID: string]: string[] } {
   const threadsToMessageIDs: { [threadID: string]: string[] } = {};
   for (const messageInfo of orderedMessageInfos) {
     const key = messageID(messageInfo);
     if (!threadsToMessageIDs[messageInfo.threadID]) {
       threadsToMessageIDs[messageInfo.threadID] = [key];
     } else {
       threadsToMessageIDs[messageInfo.threadID].push(key);
     }
   }
   return threadsToMessageIDs;
 }
 
 function isThreadWatched(
   threadID: string,
   threadInfo: ?LegacyRawThreadInfo | ?RawThreadInfo,
   watchedIDs: $ReadOnlyArray<string>,
 ) {
   return (
     threadIsPending(threadID) ||
     (threadInfo &&
       threadHasPermission(threadInfo, threadPermissions.VISIBLE) &&
       (threadInChatList(threadInfo) || watchedIDs.includes(threadID)))
   );
 }
 
 const newThread = (): ThreadMessageInfo => ({
   messageIDs: [],
   startReached: false,
 });
 
 type FreshMessageStoreResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 function freshMessageStore(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   truncationStatus: { [threadID: string]: MessageTruncationStatus },
   currentAsOf: { +[keyserverID: string]: number },
   threadInfos: MixedRawThreadInfos,
 ): FreshMessageStoreResult {
   const unshimmed = unshimMessageInfos(messageInfos);
   const orderedMessageInfos = sortMessageInfoList(unshimmed);
   const messages = _keyBy(messageID)(orderedMessageInfos);
 
   const messageStoreReplaceOperations = orderedMessageInfos.map(
     messageInfo => ({
       type: 'replace',
       payload: { id: messageID(messageInfo), messageInfo },
     }),
   );
 
   const threadsToMessageIDs =
     mapThreadsToMessageIDsFromOrderedMessageInfos(orderedMessageInfos);
   const threads = _mapValuesWithKeys(
     (messageIDs: string[], threadID: string) => ({
       ...newThread(),
       messageIDs,
       startReached:
         truncationStatus[threadID] === messageTruncationStatus.EXHAUSTIVE,
     }),
   )(threadsToMessageIDs);
   const watchedIDs = threadWatcher.getWatchedIDs();
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (
       threads[threadID] ||
       !isThreadWatched(threadID, threadInfo, watchedIDs)
     ) {
       continue;
     }
     threads[threadID] = newThread();
   }
 
   const messageStoreOperations = [
     { type: 'remove_all' },
     {
       type: 'remove_all_threads',
     },
     {
       type: 'replace_threads',
       payload: { threads },
     },
     ...messageStoreReplaceOperations,
   ];
 
   return {
     messageStoreOperations,
     messageStore: {
       messages,
       threads,
       local: {},
       currentAsOf,
     },
   };
 }
 
 type ReassignmentResult = {
   +messageStoreOperations: MessageStoreOperation[],
   +messageStore: MessageStore,
   +reassignedThreadIDs: string[],
 };
 
 function reassignMessagesToRealizedThreads(
   messageStore: MessageStore,
   threadInfos: RawThreadInfos,
 ): ReassignmentResult {
   const pendingToRealizedThreadIDs =
     pendingToRealizedThreadIDsSelector(threadInfos);
 
   const messageStoreOperations: MessageStoreOperation[] = [];
   const messages: { [string]: RawMessageInfo } = {};
   for (const storeMessageID in messageStore.messages) {
     const message = messageStore.messages[storeMessageID];
     const newThreadID = pendingToRealizedThreadIDs.get(message.threadID);
 
     messages[storeMessageID] = newThreadID
       ? {
           ...message,
           threadID: newThreadID,
           time: threadInfos[newThreadID]?.creationTime ?? message.time,
         }
       : message;
 
     if (!newThreadID) {
       continue;
     }
 
     const updateMsgOperation: ReplaceMessageOperation = {
       type: 'replace',
       payload: { id: storeMessageID, messageInfo: messages[storeMessageID] },
     };
 
     messageStoreOperations.push(updateMsgOperation);
   }
 
   const threads: { [string]: ThreadMessageInfo } = {};
   const reassignedThreadIDs = [];
   const updatedThreads: { [string]: ThreadMessageInfo } = {};
   const threadsToRemove = [];
   for (const threadID in messageStore.threads) {
     const threadMessageInfo = messageStore.threads[threadID];
     const newThreadID = pendingToRealizedThreadIDs.get(threadID);
     if (!newThreadID) {
       threads[threadID] = threadMessageInfo;
       continue;
     }
     const realizedThread = messageStore.threads[newThreadID];
     if (!realizedThread) {
       reassignedThreadIDs.push(newThreadID);
       threads[newThreadID] = threadMessageInfo;
       updatedThreads[newThreadID] = threadMessageInfo;
       threadsToRemove.push(threadID);
       continue;
     }
     threads[newThreadID] = mergeThreadMessageInfos(
       threadMessageInfo,
       realizedThread,
       messages,
     );
     updatedThreads[newThreadID] = threads[newThreadID];
   }
   if (threadsToRemove.length) {
     messageStoreOperations.push({
       type: 'remove_threads',
       payload: {
         ids: threadsToRemove,
       },
     });
   }
   messageStoreOperations.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   return {
     messageStoreOperations,
     messageStore: {
       ...messageStore,
       threads,
       messages,
     },
     reassignedThreadIDs,
   };
 }
 
 type MergeNewMessagesResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 // oldMessageStore is from the old state
 // newMessageInfos, truncationStatus come from server
 function mergeNewMessages(
   oldMessageStore: MessageStore,
   newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   truncationStatus: { +[threadID: string]: MessageTruncationStatus },
   threadInfos: RawThreadInfos,
 ): MergeNewMessagesResult {
   const {
     messageStoreOperations: updateWithLatestThreadInfosOps,
     messageStore: messageStoreUpdatedWithLatestThreadInfos,
     reassignedThreadIDs,
   } = updateMessageStoreWithLatestThreadInfos(oldMessageStore, threadInfos);
 
   const messageStoreAfterUpdateOps = processMessageStoreOperations(
     oldMessageStore,
     updateWithLatestThreadInfosOps,
   );
 
   const updatedMessageStore = {
     ...messageStoreUpdatedWithLatestThreadInfos,
     messages: messageStoreAfterUpdateOps.messages,
     threads: messageStoreAfterUpdateOps.threads,
   };
 
   const localIDsToServerIDs: Map<string, string> = new Map();
 
   const watchedThreadIDs = [
     ...threadWatcher.getWatchedIDs(),
     ...reassignedThreadIDs,
   ];
   const unshimmedNewMessages = unshimMessageInfos(newMessageInfos);
   const unshimmedNewMessagesOfWatchedThreads = unshimmedNewMessages.filter(
     msg =>
       isThreadWatched(
         msg.threadID,
         threadInfos[msg.threadID],
         watchedThreadIDs,
       ),
   );
   const orderedNewMessageInfos = _flow(
     _map((messageInfo: RawMessageInfo) => {
       const { id: inputID } = messageInfo;
       invariant(inputID, 'new messageInfos should have serverID');
       invariant(
         !threadIsPending(messageInfo.threadID),
         'new messageInfos should have realized thread id',
       );
       const currentMessageInfo = updatedMessageStore.messages[inputID];
       if (
         messageInfo.type === messageTypes.TEXT ||
         messageInfo.type === messageTypes.IMAGES ||
         messageInfo.type === messageTypes.MULTIMEDIA
       ) {
         const { localID: inputLocalID } = messageInfo;
         const currentLocalMessageInfo = inputLocalID
           ? updatedMessageStore.messages[inputLocalID]
           : null;
         if (currentMessageInfo && currentMessageInfo.localID) {
           // If the client already has a RawMessageInfo with this serverID, keep
           // any localID associated with the existing one. This is because we
           // use localIDs as React keys and changing React keys leads to loss of
           // component state. (The conditional below is for Flow)
           if (messageInfo.type === messageTypes.TEXT) {
             messageInfo = {
               ...messageInfo,
               localID: currentMessageInfo.localID,
             };
           } else if (messageInfo.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({
               ...messageInfo,
               localID: currentMessageInfo.localID,
             }: RawMediaMessageInfo);
           } else {
             messageInfo = ({
               ...messageInfo,
               localID: currentMessageInfo.localID,
             }: RawImagesMessageInfo);
           }
         } else if (currentLocalMessageInfo && currentLocalMessageInfo.localID) {
           // If the client has a RawMessageInfo with this localID, but not with
           // the serverID, that means the message creation succeeded but the
           // success action never got processed. We set a key in
           // localIDsToServerIDs here to fix the messageIDs for the rest of the
           // MessageStore too. (The conditional below is for Flow)
           invariant(inputLocalID, 'inputLocalID should be set');
           localIDsToServerIDs.set(inputLocalID, inputID);
           if (messageInfo.type === messageTypes.TEXT) {
             messageInfo = {
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             };
           } else if (messageInfo.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             }: RawMediaMessageInfo);
           } else {
             messageInfo = ({
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             }: RawImagesMessageInfo);
           }
         } else {
           // If neither the serverID nor the localID from the delivered
           // RawMessageInfo exists in the client store, then this message is
           // brand new to us. Ignore any localID provided by the server.
           // (The conditional below is for Flow)
           const { localID, ...rest } = messageInfo;
           if (rest.type === messageTypes.TEXT) {
             messageInfo = { ...rest };
           } else if (rest.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({ ...rest }: RawMediaMessageInfo);
           } else {
             messageInfo = ({ ...rest }: RawImagesMessageInfo);
           }
         }
       } else if (
         currentMessageInfo &&
         messageInfo.time > currentMessageInfo.time
       ) {
         // When thick threads will be introduced it will be possible for two
         // clients to create the same message (e.g. when they create the same
         // sidebar at the same time). We're going to use deterministic ids for
         // messages which should be unique within a thread and we have to find
         // a way for clients to agree which message to keep. We can't rely on
         // always choosing incoming messages nor messages from the store,
         // because a message that is in one user's store, will be send to
         // another user. One way to deal with it is to always choose a message
         // which is older, according to its timestamp. We can use this strategy
         // only for messages that can start a thread, because for other types
         // it might break the "contiguous" property of message ids (we can
         // consider selecting younger messages in that case, but for now we use
         // an invariant).
         invariant(
           messageInfo.type === messageTypes.CREATE_SIDEBAR ||
             messageInfo.type === messageTypes.CREATE_THREAD ||
             messageInfo.type === messageTypes.SIDEBAR_SOURCE,
           `Two different messages of type ${messageInfo.type} with the same ` +
             'id found',
         );
         return currentMessageInfo;
       }
       return _isEqual(messageInfo)(currentMessageInfo)
         ? currentMessageInfo
         : messageInfo;
     }),
     sortMessageInfoList,
   )(unshimmedNewMessagesOfWatchedThreads);
 
   const newMessageOps: MessageStoreOperation[] = [];
   const threadsToMessageIDs = mapThreadsToMessageIDsFromOrderedMessageInfos(
     orderedNewMessageInfos,
   );
   const oldMessageInfosToCombine = [];
   const threadsThatNeedMessageIDsResorted = [];
   const local: { [string]: LocalMessageInfo } = {};
   const updatedThreads: { [string]: ThreadMessageInfo } = {};
   const threads = _flow(
     _mapValuesWithKeys((messageIDs: string[], threadID: string) => {
       const oldThread = updatedMessageStore.threads[threadID];
       const truncate = truncationStatus[threadID];
       if (!oldThread) {
         updatedThreads[threadID] = {
           ...newThread(),
           messageIDs,
           startReached: truncate === messageTruncationStatus.EXHAUSTIVE,
         };
         return updatedThreads[threadID];
       }
       let oldMessageIDsUnchanged = true;
       const oldMessageIDs = oldThread.messageIDs.map(oldID => {
         const newID = localIDsToServerIDs.get(oldID);
         if (newID !== null && newID !== undefined) {
           oldMessageIDsUnchanged = false;
           return newID;
         }
         return oldID;
       });
       if (truncate === messageTruncationStatus.TRUNCATED) {
         // If the result set in the payload isn't contiguous with what we have
         // now, that means we need to dump what we have in the state and replace
         // it with the result set. We do this to achieve our two goals for the
         // messageStore: currentness and contiguousness.
         newMessageOps.push({
           type: 'remove_messages_for_threads',
           payload: { threadIDs: [threadID] },
         });
         updatedThreads[threadID] = {
           messageIDs,
           startReached: false,
         };
         return updatedThreads[threadID];
       }
       const oldNotInNew = _difference(oldMessageIDs)(messageIDs);
       for (const id of oldNotInNew) {
         const oldMessageInfo = updatedMessageStore.messages[id];
         invariant(oldMessageInfo, `could not find ${id} in messageStore`);
         oldMessageInfosToCombine.push(oldMessageInfo);
         const localInfo = updatedMessageStore.local[id];
         if (localInfo) {
           local[id] = localInfo;
         }
       }
       const startReached =
         oldThread.startReached ||
         truncate === messageTruncationStatus.EXHAUSTIVE;
       if (_difference(messageIDs)(oldMessageIDs).length === 0) {
         if (startReached === oldThread.startReached && oldMessageIDsUnchanged) {
           return oldThread;
         }
         updatedThreads[threadID] = {
           messageIDs: oldMessageIDs,
           startReached,
         };
         return updatedThreads[threadID];
       }
       const mergedMessageIDs = [...messageIDs, ...oldNotInNew];
       threadsThatNeedMessageIDsResorted.push(threadID);
       return {
         messageIDs: mergedMessageIDs,
         startReached,
       };
     }),
     _pickBy(thread => !!thread),
   )(threadsToMessageIDs);
 
   for (const threadID in updatedMessageStore.threads) {
     if (threads[threadID]) {
       continue;
     }
     let thread = updatedMessageStore.threads[threadID];
     const truncate = truncationStatus[threadID];
     if (truncate === messageTruncationStatus.EXHAUSTIVE) {
       thread = {
         ...thread,
         startReached: true,
       };
     }
     threads[threadID] = thread;
     updatedThreads[threadID] = thread;
 
     for (const id of thread.messageIDs) {
       const messageInfo = updatedMessageStore.messages[id];
       if (messageInfo) {
         oldMessageInfosToCombine.push(messageInfo);
       }
       const localInfo = updatedMessageStore.local[id];
       if (localInfo) {
         local[id] = localInfo;
       }
     }
   }
 
   const messages = _flow(
     sortMessageInfoList,
     _keyBy(messageID),
   )([...orderedNewMessageInfos, ...oldMessageInfosToCombine]);
 
   const newMessages = _keyBy(messageID)(orderedNewMessageInfos);
   for (const id in newMessages) {
     newMessageOps.push({
       type: 'replace',
       payload: { id, messageInfo: newMessages[id] },
     });
   }
 
   if (localIDsToServerIDs.size > 0) {
     newMessageOps.push({
       type: 'remove',
       payload: { ids: [...localIDsToServerIDs.keys()] },
     });
   }
 
   for (const threadID of threadsThatNeedMessageIDsResorted) {
     threads[threadID].messageIDs = sortMessageIDs(messages)(
       threads[threadID].messageIDs,
     );
     updatedThreads[threadID] = threads[threadID];
   }
 
   newMessageOps.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   const processedMessageStore = processMessageStoreOperations(
     updatedMessageStore,
     newMessageOps,
   );
 
   const currentAsOf: { [keyserverID: string]: number } = {};
   const newestMessageTimePerKeyserver = findNewestMessageTimePerKeyserver(
     orderedNewMessageInfos,
   );
   for (const keyserverID in newestMessageTimePerKeyserver) {
     currentAsOf[keyserverID] = Math.max(
       newestMessageTimePerKeyserver[keyserverID],
       processedMessageStore.currentAsOf[keyserverID] ?? 0,
     );
   }
 
   const messageStore = {
     messages: processedMessageStore.messages,
     threads: processedMessageStore.threads,
     local,
     currentAsOf: {
       ...processedMessageStore.currentAsOf,
       ...currentAsOf,
     },
   };
 
   return {
     messageStoreOperations: [
       ...updateWithLatestThreadInfosOps,
       ...newMessageOps,
     ],
     messageStore,
   };
 }
 
 type UpdateMessageStoreWithLatestThreadInfosResult = {
   +messageStoreOperations: MessageStoreOperation[],
   +messageStore: MessageStore,
   +reassignedThreadIDs: string[],
 };
 function updateMessageStoreWithLatestThreadInfos(
   messageStore: MessageStore,
   threadInfos: RawThreadInfos,
 ): UpdateMessageStoreWithLatestThreadInfosResult {
   const messageStoreOperations: MessageStoreOperation[] = [];
   const {
     messageStore: reassignedMessageStore,
     messageStoreOperations: reassignMessagesOps,
     reassignedThreadIDs,
   } = reassignMessagesToRealizedThreads(messageStore, threadInfos);
   messageStoreOperations.push(...reassignMessagesOps);
   const watchedIDs = [...threadWatcher.getWatchedIDs(), ...reassignedThreadIDs];
 
   const filteredThreads: { [string]: ThreadMessageInfo } = {};
   const threadsToRemoveMessagesFrom = [];
   const messageIDsToRemove: string[] = [];
   for (const threadID in reassignedMessageStore.threads) {
     const threadMessageInfo = reassignedMessageStore.threads[threadID];
     const threadInfo = threadInfos[threadID];
     if (isThreadWatched(threadID, threadInfo, watchedIDs)) {
       filteredThreads[threadID] = threadMessageInfo;
     } else {
       threadsToRemoveMessagesFrom.push(threadID);
       messageIDsToRemove.push(...threadMessageInfo.messageIDs);
     }
   }
 
   const updatedThreads: { [string]: ThreadMessageInfo } = {};
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (
       isThreadWatched(threadID, threadInfo, watchedIDs) &&
       !filteredThreads[threadID]
     ) {
       filteredThreads[threadID] = newThread();
       updatedThreads[threadID] = filteredThreads[threadID];
     }
   }
 
   messageStoreOperations.push({
     type: 'remove_threads',
     payload: { ids: threadsToRemoveMessagesFrom },
   });
 
   messageStoreOperations.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   messageStoreOperations.push({
     type: 'remove_messages_for_threads',
     payload: { threadIDs: threadsToRemoveMessagesFrom },
   });
 
   return {
     messageStoreOperations,
     messageStore: {
       messages: _omit(messageIDsToRemove)(reassignedMessageStore.messages),
       threads: filteredThreads,
       local: _omit(messageIDsToRemove)(reassignedMessageStore.local),
       currentAsOf: reassignedMessageStore.currentAsOf,
     },
     reassignedThreadIDs,
   };
 }
 
 function ensureRealizedThreadIDIsUsedWhenPossible<T: RawMessageInfo>(
   payload: T,
   threadInfos: RawThreadInfos,
 ): T {
   const pendingToRealizedThreadIDs =
     pendingToRealizedThreadIDsSelector(threadInfos);
   const realizedThreadID = pendingToRealizedThreadIDs.get(payload.threadID);
   return realizedThreadID
     ? { ...payload, threadID: realizedThreadID }
     : payload;
 }
 
 const { processStoreOperations: processMessageStoreOperations } =
   messageStoreOpsHandlers;
 
 type ReduceMessageStoreResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 function reduceMessageStore(
   messageStore: MessageStore,
   action: BaseAction,
   newThreadInfos: RawThreadInfos,
 ): ReduceMessageStoreResult {
   if (
     action.type === legacyLogInActionTypes.success ||
     action.type === legacySiweAuthActionTypes.success
   ) {
     const { messagesResult } = action.payload;
     let { messageInfos } = messagesResult;
 
     // If it's a resolution attempt and the userID doesn't change,
     // then we should keep all local messages in the store
     // TODO we can't check if the userID changed until ENG-6126
     if (
       action.payload.authActionSource ===
         recoveryFromReduxActionSources.cookieInvalidationResolutionAttempt ||
       action.payload.authActionSource ===
         recoveryFromReduxActionSources.socketAuthErrorResolutionAttempt
     ) {
       const localMessages = Object.values(messageStore.messages).filter(
         rawMessageInfo => messageID(rawMessageInfo).startsWith(localIDPrefix),
       );
       messageInfos = [...messageInfos, ...localMessages];
     }
 
     const { messageStoreOperations, messageStore: freshStore } =
       freshMessageStore(
         messageInfos,
         messagesResult.truncationStatus,
         messagesResult.currentAsOf,
         newThreadInfos,
       );
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...freshStore,
         messages: processedMessageStore.messages,
         threads: processedMessageStore.threads,
       },
     };
   } else if (action.type === keyserverAuthActionTypes.success) {
     const { messagesResult } = action.payload;
     return mergeNewMessages(
       messageStore,
       messagesResult.messageInfos,
       messagesResult.truncationStatus,
       newThreadInfos,
     );
   } else if (action.type === incrementalStateSyncActionType) {
     if (
       action.payload.messagesResult.rawMessageInfos.length === 0 &&
       action.payload.updatesResult.newUpdates.length === 0
     ) {
       return { messageStoreOperations: [], messageStore };
     }
 
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.messagesResult.rawMessageInfos,
       action.payload.updatesResult.newUpdates,
       action.payload.messagesResult.truncationStatuses,
     );
 
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
     );
   } else if (action.type === processUpdatesActionType) {
     if (action.payload.updatesResult.newUpdates.length === 0) {
       return { messageStoreOperations: [], messageStore };
     }
 
     const messagesResult = mergeUpdatesWithMessageInfos(
       [],
       action.payload.updatesResult.newUpdates,
     );
 
     const { messageStoreOperations, messageStore: newMessageStore } =
       mergeNewMessages(
         messageStore,
         messagesResult.rawMessageInfos,
         messagesResult.truncationStatuses,
         newThreadInfos,
       );
     return {
       messageStoreOperations,
       messageStore: {
         messages: newMessageStore.messages,
         threads: newMessageStore.threads,
         local: newMessageStore.local,
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (
     action.type === fullStateSyncActionType ||
     action.type === processMessagesActionType
   ) {
     const { messagesResult } = action.payload;
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
     );
   } else if (
     action.type === fetchSingleMostRecentMessagesFromThreadsActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       action.payload.truncationStatuses,
       newThreadInfos,
     );
   } else if (
     action.type === fetchMessagesBeforeCursorActionTypes.success ||
     action.type === fetchMostRecentMessagesActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       { [action.payload.threadID]: action.payload.truncationStatus },
       newThreadInfos,
     );
   } else if (action.type === deleteKeyserverAccountActionTypes.success) {
     const { messageStoreOperations, messageStore: filteredMessageStore } =
       updateMessageStoreWithLatestThreadInfos(messageStore, newThreadInfos);
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     let currentAsOf = {};
     if (action.payload.keyserverIDs) {
       currentAsOf = _omit(action.payload.keyserverIDs)(
         filteredMessageStore.currentAsOf,
       );
     }
 
     return {
       messageStoreOperations,
       messageStore: {
         ...filteredMessageStore,
         currentAsOf,
         messages: processedMessageStore.messages,
         threads: processedMessageStore.threads,
       },
     };
   } else if (
     action.type === deleteThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === setNewSessionActionType
   ) {
     const { messageStoreOperations, messageStore: filteredMessageStore } =
       updateMessageStoreWithLatestThreadInfos(messageStore, newThreadInfos);
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...filteredMessageStore,
         messages: processedMessageStore.messages,
         threads: processedMessageStore.threads,
       },
     };
   } else if (action.type === newThreadActionTypes.success) {
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.newMessageInfos,
       action.payload.updatesResult.newUpdates,
     );
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
     );
   } else if (action.type === sendMessageReportActionTypes.success) {
     return mergeNewMessages(
       messageStore,
       [action.payload.messageInfo],
       {
         [(action.payload.messageInfo.threadID: string)]:
           messageTruncationStatus.UNCHANGED,
       },
       newThreadInfos,
     );
-  } else if (action.type === keyserverRegisterActionTypes.success) {
+  } else if (action.type === legacyKeyserverRegisterActionTypes.success) {
     const truncationStatuses: { [string]: MessageTruncationStatus } = {};
     for (const messageInfo of action.payload.rawMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.EXHAUSTIVE;
     }
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       truncationStatuses,
       newThreadInfos,
     );
   } else if (
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success ||
     action.type === createEntryActionTypes.success ||
     action.type === saveEntryActionTypes.success ||
     action.type === restoreEntryActionTypes.success ||
     action.type === toggleMessagePinActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.newMessageInfos,
       {
         [(action.payload.threadID: string)]: messageTruncationStatus.UNCHANGED,
       },
       newThreadInfos,
     );
   } else if (action.type === deleteEntryActionTypes.success) {
     const payload = action.payload;
     if (payload) {
       return mergeNewMessages(
         messageStore,
         payload.newMessageInfos,
         { [payload.threadID]: messageTruncationStatus.UNCHANGED },
         newThreadInfos,
       );
     }
   } else if (action.type === joinThreadActionTypes.success) {
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.rawMessageInfos,
       action.payload.updatesResult.newUpdates,
     );
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
     );
   } else if (action.type === sendEditMessageActionTypes.success) {
     const { newMessageInfos } = action.payload;
     const truncationStatuses: { [string]: MessageTruncationStatus } = {};
     for (const messageInfo of newMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.UNCHANGED;
     }
     return mergeNewMessages(
       messageStore,
       newMessageInfos,
       truncationStatuses,
       newThreadInfos,
     );
   } else if (
     action.type === sendTextMessageActionTypes.started ||
     action.type === sendMultimediaMessageActionTypes.started ||
     action.type === sendReactionMessageActionTypes.started
   ) {
     const payload = ensureRealizedThreadIDIsUsedWhenPossible(
       action.payload,
       newThreadInfos,
     );
     const { localID, threadID } = payload;
     invariant(localID, `localID should be set on ${action.type}`);
 
     const messageIDs = messageStore.threads[threadID]?.messageIDs ?? [];
     if (!messageStore.messages[localID]) {
       for (const existingMessageID of messageIDs) {
         const existingMessageInfo = messageStore.messages[existingMessageID];
         if (existingMessageInfo && existingMessageInfo.localID === localID) {
           return { messageStoreOperations: [], messageStore };
         }
       }
     }
 
     const messageStoreOperations: MessageStoreOperation[] = [
       {
         type: 'replace',
         payload: { id: localID, messageInfo: payload },
       },
     ];
 
     let updatedThreads;
     let local = { ...messageStore.local };
     if (messageStore.messages[localID]) {
       const messages = {
         ...messageStore.messages,
         [(localID: string)]: payload,
       };
       local = _pickBy(
         (localInfo: LocalMessageInfo, key: string) => key !== localID,
       )(messageStore.local);
       const thread = messageStore.threads[threadID];
       updatedThreads = {
         [(threadID: string)]: {
           messageIDs: sortMessageIDs(messages)(messageIDs),
           startReached: thread?.startReached ?? true,
         },
       };
     } else {
       updatedThreads = {
         [(threadID: string)]: messageStore.threads[threadID]
           ? {
               ...messageStore.threads[threadID],
               messageIDs: [localID, ...messageIDs],
             }
           : {
               messageIDs: [localID],
               startReached: true,
             },
       };
     }
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: {
         threads: { ...updatedThreads },
       },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       messages: processedMessageStore.messages,
       threads: processedMessageStore.threads,
       local,
       currentAsOf: messageStore.currentAsOf,
     };
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (
     action.type === sendTextMessageActionTypes.failed ||
     action.type === sendMultimediaMessageActionTypes.failed
   ) {
     const { localID } = action.payload;
     return {
       messageStoreOperations: [],
       messageStore: {
         messages: messageStore.messages,
         threads: messageStore.threads,
         local: {
           ...messageStore.local,
           [(localID: string)]: { sendFailed: true },
         },
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (action.type === sendReactionMessageActionTypes.failed) {
     const { localID, threadID } = action.payload;
     const messageStoreOperations: MessageStoreOperation[] = [];
 
     messageStoreOperations.push({
       type: 'remove',
       payload: { ids: [localID] },
     });
 
     const newMessageIDs = messageStore.threads[threadID].messageIDs.filter(
       id => id !== localID,
     );
     const updatedThreads = {
       [threadID]: {
         ...messageStore.threads[threadID],
         messageIDs: newMessageIDs,
       },
     };
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: updatedThreads },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: processedMessageStore,
     };
   } else if (
     action.type === sendTextMessageActionTypes.success ||
     action.type === sendMultimediaMessageActionTypes.success ||
     action.type === sendReactionMessageActionTypes.success
   ) {
     const { payload } = action;
     invariant(
       !threadIsPending(payload.threadID),
       'Successful message action should have realized thread id',
     );
     const replaceMessageKey = (messageKey: string) =>
       messageKey === payload.localID ? payload.serverID : messageKey;
     let newMessages;
     const messageStoreOperations: MessageStoreOperation[] = [];
     if (messageStore.messages[payload.serverID]) {
       // If somehow the serverID got in there already, we'll just update the
       // serverID message and scrub the localID one
       newMessages = _omitBy(
         (messageInfo: RawMessageInfo) =>
           messageInfo.type === messageTypes.TEXT &&
           !messageInfo.id &&
           messageInfo.localID === payload.localID,
       )(messageStore.messages);
       messageStoreOperations.push({
         type: 'remove',
         payload: { ids: [payload.localID] },
       });
     } else if (messageStore.messages[payload.localID]) {
       // The normal case, the localID message gets replaced by the serverID one
       newMessages = _mapKeys(replaceMessageKey)(messageStore.messages);
       messageStoreOperations.push({
         type: 'rekey',
         payload: { from: payload.localID, to: payload.serverID },
       });
     } else {
       // Well this is weird, we probably got deauthorized between when the
       // action was dispatched and when we ran this reducer...
       return { messageStoreOperations, messageStore };
     }
 
     const newMessage = {
       ...newMessages[payload.serverID],
       id: payload.serverID,
       localID: payload.localID,
       time: payload.time,
     };
     newMessages[payload.serverID] = newMessage;
     messageStoreOperations.push({
       type: 'replace',
       payload: { id: payload.serverID, messageInfo: newMessage },
     });
     const threadID = payload.threadID;
     const newMessageIDs = _flow(
       _uniq,
       sortMessageIDs(newMessages),
     )(messageStore.threads[threadID].messageIDs.map(replaceMessageKey));
     const local = _pickBy(
       (localInfo: LocalMessageInfo, key: string) => key !== payload.localID,
     )(messageStore.local);
 
     const updatedThreads = {
       [threadID]: {
         ...messageStore.threads[threadID],
         messageIDs: newMessageIDs,
       },
     };
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: updatedThreads },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStore,
         messages: processedMessageStore.messages,
         threads: processedMessageStore.threads,
         local,
       },
     };
   } else if (action.type === saveMessagesActionType) {
     const truncationStatuses: { [string]: MessageTruncationStatus } = {};
     for (const messageInfo of action.payload.rawMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.UNCHANGED;
     }
     const { messageStoreOperations, messageStore: newMessageStore } =
       mergeNewMessages(
         messageStore,
         action.payload.rawMessageInfos,
         truncationStatuses,
         newThreadInfos,
       );
     return {
       messageStoreOperations,
       messageStore: {
         messages: newMessageStore.messages,
         threads: newMessageStore.threads,
         local: newMessageStore.local,
         // We avoid bumping currentAsOf because notifs may include a contracted
         // RawMessageInfo, so we want to make sure we still fetch it
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (action.type === messageStorePruneActionType) {
     const messageIDsToPrune = [];
 
     const updatedThreads: { [string]: ThreadMessageInfo } = {};
     for (const threadID of action.payload.threadIDs) {
       let thread = messageStore.threads[threadID];
       if (!thread) {
         continue;
       }
 
       const newMessageIDs = [...thread.messageIDs];
       const removed = newMessageIDs.splice(defaultNumberPerThread);
       if (removed.length > 0) {
         thread = {
           ...thread,
           messageIDs: newMessageIDs,
           startReached: false,
         };
       }
       for (const id of removed) {
         messageIDsToPrune.push(id);
       }
 
       updatedThreads[threadID] = thread;
     }
 
     const messageStoreOperations = [
       {
         type: 'remove',
         payload: { ids: messageIDsToPrune },
       },
       {
         type: 'replace_threads',
         payload: {
           threads: updatedThreads,
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       messages: processedMessageStore.messages,
       threads: processedMessageStore.threads,
       local: _omit(messageIDsToPrune)(messageStore.local),
       currentAsOf: messageStore.currentAsOf,
     };
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (action.type === updateMultimediaMessageMediaActionType) {
     const { messageID: id, currentMediaID, mediaUpdate } = action.payload;
     const message = messageStore.messages[id];
     invariant(message, `message with ID ${id} could not be found`);
     invariant(
       message.type === messageTypes.IMAGES ||
         message.type === messageTypes.MULTIMEDIA,
       `message with ID ${id} is not multimedia`,
     );
 
     let updatedMessage;
     let replaced = false;
     if (message.type === messageTypes.IMAGES) {
       const media: Image[] = [];
       for (const singleMedia of message.media) {
         if (singleMedia.id !== currentMediaID) {
           media.push(singleMedia);
         } else {
           let updatedMedia: Image = {
             id: mediaUpdate.id ?? singleMedia.id,
             type: 'photo',
             uri: mediaUpdate.uri ?? singleMedia.uri,
             dimensions: mediaUpdate.dimensions ?? singleMedia.dimensions,
             thumbHash: mediaUpdate.thumbHash ?? singleMedia.thumbHash,
           };
 
           if (
             'localMediaSelection' in singleMedia &&
             !('localMediaSelection' in mediaUpdate)
           ) {
             updatedMedia = {
               ...updatedMedia,
               localMediaSelection: singleMedia.localMediaSelection,
             };
           } else if (mediaUpdate.localMediaSelection) {
             updatedMedia = {
               ...updatedMedia,
               localMediaSelection: mediaUpdate.localMediaSelection,
             };
           }
 
           media.push(updatedMedia);
           replaced = true;
         }
       }
       updatedMessage = { ...message, media };
     } else {
       const media: Media[] = [];
       for (const singleMedia of message.media) {
         if (singleMedia.id !== currentMediaID) {
           media.push(singleMedia);
         } else if (
           singleMedia.type === 'photo' &&
           mediaUpdate.type === 'photo'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'video' &&
           mediaUpdate.type === 'video'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'encrypted_photo' &&
           mediaUpdate.type === 'encrypted_photo'
         ) {
           if (singleMedia.blobURI) {
             const { holder, ...rest } = mediaUpdate;
             if (holder) {
               console.log(
                 `mediaUpdate contained holder for media ${singleMedia.id} ` +
                   'that has blobURI',
               );
             }
             media.push({ ...singleMedia, ...rest });
           } else {
             invariant(
               singleMedia.holder,
               'Encrypted media must have holder or blobURI',
             );
             const { blobURI, ...rest } = mediaUpdate;
             if (blobURI) {
               console.log(
                 `mediaUpdate contained blobURI for media ${singleMedia.id} ` +
                   'that has holder',
               );
             }
             media.push({ ...singleMedia, ...rest });
           }
           replaced = true;
         } else if (
           singleMedia.type === 'encrypted_video' &&
           mediaUpdate.type === 'encrypted_video'
         ) {
           if (singleMedia.blobURI) {
             const { holder, thumbnailHolder, ...rest } = mediaUpdate;
             if (holder || thumbnailHolder) {
               console.log(
                 'mediaUpdate contained holder or thumbnailHolder for media ' +
                   `${singleMedia.id} that has blobURI`,
               );
             }
             media.push({ ...singleMedia, ...rest });
           } else {
             invariant(
               singleMedia.holder,
               'Encrypted media must have holder or blobURI',
             );
             const { blobURI, thumbnailBlobURI, ...rest } = mediaUpdate;
             if (blobURI || thumbnailBlobURI) {
               console.log(
                 'mediaUpdate contained blobURI or thumbnailBlobURI for media ' +
                   `${singleMedia.id} that has holder`,
               );
             }
             media.push({ ...singleMedia, ...rest });
           }
           replaced = true;
         } else if (
           singleMedia.type === 'photo' &&
           mediaUpdate.type === 'encrypted_photo'
         ) {
           // extract fields that are absent in encrypted_photo type
           const { uri, localMediaSelection, ...original } = singleMedia;
           const {
             holder: newHolder,
             blobURI: newBlobURI,
             encryptionKey,
             ...update
           } = mediaUpdate;
           const blobURI = newBlobURI ?? newHolder;
           invariant(
             blobURI && encryptionKey,
             'holder and encryptionKey are required for encrypted_photo message',
           );
           media.push({
             ...original,
             ...update,
             type: 'encrypted_photo',
             blobURI,
             encryptionKey,
           });
           replaced = true;
         } else if (
           singleMedia.type === 'video' &&
           mediaUpdate.type === 'encrypted_video'
         ) {
           const { uri, thumbnailURI, localMediaSelection, ...original } =
             singleMedia;
           const {
             holder: newHolder,
             blobURI: newBlobURI,
             encryptionKey,
             thumbnailHolder: newThumbnailHolder,
             thumbnailBlobURI: newThumbnailBlobURI,
             thumbnailEncryptionKey,
             ...update
           } = mediaUpdate;
           const blobURI = newBlobURI ?? newHolder;
           invariant(
             blobURI && encryptionKey,
             'holder and encryptionKey are required for encrypted_video message',
           );
           const thumbnailBlobURI = newThumbnailBlobURI ?? newThumbnailHolder;
           invariant(
             thumbnailBlobURI && thumbnailEncryptionKey,
             'thumbnailHolder and thumbnailEncryptionKey are required for ' +
               'encrypted_video message',
           );
           media.push({
             ...original,
             ...update,
             type: 'encrypted_video',
             blobURI,
             encryptionKey,
             thumbnailBlobURI,
             thumbnailEncryptionKey,
           });
           replaced = true;
         } else if (mediaUpdate.id) {
           const { id: newID } = mediaUpdate;
           media.push({ ...singleMedia, id: newID });
           replaced = true;
         }
       }
       updatedMessage = { ...message, media };
     }
 
     invariant(
       replaced,
       `message ${id} did not contain media with ID ${currentMediaID}`,
     );
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: {
           id,
           messageInfo: updatedMessage,
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStore,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === createLocalMessageActionType) {
     const messageInfo = ensureRealizedThreadIDIsUsedWhenPossible(
       action.payload,
       newThreadInfos,
     );
     const { localID, threadID } = messageInfo;
 
     const messageIDs =
       messageStore.threads[messageInfo.threadID]?.messageIDs ?? [];
     const threadState: ThreadMessageInfo = messageStore.threads[threadID]
       ? {
           ...messageStore.threads[threadID],
           messageIDs: [localID, ...messageIDs],
         }
       : {
           messageIDs: [localID],
           startReached: true,
         };
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: { id: localID, messageInfo },
       },
       {
         type: 'replace_threads',
         payload: {
           threads: { [(threadID: string)]: threadState },
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStore,
         threads: processedMessageStore.threads,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === processServerRequestsActionType) {
     const {
       messageStoreOperations,
       messageStore: messageStoreAfterReassignment,
     } = reassignMessagesToRealizedThreads(messageStore, newThreadInfos);
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStoreAfterReassignment,
         messages: processedMessageStore.messages,
         threads: processedMessageStore.threads,
       },
     };
   } else if (action.type === setClientDBStoreActionType) {
     const actionPayloadMessageStoreThreads =
       translateClientDBThreadMessageInfos(
         action.payload.messageStoreThreads ?? [],
       );
 
     const newThreads: {
       [threadID: string]: ThreadMessageInfo,
     } = { ...messageStore.threads };
     for (const threadID in actionPayloadMessageStoreThreads) {
       newThreads[threadID] = {
         ...actionPayloadMessageStoreThreads[threadID],
         messageIDs: messageStore.threads?.[threadID]?.messageIDs ?? [],
       };
     }
 
     const payloadMessages = action.payload.messages;
     if (!payloadMessages) {
       return {
         messageStoreOperations: [],
         messageStore: { ...messageStore, threads: newThreads },
       };
     }
 
     const { messageStoreOperations, messageStore: updatedMessageStore } =
       updateMessageStoreWithLatestThreadInfos(
         { ...messageStore, threads: newThreads },
         newThreadInfos,
       );
 
     let threads = { ...updatedMessageStore.threads };
     let local = { ...updatedMessageStore.local };
 
     // Store message IDs already contained within threads so that we
     // do not insert duplicates
     const existingMessageIDs = new Set<string>();
     for (const threadID in threads) {
       threads[threadID].messageIDs.forEach(msgID => {
         existingMessageIDs.add(msgID);
       });
     }
     const threadsNeedMsgIDsResorting = new Set<string>();
     const actionPayloadMessages =
       messageStoreOpsHandlers.translateClientDBData(payloadMessages);
 
     // When starting the app on native, we filter out any local-only multimedia
     // messages because the relevant context is no longer available
     const messageIDsToBeRemoved = [];
     const threadsToAdd: { [string]: ThreadMessageInfo } = {};
     for (const id in actionPayloadMessages) {
       const message = actionPayloadMessages[id];
       const { threadID } = message;
       let existingThread = threads[threadID];
       if (!existingThread) {
         existingThread = newThread();
         threadsToAdd[threadID] = existingThread;
       }
       if (
         (message.type === messageTypes.IMAGES ||
           message.type === messageTypes.MULTIMEDIA) &&
         !message.id
       ) {
         messageIDsToBeRemoved.push(id);
         threads = {
           ...threads,
           [(threadID: string)]: {
             ...existingThread,
             messageIDs: existingThread.messageIDs.filter(
               curMessageID => curMessageID !== id,
             ),
           },
         };
         local = _pickBy(
           (localInfo: LocalMessageInfo, key: string) => key !== id,
         )(local);
       } else if (!existingMessageIDs.has(id)) {
         threads = {
           ...threads,
           [(threadID: string)]: {
             ...existingThread,
             messageIDs: [...existingThread.messageIDs, id],
           },
         };
         threadsNeedMsgIDsResorting.add(threadID);
       } else if (!threads[threadID]) {
         threads = { ...threads, [(threadID: string)]: existingThread };
       }
     }
 
     for (const threadID of threadsNeedMsgIDsResorting) {
       threads[threadID].messageIDs = sortMessageIDs(actionPayloadMessages)(
         threads[threadID].messageIDs,
       );
     }
 
     const newMessageStore = {
       ...updatedMessageStore,
       messages: actionPayloadMessages,
       threads: threads,
       local: local,
     };
 
     if (messageIDsToBeRemoved.length > 0) {
       messageStoreOperations.push({
         type: 'remove',
         payload: { ids: messageIDsToBeRemoved },
       });
     }
 
     const processedMessageStore = processMessageStoreOperations(
       newMessageStore,
       messageStoreOperations,
     );
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: threadsToAdd },
     });
 
     return {
       messageStoreOperations,
       messageStore: processedMessageStore,
     };
   }
   return { messageStoreOperations: [], messageStore };
 }
 
 type MergedUpdatesWithMessages = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
 };
 function mergeUpdatesWithMessageInfos(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   truncationStatuses?: MessageTruncationStatuses,
 ): MergedUpdatesWithMessages {
   const messageIDs = new Set(
     messageInfos.map(messageInfo => messageInfo.id).filter(Boolean),
   );
   const mergedMessageInfos = [...messageInfos];
   const mergedTruncationStatuses = { ...truncationStatuses };
 
   for (const update of newUpdates) {
     const { mergeMessageInfosAndTruncationStatuses } = updateSpecs[update.type];
     if (!mergeMessageInfosAndTruncationStatuses) {
       continue;
     }
     mergeMessageInfosAndTruncationStatuses(
       messageIDs,
       mergedMessageInfos,
       mergedTruncationStatuses,
       update,
     );
   }
   return {
     rawMessageInfos: mergedMessageInfos,
     truncationStatuses: mergedTruncationStatuses,
   };
 }
 
 export { freshMessageStore, reduceMessageStore };
diff --git a/lib/reducers/nav-reducer.js b/lib/reducers/nav-reducer.js
index c0b56cb08..14505b499 100644
--- a/lib/reducers/nav-reducer.js
+++ b/lib/reducers/nav-reducer.js
@@ -1,60 +1,60 @@
 // @flow
 
 import { updateCalendarQueryActionTypes } from '../actions/entry-actions.js';
 import { legacySiweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   identityRegisterActionTypes,
   legacyLogInActionTypes,
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
   logOutActionTypes,
   deleteAccountActionTypes,
   identityLogInActionTypes,
 } from '../actions/user-actions.js';
 import { defaultCalendarQuery } from '../types/entry-types.js';
 import type { BaseNavInfo } from '../types/nav-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { getConfig } from '../utils/config.js';
 
 export default function reduceBaseNavInfo<T: BaseNavInfo>(
   state: T,
   action: BaseAction,
 ): T {
   if (
     action.type === legacyLogInActionTypes.started ||
     action.type === legacySiweAuthActionTypes.started ||
-    action.type === keyserverRegisterActionTypes.started ||
+    action.type === legacyKeyserverRegisterActionTypes.started ||
     action.type === fullStateSyncActionType ||
     action.type === incrementalStateSyncActionType
   ) {
     const { startDate, endDate } = action.payload.calendarQuery;
     return { ...state, startDate, endDate };
   } else if (action.type === updateCalendarQueryActionTypes.started) {
     if (action.payload && action.payload.calendarQuery) {
       const { startDate, endDate } = action.payload.calendarQuery;
       return { ...state, startDate, endDate };
     }
   } else if (
     action.type === updateCalendarQueryActionTypes.success &&
     !action.payload.calendarQueryAlreadyUpdated
   ) {
     const { startDate, endDate } = action.payload.calendarQuery;
     return { ...state, startDate, endDate };
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success ||
     action.type === identityRegisterActionTypes.success ||
     (action.type === identityLogInActionTypes.success &&
       action.payload.userID !== action.payload.preRequestUserState?.id)
   ) {
     const { startDate, endDate } = defaultCalendarQuery(
       getConfig().platformDetails.platform,
     );
 
     return { ...state, startDate, endDate };
   }
   return state;
 }
diff --git a/lib/reducers/theme-reducer.js b/lib/reducers/theme-reducer.js
index fdd0aae7e..2d9dfc332 100644
--- a/lib/reducers/theme-reducer.js
+++ b/lib/reducers/theme-reducer.js
@@ -1,42 +1,42 @@
 // @flow
 
 import { legacySiweAuthActionTypes } from '../actions/siwe-actions.js';
 import { updateThemeInfoActionType } from '../actions/theme-actions.js';
 import {
   legacyLogInActionTypes,
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
 } from '../actions/user-actions.js';
 import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   defaultGlobalThemeInfo,
   type GlobalThemeInfo,
 } from '../types/theme-types.js';
 import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
 import { relyingOnAuthoritativeKeyserver } from '../utils/services-utils.js';
 
 export default function reduceGlobalThemeInfo(
   state: GlobalThemeInfo,
   action: BaseAction,
 ): GlobalThemeInfo {
   if (
     action.type === legacyLogInActionTypes.success ||
     action.type === legacySiweAuthActionTypes.success ||
-    action.type === keyserverRegisterActionTypes.success
+    action.type === legacyKeyserverRegisterActionTypes.success
   ) {
     return defaultGlobalThemeInfo;
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.cookieInvalidated &&
     action.payload.keyserverID === authoritativeKeyserverID() &&
     relyingOnAuthoritativeKeyserver
   ) {
     return defaultGlobalThemeInfo;
   } else if (action.type === updateThemeInfoActionType) {
     return {
       ...state,
       ...action.payload,
     };
   }
   return state;
 }
diff --git a/lib/reducers/thread-reducer.js b/lib/reducers/thread-reducer.js
index d45fe4e49..733877d21 100644
--- a/lib/reducers/thread-reducer.js
+++ b/lib/reducers/thread-reducer.js
@@ -1,499 +1,499 @@
 // @flow
 
 import {
   setThreadUnreadStatusActionTypes,
   updateActivityActionTypes,
 } from '../actions/activity-actions.js';
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import { saveMessagesActionType } from '../actions/message-actions.js';
 import { legacySiweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   changeThreadSettingsActionTypes,
   deleteThreadActionTypes,
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
   changeThreadMemberRolesActionTypes,
   joinThreadActionTypes,
   leaveThreadActionTypes,
   modifyCommunityRoleActionTypes,
   deleteCommunityRoleActionTypes,
 } from '../actions/thread-actions.js';
 import {
   keyserverAuthActionTypes,
   deleteKeyserverAccountActionTypes,
   legacyLogInActionTypes,
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
   updateSubscriptionActionTypes,
 } from '../actions/user-actions.js';
 import {
   getThreadIDsForKeyservers,
   extractKeyserverIDFromID,
 } from '../keyserver-conn/keyserver-call-utils.js';
 import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js';
 import {
   type ThreadStoreOperation,
   threadStoreOpsHandlers,
 } from '../ops/thread-store-ops.js';
 import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import type { RawThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import { type ClientThreadInconsistencyReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   processServerRequestsActionType,
 } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type { RawThreadInfos, ThreadStore } from '../types/thread-types.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 
 const { processStoreOperations: processThreadStoreOperations } =
   threadStoreOpsHandlers;
 
 function generateOpsForThreadUpdates(
   threadInfos: RawThreadInfos,
   payload: {
     +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
     ...
   },
 ): $ReadOnlyArray<ThreadStoreOperation> {
   return payload.updatesResult.newUpdates
     .map(update =>
       updateSpecs[update.type].generateOpsForThreadUpdates?.(
         threadInfos,
         update,
       ),
     )
     .filter(Boolean)
     .flat();
 }
 
 function reduceThreadInfos(
   state: ThreadStore,
   action: BaseAction,
 ): {
   threadStore: ThreadStore,
   newThreadInconsistencies: $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>,
   threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 } {
   if (action.type === fullStateSyncActionType) {
     const threadsToRemove = Object.keys(state.threadInfos).filter(
       key => extractKeyserverIDFromID(key) === action.payload.keyserverID,
     );
     const newThreadInfos = action.payload.threadInfos;
     const threadStoreOperations = [
       {
         type: 'remove',
         payload: { ids: threadsToRemove },
       },
       ...Object.keys(newThreadInfos).map((id: string) => ({
         type: 'replace',
         payload: { id, threadInfo: newThreadInfos[id] },
       })),
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (
     action.type === legacyLogInActionTypes.success ||
     action.type === legacySiweAuthActionTypes.success ||
-    action.type === keyserverRegisterActionTypes.success
+    action.type === legacyKeyserverRegisterActionTypes.success
   ) {
     const newThreadInfos = action.payload.threadInfos;
     const threadStoreOperations = [
       {
         type: 'remove_all',
       },
       ...Object.keys(newThreadInfos).map((id: string) => ({
         type: 'replace',
         payload: { id, threadInfo: newThreadInfos[id] },
       })),
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === keyserverAuthActionTypes.success) {
     const keyserverIDs = Object.keys(action.payload.updatesCurrentAsOf);
     const threadIDsToRemove = getThreadIDsForKeyservers(
       Object.keys(state.threadInfos),
       keyserverIDs,
     );
     const newThreadInfos = action.payload.threadInfos;
 
     const threadStoreOperations = [
       {
         type: 'remove',
         payload: { ids: threadIDsToRemove },
       },
       ...Object.keys(newThreadInfos).map((id: string) => ({
         type: 'replace',
         payload: { id, threadInfo: newThreadInfos[id] },
       })),
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === deleteKeyserverAccountActionTypes.success) {
     const threadIDsToRemove = getThreadIDsForKeyservers(
       Object.keys(state.threadInfos),
       action.payload.keyserverIDs,
     );
 
     if (threadIDsToRemove.length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const threadStoreOperations = [
       {
         type: 'remove',
         payload: { ids: threadIDsToRemove },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.cookieInvalidated
   ) {
     const threadIDsToRemove = getThreadIDsForKeyservers(
       Object.keys(state.threadInfos),
       [action.payload.keyserverID],
     );
 
     if (threadIDsToRemove.length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const threadStoreOperations = [
       {
         type: 'remove',
         payload: { ids: threadIDsToRemove },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (
     action.type === joinThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success ||
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType ||
     action.type === newThreadActionTypes.success ||
     action.type === modifyCommunityRoleActionTypes.success ||
     action.type === deleteCommunityRoleActionTypes.success
   ) {
     const { newUpdates } = action.payload.updatesResult;
     if (newUpdates.length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = generateOpsForThreadUpdates(
       state.threadInfos,
       action.payload,
     );
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === updateSubscriptionActionTypes.success) {
     const { threadID, subscription } = action.payload;
     const threadInfo = state.threadInfos[threadID];
     const newThreadInfo = {
       ...threadInfo,
       currentUser: {
         ...threadInfo.currentUser,
         subscription,
       },
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: newThreadInfo,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === saveMessagesActionType) {
     const threadIDToMostRecentTime = new Map<string, number>();
     for (const messageInfo of action.payload.rawMessageInfos) {
       const current = threadIDToMostRecentTime.get(messageInfo.threadID);
       if (!current || current < messageInfo.time) {
         threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
       }
     }
     const changedThreadInfos: { [string]: RawThreadInfo } = {};
     for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
       const threadInfo = state.threadInfos[threadID];
       if (
         !threadInfo ||
         threadInfo.currentUser.unread ||
         action.payload.updatesCurrentAsOf > mostRecentTime
       ) {
         continue;
       }
       changedThreadInfos[threadID] = {
         ...threadInfo,
         currentUser: {
           ...threadInfo.currentUser,
           unread: true,
         },
       };
     }
     if (Object.keys(changedThreadInfos).length !== 0) {
       const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
         type: 'replace',
         payload: {
           id,
           threadInfo: changedThreadInfos[id],
         },
       }));
       const updatedThreadStore = processThreadStoreOperations(
         state,
         threadStoreOperations,
       );
       return {
         threadStore: updatedThreadStore,
         newThreadInconsistencies: [],
         threadStoreOperations,
       };
     }
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (!checkStateRequest || !checkStateRequest.stateChanges) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const { rawThreadInfos, deleteThreadIDs } = checkStateRequest.stateChanges;
     if (!rawThreadInfos && !deleteThreadIDs) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const threadStoreOperations: ThreadStoreOperation[] = [];
     if (rawThreadInfos) {
       for (const rawThreadInfo of rawThreadInfos) {
         threadStoreOperations.push({
           type: 'replace',
           payload: {
             id: rawThreadInfo.id,
             threadInfo: rawThreadInfo,
           },
         });
       }
     }
     if (deleteThreadIDs) {
       threadStoreOperations.push({
         type: 'remove',
         payload: {
           ids: deleteThreadIDs,
         },
       });
     }
 
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
 
     const newThreadInconsistencies =
       stateSyncSpecs.threads.findStoreInconsistencies(
         action,
         state.threadInfos,
         updatedThreadStore.threadInfos,
       );
 
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies,
       threadStoreOperations,
     };
   } else if (action.type === updateActivityActionTypes.success) {
     const updatedThreadInfos: { [string]: RawThreadInfo } = {};
     for (const setToUnread of action.payload.result.unfocusedToUnread) {
       const threadInfo = state.threadInfos[setToUnread];
       if (threadInfo && !threadInfo.currentUser.unread) {
         updatedThreadInfos[setToUnread] = {
           ...threadInfo,
           currentUser: {
             ...threadInfo.currentUser,
             unread: true,
           },
         };
       }
     }
     if (Object.keys(updatedThreadInfos).length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
       type: 'replace',
       payload: {
         id,
         threadInfo: updatedThreadInfos[id],
       },
     }));
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setThreadUnreadStatusActionTypes.started) {
     const { threadID, unread } = action.payload;
     const threadInfo = state.threadInfos[threadID];
     const updatedThreadInfo = {
       ...threadInfo,
       currentUser: {
         ...threadInfo.currentUser,
         unread,
       },
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: updatedThreadInfo,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setThreadUnreadStatusActionTypes.success) {
     const { threadID, resetToUnread } = action.payload;
     const threadInfo = state.threadInfos[threadID];
     const { currentUser } = threadInfo;
 
     if (!resetToUnread || currentUser.unread) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const updatedThread = {
       ...threadInfo,
       currentUser: { ...currentUser, unread: true },
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: updatedThread,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setClientDBStoreActionType) {
     return {
       threadStore: action.payload.threadStore ?? state,
       newThreadInconsistencies: [],
       threadStoreOperations: [],
     };
   }
   return {
     threadStore: state,
     newThreadInconsistencies: [],
     threadStoreOperations: [],
   };
 }
 
 export { reduceThreadInfos };
diff --git a/lib/reducers/user-reducer.js b/lib/reducers/user-reducer.js
index 529aa0dfa..06d593b80 100644
--- a/lib/reducers/user-reducer.js
+++ b/lib/reducers/user-reducer.js
@@ -1,427 +1,427 @@
 // @flow
 
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import { legacySiweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   joinThreadActionTypes,
   newThreadActionTypes,
 } from '../actions/thread-actions.js';
 import {
   identityLogInActionTypes,
   identityRegisterActionTypes,
   deleteAccountActionTypes,
   keyserverAuthActionTypes,
   logOutActionTypes,
   legacyLogInActionTypes,
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
   setUserSettingsActionTypes,
   updateUserAvatarActionTypes,
 } from '../actions/user-actions.js';
 import { setNewSessionActionType } from '../keyserver-conn/keyserver-conn-types.js';
 import {
   convertUserInfosToReplaceUserOps,
   type UserStoreOperation,
   userStoreOpsHandlers,
 } from '../ops/user-store-ops.js';
 import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
 import { updateSpecs } from '../shared/updates/update-specs.js';
 import type { BaseAction } from '../types/redux-types.js';
 import type { ClientUserInconsistencyReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   processServerRequestsActionType,
 } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { processUpdatesActionType } from '../types/update-types.js';
 import type { ClientUpdateInfo } from '../types/update-types.js';
 import type {
   CurrentUserInfo,
   UserInfos,
   UserStore,
 } from '../types/user-types.js';
 import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
 import { relyingOnAuthoritativeKeyserver } from '../utils/services-utils.js';
 
 function reduceCurrentUserInfo(
   state: ?CurrentUserInfo,
   action: BaseAction,
 ): ?CurrentUserInfo {
   if (
     action.type === identityLogInActionTypes.success ||
     action.type === identityRegisterActionTypes.success
   ) {
     const newUserInfo = {
       id: action.payload.userID,
       username: action.payload.username,
     };
     if (!_isEqual(newUserInfo)(state)) {
       return newUserInfo;
     }
   } else if (
     action.type === legacyLogInActionTypes.success ||
     action.type === legacySiweAuthActionTypes.success ||
-    action.type === keyserverRegisterActionTypes.success ||
+    action.type === legacyKeyserverRegisterActionTypes.success ||
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success
   ) {
     if (!_isEqual(action.payload.currentUserInfo)(state)) {
       return action.payload.currentUserInfo;
     }
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.currentUserInfo &&
     action.payload.keyserverID === authoritativeKeyserverID() &&
     relyingOnAuthoritativeKeyserver
   ) {
     const actionUserInfo = action.payload.sessionChange.currentUserInfo;
     if (!actionUserInfo?.id) {
       return actionUserInfo;
     } else if (!state?.id || actionUserInfo.id !== state.id) {
       console.log(
         'keyserver auth returned a different user info than identity login',
       );
     } else {
       const newUserInfo = {
         ...state,
         avatar: actionUserInfo.avatar,
         settings: actionUserInfo.settings,
       };
       if (!_isEqual(newUserInfo)(state)) {
         return newUserInfo;
       }
     }
   } else if (
     action.type === fullStateSyncActionType &&
     relyingOnAuthoritativeKeyserver
   ) {
     if (action.payload.keyserverID !== authoritativeKeyserverID()) {
       return state;
     }
     const { currentUserInfo } = action.payload;
     if (!_isEqual(currentUserInfo)(state)) {
       return currentUserInfo;
     }
   } else if (
     (action.type === incrementalStateSyncActionType ||
       action.type === processUpdatesActionType) &&
     relyingOnAuthoritativeKeyserver
   ) {
     if (action.payload.keyserverID !== authoritativeKeyserverID()) {
       return state;
     }
     return action.payload.updatesResult.newUpdates.reduce(
       (reducedState, update) => {
         const { reduceCurrentUser } = updateSpecs[update.type];
         return reduceCurrentUser
           ? reduceCurrentUser(reducedState, update)
           : reducedState;
       },
       state,
     );
   } else if (
     action.type === processServerRequestsActionType &&
     relyingOnAuthoritativeKeyserver
   ) {
     if (action.payload.keyserverID !== authoritativeKeyserverID()) {
       return state;
     }
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     const newCurrentUserInfo = checkStateRequest?.stateChanges?.currentUserInfo;
     if (newCurrentUserInfo && !_isEqual(newCurrentUserInfo)(state)) {
       return newCurrentUserInfo;
     }
   } else if (
     action.type === updateUserAvatarActionTypes.success &&
     state &&
     !state.anonymous
   ) {
     const { viewerUpdates } = action.payload.updates;
     for (const update of viewerUpdates) {
       if (
         update.type === updateTypes.UPDATE_CURRENT_USER &&
         !_isEqual(update.currentUserInfo.avatar)(state.avatar)
       ) {
         return {
           ...state,
           avatar: update.currentUserInfo.avatar,
         };
       }
     }
     return state;
   } else if (action.type === setUserSettingsActionTypes.success) {
     if (state?.settings) {
       return {
         ...state,
         settings: {
           ...state.settings,
           ...action.payload,
         },
       };
     }
   }
   return state;
 }
 
 const { processStoreOperations: processUserStoreOps } = userStoreOpsHandlers;
 
 function generateOpsForUserUpdates(payload: {
   +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
   ...
 }): $ReadOnlyArray<UserStoreOperation> {
   return payload.updatesResult.newUpdates
     .map(update =>
       updateSpecs[update.type].generateOpsForUserInfoUpdates?.(update),
     )
     .filter(Boolean)
     .flat();
 }
 
 function reduceUserInfos(
   state: UserStore,
   action: BaseAction,
 ): [
   UserStore,
   $ReadOnlyArray<ClientUserInconsistencyReportCreationRequest>,
   $ReadOnlyArray<UserStoreOperation>,
 ] {
   if (
     action.type === joinThreadActionTypes.success ||
     action.type === newThreadActionTypes.success
   ) {
     const newUserInfos: UserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
 
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> =
       convertUserInfosToReplaceUserOps(newUserInfos);
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
 
     if (!_isEqual(state.userInfos)(processedUserInfos)) {
       return [
         {
           ...state,
           userInfos: processedUserInfos,
         },
         [],
         userStoreOps,
       ];
     }
   } else if (
     action.type === setNewSessionActionType &&
     action.payload.sessionChange.cookieInvalidated &&
     action.payload.keyserverID === authoritativeKeyserverID() &&
     relyingOnAuthoritativeKeyserver
   ) {
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> = [
       { type: 'remove_all_users' },
     ];
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
 
     if (Object.keys(state.userInfos).length === 0) {
       return [state, [], []];
     }
     return [
       {
         userInfos: processedUserInfos,
       },
       [],
       userStoreOps,
     ];
   } else if (
     action.type === fullStateSyncActionType &&
     relyingOnAuthoritativeKeyserver
   ) {
     if (action.payload.keyserverID !== authoritativeKeyserverID()) {
       return [state, [], []];
     }
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> = [
       { type: 'remove_all_users' },
       ...convertUserInfosToReplaceUserOps(newUserInfos),
     ];
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
 
     if (!_isEqual(state.userInfos)(processedUserInfos)) {
       return [
         {
           userInfos: processedUserInfos,
         },
         [],
         userStoreOps,
       ];
     }
   } else if (
     action.type === legacyLogInActionTypes.success ||
     action.type === legacySiweAuthActionTypes.success ||
-    action.type === keyserverRegisterActionTypes.success
+    action.type === legacyKeyserverRegisterActionTypes.success
   ) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> = [
       { type: 'remove_all_users' },
       ...convertUserInfosToReplaceUserOps(newUserInfos),
     ];
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
 
     return [
       {
         userInfos: processedUserInfos,
       },
       [],
       userStoreOps,
     ];
   } else if (action.type === keyserverAuthActionTypes.success) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
 
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> =
       convertUserInfosToReplaceUserOps(newUserInfos);
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
 
     if (!_isEqual(state.userInfos)(processedUserInfos)) {
       return [
         {
           ...state,
           userInfos: processedUserInfos,
         },
         [],
         userStoreOps,
       ];
     }
   } else if (
     (action.type === incrementalStateSyncActionType ||
       action.type === processUpdatesActionType) &&
     relyingOnAuthoritativeKeyserver
   ) {
     if (action.payload.keyserverID !== authoritativeKeyserverID()) {
       return [state, [], []];
     }
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.userInfos,
     );
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> = [
       ...convertUserInfosToReplaceUserOps(newUserInfos),
       ...generateOpsForUserUpdates(action.payload),
     ];
 
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
 
     if (!_isEqual(state.userInfos)(processedUserInfos)) {
       return [
         {
           ...state,
           userInfos: processedUserInfos,
         },
         [],
         userStoreOps,
       ];
     }
   } else if (
     action.type === processServerRequestsActionType &&
     relyingOnAuthoritativeKeyserver
   ) {
     if (action.payload.keyserverID !== authoritativeKeyserverID()) {
       return [state, [], []];
     }
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (!checkStateRequest || !checkStateRequest.stateChanges) {
       return [state, [], []];
     }
     const { userInfos, deleteUserInfoIDs } = checkStateRequest.stateChanges;
     if (!userInfos && !deleteUserInfoIDs) {
       return [state, [], []];
     }
 
     const userStoreOps: UserStoreOperation[] = [];
     if (userInfos) {
       for (const userInfo of userInfos) {
         userStoreOps.push({ type: 'replace_user', payload: { ...userInfo } });
       }
     }
     if (deleteUserInfoIDs) {
       userStoreOps.push({
         type: 'remove_users',
         payload: { ids: deleteUserInfoIDs },
       });
     }
 
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
 
     const newInconsistencies = stateSyncSpecs.users.findStoreInconsistencies(
       action,
       state.userInfos,
       processedUserInfos,
     );
     return [
       {
         userInfos: processedUserInfos,
       },
       newInconsistencies,
       userStoreOps,
     ];
   } else if (action.type === updateUserAvatarActionTypes.success) {
     const newUserInfos = _keyBy(userInfo => userInfo.id)(
       action.payload.updates.userInfos,
     );
     const userStoreOps: $ReadOnlyArray<UserStoreOperation> =
       convertUserInfosToReplaceUserOps(newUserInfos);
     const processedUserInfos: UserInfos = processUserStoreOps(
       state.userInfos,
       userStoreOps,
     );
 
     const newState = !_isEqual(state.userInfos)(processedUserInfos)
       ? {
           ...state,
           userInfos: processedUserInfos,
         }
       : state;
     return [newState, [], userStoreOps];
   } else if (action.type === setClientDBStoreActionType) {
     if (!action.payload.users) {
       return [state, [], []];
     }
 
     return [{ userInfos: action.payload.users }, [], []];
   }
 
   return [state, [], []];
 }
 
 export { reduceCurrentUserInfo, reduceUserInfos };
diff --git a/lib/types/account-types.js b/lib/types/account-types.js
index d59dc8705..eafaa02b0 100644
--- a/lib/types/account-types.js
+++ b/lib/types/account-types.js
@@ -1,301 +1,301 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import type { SignedIdentityKeysBlob } from './crypto-types.js';
 import type { PlatformDetails } from './device-types.js';
 import type {
   CalendarQuery,
   CalendarResult,
   RawEntryInfo,
 } from './entry-types.js';
 import {
   type RawMessageInfo,
   type MessageTruncationStatuses,
   type GenericMessagesResult,
 } from './message-types.js';
 import type {
   PreRequestUserState,
   IdentityCallPreRequestUserState,
 } from './session-types.js';
 import {
   type MixedRawThreadInfos,
   type RawThreadInfos,
 } from './thread-types.js';
 import type {
   CurrentUserInfo,
   UserInfo,
   LoggedOutUserInfo,
   LoggedInUserInfo,
 } from './user-types';
 import type { PolicyType } from '../facts/policies.js';
 import { values } from '../utils/objects.js';
 import { tShape } from '../utils/validation-utils.js';
 
 export type ResetPasswordRequest = {
   +usernameOrEmail: string,
 };
 
 export type LogOutResult = {
   +currentUserInfo: ?LoggedOutUserInfo,
   +preRequestUserState: IdentityCallPreRequestUserState,
 };
 
 export type KeyserverLogOutResult = $ReadOnly<{
   +currentUserInfo: ?LoggedOutUserInfo,
   +preRequestUserState: PreRequestUserState,
   +keyserverIDs: $ReadOnlyArray<string>,
 }>;
 
 export type LogOutResponse = {
   +currentUserInfo: LoggedOutUserInfo,
 };
 
-export type RegisterInfo = {
+export type LegacyRegisterInfo = {
   ...LogInExtraInfo,
   +username: string,
   +password: string,
 };
 
 export type DeviceTokenUpdateRequest = {
   +deviceToken: string,
 };
 
 type DeviceTokenUpdateInput = {
   +[keyserverID: string]: DeviceTokenUpdateRequest,
 };
 
 export type RegisterRequest = {
   +username: string,
   +email?: empty,
   +password: string,
   +calendarQuery?: ?CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +platformDetails: PlatformDetails,
   +primaryIdentityPublicKey?: empty,
   +signedIdentityKeysBlob?: SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
 };
 
 export type RegisterResponse = {
   +id: string,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +currentUserInfo: LoggedInUserInfo,
   +cookieChange: {
     +threadInfos: MixedRawThreadInfos,
     +userInfos: $ReadOnlyArray<UserInfo>,
   },
 };
 
-export type RegisterResult = {
+export type LegacyRegisterResult = {
   +currentUserInfo: LoggedInUserInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +threadInfos: RawThreadInfos,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarQuery: CalendarQuery,
 };
 
 export const recoveryFromReduxActionSources = Object.freeze({
   cookieInvalidationResolutionAttempt: 'COOKIE_INVALIDATION_RESOLUTION_ATTEMPT',
   appStartCookieLoggedInButInvalidRedux:
     'APP_START_COOKIE_LOGGED_IN_BUT_INVALID_REDUX',
   appStartReduxLoggedInButInvalidCookie:
     'APP_START_REDUX_LOGGED_IN_BUT_INVALID_COOKIE',
   socketAuthErrorResolutionAttempt: 'SOCKET_AUTH_ERROR_RESOLUTION_ATTEMPT',
   refetchUserDataAfterAcknowledgment: 'REFETCH_USER_DATA_AFTER_ACKNOWLEDGMENT',
   socketNotLoggedIn: 'SOCKET_NOT_LOGGED_IN',
 });
 
 export type RecoveryFromReduxActionSource = $Values<
   typeof recoveryFromReduxActionSources,
 >;
 
 export const recoveryFromDataHandlerActionSources = Object.freeze({
   //sqliteOpFailure: 'SQLITE_OP_FAILURE', (DEPRECATED)
   sqliteLoadFailure: 'SQLITE_LOAD_FAILURE',
   corruptedDatabaseDeletion: 'CORRUPTED_DATABASE_DELETION',
 });
 
 export type RecoveryFromDataHandlerActionSource = $Values<
   typeof recoveryFromDataHandlerActionSources,
 >;
 
 export type RecoveryActionSource =
   | RecoveryFromReduxActionSource
   | RecoveryFromDataHandlerActionSource;
 
 export const logInActionSources = Object.freeze({
   logInFromWebForm: 'LOG_IN_FROM_WEB_FORM',
   logInFromNativeForm: 'LOG_IN_FROM_NATIVE_FORM',
   logInFromNativeSIWE: 'LOG_IN_FROM_NATIVE_SIWE',
   keyserverAuthFromNative: 'KEYSERVER_AUTH_FROM_NATIVE',
   keyserverAuthFromWeb: 'KEYSERVER_AUTH_FROM_WEB',
 });
 
 export type LogInActionSource = $Values<typeof logInActionSources>;
 
 export const authActionSources = Object.freeze({
   ...recoveryFromReduxActionSources,
   ...recoveryFromDataHandlerActionSources,
   ...logInActionSources,
 });
 
 export type AuthActionSource = LogInActionSource | RecoveryActionSource;
 
 export type LogInStartingPayload = {
   +calendarQuery: CalendarQuery,
   +authActionSource?: AuthActionSource,
 };
 
 export type LogInExtraInfo = {
   +calendarQuery: CalendarQuery,
   +deviceTokenUpdateRequest: DeviceTokenUpdateInput,
   +signedIdentityKeysBlob?: SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
   +preRequestUserInfo: ?CurrentUserInfo,
 };
 
 export type LogInInfo = {
   ...LogInExtraInfo,
   +username: string,
   +password: string,
   +authActionSource: AuthActionSource,
   +keyserverIDs?: $ReadOnlyArray<string>,
 };
 
 export type LogInRequest = {
   +usernameOrEmail?: ?string,
   +username?: ?string,
   +password: string,
   +calendarQuery?: ?CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +platformDetails: PlatformDetails,
   +watchedIDs: $ReadOnlyArray<string>,
   +source?: AuthActionSource,
   +primaryIdentityPublicKey?: empty,
   +signedIdentityKeysBlob?: SignedIdentityKeysBlob,
   +initialNotificationsEncryptedMessage?: string,
 };
 
 export type ServerLogInResponse = {
   +currentUserInfo: LoggedInUserInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +rawEntryInfos?: ?$ReadOnlyArray<RawEntryInfo>,
   +serverTime: number,
   +cookieChange: {
     +threadInfos: MixedRawThreadInfos,
     +userInfos: $ReadOnlyArray<UserInfo>,
   },
   +notAcknowledgedPolicies?: $ReadOnlyArray<PolicyType>,
 };
 
 export type ClientLogInResponse = $ReadOnly<{
   ...ServerLogInResponse,
   +cookieChange: $ReadOnly<{
     ...$PropertyType<ServerLogInResponse, 'cookieChange'>,
     threadInfos: RawThreadInfos,
   }>,
 }>;
 
 export type LogInResult = {
   +threadInfos: RawThreadInfos,
   +currentUserInfo: LoggedInUserInfo,
   +messagesResult: GenericMessagesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarResult: CalendarResult,
   +updatesCurrentAsOf: { +[keyserverID: string]: number },
   +authActionSource: AuthActionSource,
   +notAcknowledgedPolicies?: $ReadOnlyArray<PolicyType>,
   +preRequestUserInfo: ?CurrentUserInfo,
 };
 
 export type KeyserverAuthResult = {
   +threadInfos: RawThreadInfos,
   +currentUserInfo?: ?LoggedInUserInfo,
   +messagesResult: GenericMessagesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +calendarResult: CalendarResult,
   +updatesCurrentAsOf: { +[keyserverID: string]: number },
   +authActionSource: AuthActionSource,
   +notAcknowledgedPolicies?: ?$ReadOnlyArray<PolicyType>,
   +preRequestUserInfo: ?CurrentUserInfo,
 };
 
 type KeyserverRequestData = {
   +initialContentEncryptedMessage: string,
   +initialNotificationsEncryptedMessage: string,
 };
 
 export type KeyserverAuthInfo = {
   +userID: string,
   +deviceID: string,
   +doNotRegister: boolean,
   +calendarQuery: CalendarQuery,
   +deviceTokenUpdateInput: DeviceTokenUpdateInput,
   +authActionSource: AuthActionSource,
   +keyserverData: { +[keyserverID: string]: KeyserverRequestData },
 };
 
 export type KeyserverAuthRequest = $ReadOnly<{
   ...KeyserverRequestData,
   +userID: string,
   +deviceID: string,
   +doNotRegister: boolean,
   +calendarQuery: CalendarQuery,
   +deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   +watchedIDs: $ReadOnlyArray<string>,
   +platformDetails: PlatformDetails,
   +source?: AuthActionSource,
 }>;
 
 export type UpdatePasswordRequest = {
   code: string,
   password: string,
   calendarQuery?: ?CalendarQuery,
   deviceTokenUpdateRequest?: ?DeviceTokenUpdateRequest,
   platformDetails: PlatformDetails,
   watchedIDs: $ReadOnlyArray<string>,
 };
 
 export type PolicyAcknowledgmentRequest = {
   +policy: PolicyType,
 };
 
 export type EmailSubscriptionRequest = {
   +email: string,
 };
 export type UpdateUserSettingsRequest = {
   +name: 'default_user_notifications',
   +data: NotificationTypes,
 };
 
 export const userSettingsTypes = Object.freeze({
   DEFAULT_NOTIFICATIONS: 'default_user_notifications',
 });
 
 export const notificationTypes = Object.freeze({
   FOCUSED: 'focused',
   BADGE_ONLY: 'badge_only',
   BACKGROUND: 'background',
 });
 
 export type NotificationTypes = $Values<typeof notificationTypes>;
 
 export const notificationTypeValues: $ReadOnlyArray<NotificationTypes> =
   values(notificationTypes);
 
 export type DefaultNotificationPayload = {
   +default_user_notifications: ?NotificationTypes,
 };
 
 export const defaultNotificationPayloadValidator: TInterface<DefaultNotificationPayload> =
   tShape<DefaultNotificationPayload>({
     default_user_notifications: t.maybe(t.enums.of(notificationTypeValues)),
   });
 
 export type ClaimUsernameResponse = {
   +message: string,
   +signature: string,
 };
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index 637407b59..807917450 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1436 +1,1436 @@
 // @flow
 
 import type {
   LogOutResult,
   KeyserverLogOutResult,
   LogInStartingPayload,
   LogInResult,
-  RegisterResult,
+  LegacyRegisterResult,
   DefaultNotificationPayload,
   ClaimUsernameResponse,
   KeyserverAuthResult,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type { AlertStore, RecordAlertActionPayload } from './alert-types.js';
 import type {
   AuxUserStore,
   SetFarcasterFriendsFIDPayload,
 } from './aux-user-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type {
   CommunityStore,
   AddCommunityPayload,
   CreateOrUpdateFarcasterChannelTagResponse,
 } from './community-types.js';
 import type { MessageSourceMetadata, DBOpsStore } from './db-ops-types.js';
 import type {
   GetVersionActionPayload,
   LastCommunicatedPlatformDetails,
 } from './device-types.js';
 import type { DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
   FetchRevisionsForEntryPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { IdentityAuthResult } from './identity-service-types.js';
 import type { IntegrityStore } from './integrity-types.js';
 import type {
   KeyserverStore,
   AddKeyserverPayload,
   RemoveKeyserverPayload,
 } from './keyserver-types.js';
 import type { LifecycleState } from './lifecycle-state-types.js';
 import type {
   FetchInviteLinksResponse,
   InviteLink,
   InviteLinksStore,
   InviteLinkVerificationResponse,
   DisableInviteLinkPayload,
 } from './link-types.js';
 import type { LoadingStatus, LoadingInfo } from './loading-types.js';
 import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
 import type { MessageReportCreationResult } from './message-report-types.js';
 import type {
   MessageStore,
   RawMultimediaMessageInfo,
   FetchMessageInfosPayload,
   SendMessagePayload,
   EditMessagePayload,
   SaveMessagesPayload,
   NewMessagesPayload,
   MessageStorePrunePayload,
   LocallyComposedMessageInfo,
   SimpleMessagesPayload,
   FetchPinnedMessagesResult,
   SearchMessagesResponse,
 } from './message-types.js';
 import type { RawReactionMessageInfo } from './messages/reaction.js';
 import type { RawTextMessageInfo } from './messages/text.js';
 import type { BaseNavInfo, WebNavInfo } from './nav-types.js';
 import {
   type ForcePolicyAcknowledgmentPayload,
   type PolicyAcknowledgmentPayload,
   type UserPolicies,
 } from './policy-types.js';
 import type { RelationshipErrors } from './relationship-types.js';
 import type {
   EnabledReports,
   ClearDeliveredReportsPayload,
   QueueReportsPayload,
   ReportStore,
 } from './report-types.js';
 import type {
   ProcessServerRequestAction,
   GetOlmSessionInitializationDataResponse,
 } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   ConnectionIssue,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   SetActiveSessionRecoveryPayload,
 } from './socket-types.js';
 import { type ClientStore } from './store-ops-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type {
   SyncedMetadataStore,
   SetSyncedMetadataEntryPayload,
   ClearSyncedMetadataEntryPayload,
 } from './synced-metadata-types.js';
 import type { GlobalThemeInfo } from './theme-types.js';
 import type { ThreadActivityStore } from './thread-activity-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
   LegacyThreadStore,
   RoleModificationPayload,
   RoleDeletionPayload,
 } from './thread-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type { CurrentUserInfo, UserInfos, UserStore } from './user-types.js';
 import type { SetDeviceTokenActionPayload } from '../actions/device-actions.js';
 import type {
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateKeyserverReachabilityPayload,
 } from '../keyserver-conn/keyserver-conn-types.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo = BaseNavInfo> = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +alertStore: AlertStore,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +dataLoaded: boolean,
   +userPolicies: UserPolicies,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
   +customServer: ?string,
   +communityStore: CommunityStore,
   +dbOpsStore: DBOpsStore,
   +syncedMetadataStore: SyncedMetadataStore,
   +auxUserStore: AuxUserStore,
   ...
 };
 
 export type NativeAppState = BaseAppState<>;
 export type WebAppState = BaseAppState<> & {
   +pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type ClientWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type ServerWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: LegacyThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type WebInitialKeyserverInfo = {
   +sessionID: ?string,
   +updatesCurrentAsOf: number,
 };
 
 export type BaseAction = $ReadOnly<{
   +messageSourceMetadata?: MessageSourceMetadata,
   ...
     | {
         +type: '@@redux/INIT',
         +payload?: void,
       }
     | {
         +type: 'FETCH_ENTRIES_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_ENTRIES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_ENTRIES_SUCCESS',
         +payload: FetchEntryInfosResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LOG_OUT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LOG_OUT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LOG_OUT_SUCCESS',
         +payload: LogOutResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CLAIM_USERNAME_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CLAIM_USERNAME_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CLAIM_USERNAME_SUCCESS',
         +payload: ClaimUsernameResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
         +payload: KeyserverLogOutResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ACCOUNT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ACCOUNT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ACCOUNT_SUCCESS',
         +payload: LogOutResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_LOCAL_ENTRY',
         +payload: RawEntryInfo,
       }
     | {
         +type: 'CREATE_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_ENTRY_SUCCESS',
         +payload: CreateEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SAVE_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SAVE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SAVE_ENTRY_SUCCESS',
         +payload: SaveEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CONCURRENT_MODIFICATION_RESET',
         +payload: {
           +id: string,
           +dbText: string,
         },
       }
     | {
         +type: 'DELETE_ENTRY_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: {
           +localID: ?string,
           +serverID: ?string,
         },
       }
     | {
         +type: 'DELETE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ENTRY_SUCCESS',
         +payload: ?DeleteEntryResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_LOG_IN_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'IDENTITY_LOG_IN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_LOG_IN_SUCCESS',
         +payload: IdentityAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'KEYSERVER_AUTH_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: LogInStartingPayload,
       }
     | {
         +type: 'KEYSERVER_AUTH_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'KEYSERVER_AUTH_SUCCESS',
         +payload: KeyserverAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_LOG_IN_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: LogInStartingPayload,
       }
     | {
         +type: 'LEGACY_LOG_IN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_LOG_IN_SUCCESS',
         +payload: LogInResult,
         +loadingInfo: LoadingInfo,
       }
     | {
-        +type: 'KEYSERVER_REGISTER_STARTED',
+        +type: 'LEGACY_KEYSERVER_REGISTER_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: LogInStartingPayload,
       }
     | {
-        +type: 'KEYSERVER_REGISTER_FAILED',
+        +type: 'LEGACY_KEYSERVER_REGISTER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
-        +type: 'KEYSERVER_REGISTER_SUCCESS',
-        +payload: RegisterResult,
+        +type: 'LEGACY_KEYSERVER_REGISTER_SUCCESS',
+        +payload: LegacyRegisterResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_SUCCESS',
         +payload: IdentityAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_KEYSERVER_USER_PASSWORD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_KEYSERVER_USER_PASSWORD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_KEYSERVER_USER_PASSWORD_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_SETTINGS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_SETTINGS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
         +payload: ChangeThreadSettingsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_THREAD_SUCCESS',
         +payload: LeaveThreadPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'NEW_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'NEW_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'NEW_THREAD_SUCCESS',
         +payload: NewThreadResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REMOVE_USERS_FROM_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REMOVE_USERS_FROM_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
         +payload: ChangeThreadSettingsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
         +payload: ChangeThreadSettingsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
         +payload: FetchRevisionsForEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RESTORE_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RESTORE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RESTORE_ENTRY_SUCCESS',
         +payload: RestoreEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'JOIN_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'JOIN_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'JOIN_THREAD_SUCCESS',
         +payload: ThreadJoinPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEAVE_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEAVE_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEAVE_THREAD_SUCCESS',
         +payload: LeaveThreadPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_NEW_SESSION',
         +payload: SetSessionPayload,
       }
     | {
         +type: 'persist/REHYDRATE',
         +payload: ?BaseAppState<>,
       }
     | {
         +type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
         +payload: FetchMessageInfosPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
         +payload: FetchMessageInfosPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
         +payload: SimpleMessagesPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_TEXT_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload: RawTextMessageInfo,
       }
     | {
         +type: 'SEND_TEXT_MESSAGE_FAILED',
         +error: true,
         +payload: Error & {
           +localID: string,
           +threadID: string,
         },
         +loadingInfo?: LoadingInfo,
       }
     | {
         +type: 'SEND_TEXT_MESSAGE_SUCCESS',
         +payload: SendMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload: RawMultimediaMessageInfo,
       }
     | {
         +type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
         +error: true,
         +payload: Error & {
           +localID: string,
           +threadID: string,
         },
         +loadingInfo?: LoadingInfo,
       }
     | {
         +type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
         +payload: SendMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REACTION_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload: RawReactionMessageInfo,
       }
     | {
         +type: 'SEND_REACTION_MESSAGE_FAILED',
         +error: true,
         +payload: Error & {
           +localID: string,
           +threadID: string,
           +targetMessageID: string,
           +reaction: string,
           +action: string,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REACTION_MESSAGE_SUCCESS',
         +payload: SendMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_USERS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_USERS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_USERS_SUCCESS',
         +payload: UserSearchResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'EXACT_SEARCH_USER_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'EXACT_SEARCH_USER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'EXACT_SEARCH_USER_SUCCESS',
         +payload: ExactUserSearchResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_DRAFT',
         +payload: {
           +key: string,
           +text: string,
         },
       }
     | {
         +type: 'MOVE_DRAFT',
         +payload: {
           +oldKey: string,
           +newKey: string,
         },
       }
     | {
         +type: 'SET_CLIENT_DB_STORE',
         +payload: ClientStore,
       }
     | {
         +type: 'UPDATE_ACTIVITY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_ACTIVITY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_ACTIVITY_SUCCESS',
         +payload: ActivityUpdateSuccessPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DEVICE_TOKEN_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DEVICE_TOKEN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DEVICE_TOKEN_SUCCESS',
         +payload: SetDeviceTokenActionPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORT_SUCCESS',
         +payload?: ClearDeliveredReportsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORTS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORTS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORTS_SUCCESS',
         +payload?: ClearDeliveredReportsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'QUEUE_REPORTS',
         +payload: QueueReportsPayload,
       }
     | {
         +type: 'SET_URL_PREFIX',
         +payload: string,
       }
     | {
         +type: 'SAVE_MESSAGES',
         +payload: SaveMessagesPayload,
       }
     | {
         +type: 'UPDATE_CALENDAR_THREAD_FILTER',
         +payload: CalendarThreadFilter,
       }
     | {
         +type: 'CLEAR_CALENDAR_THREAD_FILTER',
         +payload?: void,
       }
     | {
         +type: 'SET_CALENDAR_DELETED_FILTER',
         +payload: SetCalendarDeletedFilterPayload,
       }
     | {
         +type: 'UPDATE_SUBSCRIPTION_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_SUBSCRIPTION_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_SUBSCRIPTION_SUCCESS',
         +payload: SubscriptionUpdateResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_CALENDAR_QUERY_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: CalendarQueryUpdateStartingPayload,
       }
     | {
         +type: 'UPDATE_CALENDAR_QUERY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
         +payload: CalendarQueryUpdateResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FULL_STATE_SYNC',
         +payload: StateSyncFullActionPayload,
       }
     | {
         +type: 'INCREMENTAL_STATE_SYNC',
         +payload: StateSyncIncrementalActionPayload,
       }
     | ProcessServerRequestAction
     | {
         +type: 'UPDATE_CONNECTION_STATUS',
         +payload: UpdateConnectionStatusPayload,
       }
     | {
         +type: 'QUEUE_ACTIVITY_UPDATES',
         +payload: QueueActivityUpdatesPayload,
       }
     | {
         +type: 'UNSUPERVISED_BACKGROUND',
         +payload: { +keyserverID: string },
       }
     | {
         +type: 'UPDATE_LIFECYCLE_STATE',
         +payload: LifecycleState,
       }
     | {
         +type: 'ENABLE_APP',
         +payload: SupportedApps,
       }
     | {
         +type: 'DISABLE_APP',
         +payload: SupportedApps,
       }
     | {
         +type: 'UPDATE_REPORTS_ENABLED',
         +payload: Partial<EnabledReports>,
       }
     | {
         +type: 'PROCESS_UPDATES',
         +payload: ClientUpdatesResultWithUserInfos,
       }
     | {
         +type: 'PROCESS_MESSAGES',
         +payload: NewMessagesPayload,
       }
     | {
         +type: 'MESSAGE_STORE_PRUNE',
         +payload: MessageStorePrunePayload,
       }
     | {
         +type: 'SET_LATE_RESPONSE',
         +payload: SetLateResponsePayload,
       }
     | {
         +type: 'UPDATE_KEYSERVER_REACHABILITY',
         +payload: UpdateKeyserverReachabilityPayload,
       }
     | {
         +type: 'REQUEST_ACCESS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REQUEST_ACCESS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REQUEST_ACCESS_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
         +payload: UpdateMultimediaMessageMediaPayload,
       }
     | {
         +type: 'CREATE_LOCAL_MESSAGE',
         +payload: LocallyComposedMessageInfo,
       }
     | {
         +type: 'UPDATE_RELATIONSHIPS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_RELATIONSHIPS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_RELATIONSHIPS_SUCCESS',
         +payload: RelationshipErrors,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_THREAD_UNREAD_STATUS_STARTED',
         +payload: {
           +threadID: string,
           +unread: boolean,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_THREAD_UNREAD_STATUS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
         +payload: SetThreadUnreadStatusPayload,
       }
     | {
         +type: 'SET_USER_SETTINGS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_USER_SETTINGS_SUCCESS',
         +payload: DefaultNotificationPayload,
       }
     | {
         +type: 'SET_USER_SETTINGS_FAILED',
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MESSAGE_REPORT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MESSAGE_REPORT_SUCCESS',
         +payload: MessageReportCreationResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MESSAGE_REPORT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FORCE_POLICY_ACKNOWLEDGMENT',
         +payload: ForcePolicyAcknowledgmentPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'POLICY_ACKNOWLEDGMENT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
         +payload: PolicyAcknowledgmentPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'POLICY_ACKNOWLEDGMENT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_SIWE_NONCE_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_SIWE_NONCE_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_SIWE_NONCE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_STARTED',
         +payload: LogInStartingPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_SUCCESS',
         +payload: LogInResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RECORD_ALERT',
         +payload: RecordAlertActionPayload,
       }
     | {
         +type: 'UPDATE_USER_AVATAR_STARTED',
         +payload: UpdateUserAvatarRequest,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_USER_AVATAR_SUCCESS',
         +payload: UpdateUserAvatarResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_USER_AVATAR_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_EDIT_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'SEND_EDIT_MESSAGE_SUCCESS',
         +payload: EditMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_EDIT_MESSAGE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'TOGGLE_MESSAGE_PIN_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
         +payload: ToggleMessagePinResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'TOGGLE_MESSAGE_PIN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PINNED_MESSAGES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_PINNED_MESSAGES_SUCCESS',
         +payload: FetchPinnedMessagesResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PINNED_MESSAGES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERIFY_INVITE_LINK_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'VERIFY_INVITE_LINK_SUCCESS',
         +payload: InviteLinkVerificationResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERIFY_INVITE_LINK_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
         +payload: FetchInviteLinksResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
         +payload: string,
       }
     | {
         +type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
         +payload: void,
       }
     | {
         +type: 'UPDATE_CHAT_COMMUNITY_FILTER',
         +payload: string,
       }
     | {
         +type: 'CLEAR_CHAT_COMMUNITY_FILTER',
         +payload: void,
       }
     | {
         +type: 'SEARCH_MESSAGES_STARTED',
         +payload: void,
         +loadingInfo?: LoadingInfo,
       }
     | {
         +type: 'SEARCH_MESSAGES_SUCCESS',
         +payload: SearchMessagesResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_MESSAGES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
         +payload: InviteLink,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DISABLE_INVITE_LINK_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'DISABLE_INVITE_LINK_SUCCESS',
         +payload: DisableInviteLinkPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DISABLE_INVITE_LINK_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
         +payload: GetOlmSessionInitializationDataResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DATA_LOADED',
         +payload: {
           +dataLoaded: boolean,
         },
       }
     | {
         +type: 'GET_VERSION_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'GET_VERSION_SUCCESS',
         +payload: GetVersionActionPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_VERSION_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS',
         +payload: LastCommunicatedPlatformDetails,
       }
     | { +type: 'RESET_USER_STATE', +payload?: void }
     | {
         +type: 'MODIFY_COMMUNITY_ROLE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
         +payload: RoleModificationPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'MODIFY_COMMUNITY_ROLE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_COMMUNITY_ROLE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'DELETE_COMMUNITY_ROLE_SUCCESS',
         +payload: RoleDeletionPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_COMMUNITY_ROLE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_THREAD_LAST_NAVIGATED',
         +payload: { +threadID: string, +time: number },
       }
     | {
         +type: 'UPDATE_INTEGRITY_STORE',
         +payload: {
           +threadIDsToHash?: $ReadOnlyArray<string>,
           +threadHashingStatus?: 'starting' | 'running' | 'completed',
         },
       }
     | {
         +type: 'UPDATE_THEME_INFO',
         +payload: Partial<GlobalThemeInfo>,
       }
     | {
         +type: 'ADD_KEYSERVER',
         +payload: AddKeyserverPayload,
       }
     | {
         +type: 'REMOVE_KEYSERVER',
         +payload: RemoveKeyserverPayload,
       }
     | {
         +type: 'SET_CUSTOM_SERVER',
         +payload: string,
       }
     | {
         +type: 'SET_CONNECTION_ISSUE',
         +payload: { +connectionIssue: ?ConnectionIssue, +keyserverID: string },
       }
     | {
         +type: 'ADD_COMMUNITY',
         +payload: AddCommunityPayload,
       }
     | {
         +type: 'SET_SYNCED_METADATA_ENTRY',
         +payload: SetSyncedMetadataEntryPayload,
       }
     | {
         +type: 'CLEAR_SYNCED_METADATA_ENTRY',
         +payload: ClearSyncedMetadataEntryPayload,
       }
     | {
         +type: 'SET_ACTIVE_SESSION_RECOVERY',
         +payload: SetActiveSessionRecoveryPayload,
       }
     | {
         +type: 'SET_FARCASTER_FRIENDS_FID',
         +payload: SetFarcasterFriendsFIDPayload,
       }
     | {
         +type: 'CLEAR_AUX_USER_FIDS',
         +payload?: void,
       }
     | {
         +type: 'OPS_PROCESSING_FINISHED_ACTION_TYPE',
         +payload?: void,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_SUCCESS',
         +payload: CreateOrUpdateFarcasterChannelTagResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       },
 }>;
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type DispatchSource = 'tunnelbroker' | 'tab-sync';
 export type SuperAction = {
   +type: string,
   +payload?: ActionPayload,
   +loadingInfo?: LoadingInfo,
   +error?: boolean,
   +dispatchSource?: DispatchSource,
   +messageSourceMetadata?: MessageSourceMetadata,
 };
 type ThunkedAction = (dispatch: Dispatch) => void;
 export type PromisedAction = (dispatch: Dispatch) => Promise<void>;
 export type Dispatch = ((promisedAction: PromisedAction) => Promise<void>) &
   ((thunkedAction: ThunkedAction) => void) &
   ((action: SuperAction) => boolean);
 
 // This is lifted from redux-persist/lib/constants.js
 // I don't want to add redux-persist to the web/server bundles...
 // import { REHYDRATE } from 'redux-persist';
 export const rehydrateActionType = 'persist/REHYDRATE';
diff --git a/native/account/register-panel.react.js b/native/account/legacy-register-panel.react.js
similarity index 84%
rename from native/account/register-panel.react.js
rename to native/account/legacy-register-panel.react.js
index f193b3636..1f9e94dd0 100644
--- a/native/account/register-panel.react.js
+++ b/native/account/legacy-register-panel.react.js
@@ -1,507 +1,517 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   Text,
   View,
   StyleSheet,
   Platform,
   Keyboard,
   Linking,
 } from 'react-native';
 import Animated from 'react-native-reanimated';
 
 import { setDataLoadedActionType } from 'lib/actions/client-db-store-actions.js';
 import {
-  keyserverRegisterActionTypes,
-  keyserverRegister,
+  legacyKeyserverRegisterActionTypes,
+  legacyKeyserverRegister,
   getOlmSessionInitializationDataActionTypes,
 } from 'lib/actions/user-actions.js';
 import { useLegacyAshoatKeyserverCall } from 'lib/keyserver-conn/legacy-keyserver-call.js';
 import {
   createLoadingStatusSelector,
   combineLoadingStatuses,
 } from 'lib/selectors/loading-selectors.js';
 import { validUsernameRegex } from 'lib/shared/account-utils.js';
 import { useInitialNotificationsEncryptedMessage } from 'lib/shared/crypto-utils.js';
 import type {
-  RegisterInfo,
+  LegacyRegisterInfo,
   LogInExtraInfo,
-  RegisterResult,
+  LegacyRegisterResult,
   LogInStartingPayload,
 } from 'lib/types/account-types.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import {
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/redux-promise-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 
 import { TextInput } from './modal-components.react.js';
 import { setNativeCredentials } from './native-credentials.js';
 import { PanelButton, Panel } from './panel-components.react.js';
 import { authoritativeKeyserverID } from '../authoritative-keyserver.js';
 import SWMansionIcon from '../components/swmansion-icon.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { nativeLogInExtraInfoSelector } from '../selectors/account-selectors.js';
 import type { KeyPressEvent } from '../types/react-native.js';
 import {
   AppOutOfDateAlertDetails,
   UsernameReservedAlertDetails,
   UsernameTakenAlertDetails,
   UnknownErrorAlertDetails,
 } from '../utils/alert-messages.js';
 import Alert from '../utils/alert.js';
 import { type StateContainer } from '../utils/state-container.js';
 
-type WritableRegisterState = {
+type WritableLegacyRegisterState = {
   usernameInputText: string,
   passwordInputText: string,
   confirmPasswordInputText: string,
 };
-export type RegisterState = $ReadOnly<WritableRegisterState>;
+export type LegacyRegisterState = $ReadOnly<WritableLegacyRegisterState>;
 type BaseProps = {
   +setActiveAlert: (activeAlert: boolean) => void,
   +opacityValue: Animated.Node,
-  +registerState: StateContainer<RegisterState>,
+  +legacyRegisterState: StateContainer<LegacyRegisterState>,
 };
 type Props = {
   ...BaseProps,
   +loadingStatus: LoadingStatus,
   +logInExtraInfo: () => Promise<LogInExtraInfo>,
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
-  +register: (registerInfo: RegisterInfo) => Promise<RegisterResult>,
+  +legacyRegister: (
+    registerInfo: LegacyRegisterInfo,
+  ) => Promise<LegacyRegisterResult>,
   +getInitialNotificationsEncryptedMessage: () => Promise<string>,
 };
 type State = {
   +confirmPasswordFocused: boolean,
 };
-class RegisterPanel extends React.PureComponent<Props, State> {
+class LegacyRegisterPanel extends React.PureComponent<Props, State> {
   state: State = {
     confirmPasswordFocused: false,
   };
   usernameInput: ?TextInput;
   passwordInput: ?TextInput;
   confirmPasswordInput: ?TextInput;
   passwordBeingAutoFilled = false;
 
   render(): React.Node {
     let confirmPasswordTextInputExtraProps;
     if (
       Platform.OS !== 'ios' ||
       this.state.confirmPasswordFocused ||
-      this.props.registerState.state.confirmPasswordInputText.length > 0
+      this.props.legacyRegisterState.state.confirmPasswordInputText.length > 0
     ) {
       confirmPasswordTextInputExtraProps = {
         secureTextEntry: true,
         textContentType: 'password',
       };
     }
 
     let onPasswordKeyPress;
     if (Platform.OS === 'ios') {
       onPasswordKeyPress = this.onPasswordKeyPress;
     }
 
     const privatePolicyNotice = (
       <View style={styles.notice}>
         <Text style={styles.noticeText}>
           By signing up, you agree to our{' '}
           <Text style={styles.hyperlinkText} onPress={this.onTermsOfUsePressed}>
             Terms
           </Text>
           {' & '}
           <Text
             style={styles.hyperlinkText}
             onPress={this.onPrivacyPolicyPressed}
           >
             Privacy Policy
           </Text>
           .
         </Text>
       </View>
     );
 
     return (
       <Panel opacityValue={this.props.opacityValue} style={styles.container}>
         <View style={styles.row}>
           <SWMansionIcon
             name="user-1"
             size={22}
             color="#555"
             style={styles.icon}
           />
           <TextInput
             style={styles.input}
-            value={this.props.registerState.state.usernameInputText}
+            value={this.props.legacyRegisterState.state.usernameInputText}
             onChangeText={this.onChangeUsernameInputText}
             placeholder="Username"
             autoFocus={true}
             autoCorrect={false}
             autoCapitalize="none"
             keyboardType="ascii-capable"
             textContentType="username"
             autoComplete="username-new"
             returnKeyType="next"
             blurOnSubmit={false}
             onSubmitEditing={this.focusPasswordInput}
             editable={this.props.loadingStatus !== 'loading'}
             ref={this.usernameInputRef}
           />
         </View>
         <View style={styles.row}>
           <SWMansionIcon
             name="lock-on"
             size={22}
             color="#555"
             style={styles.icon}
           />
           <TextInput
             style={styles.input}
-            value={this.props.registerState.state.passwordInputText}
+            value={this.props.legacyRegisterState.state.passwordInputText}
             onChangeText={this.onChangePasswordInputText}
             onKeyPress={onPasswordKeyPress}
             placeholder="Password"
             secureTextEntry={true}
             textContentType="password"
             autoComplete="password-new"
             returnKeyType="next"
             blurOnSubmit={false}
             onSubmitEditing={this.focusConfirmPasswordInput}
             editable={this.props.loadingStatus !== 'loading'}
             ref={this.passwordInputRef}
           />
         </View>
         <View style={styles.row}>
           <TextInput
             style={styles.input}
-            value={this.props.registerState.state.confirmPasswordInputText}
+            value={
+              this.props.legacyRegisterState.state.confirmPasswordInputText
+            }
             onChangeText={this.onChangeConfirmPasswordInputText}
             placeholder="Confirm password"
             autoComplete="password-new"
             returnKeyType="go"
             blurOnSubmit={false}
             onSubmitEditing={this.onSubmit}
             onFocus={this.onConfirmPasswordFocus}
             editable={this.props.loadingStatus !== 'loading'}
             ref={this.confirmPasswordInputRef}
             {...confirmPasswordTextInputExtraProps}
           />
         </View>
         <View style={styles.footer}>
           {privatePolicyNotice}
           <PanelButton
             text="SIGN UP"
             loadingStatus={this.props.loadingStatus}
             onSubmit={this.onSubmit}
           />
         </View>
       </Panel>
     );
   }
 
   usernameInputRef = (usernameInput: ?TextInput) => {
     this.usernameInput = usernameInput;
   };
 
   passwordInputRef = (passwordInput: ?TextInput) => {
     this.passwordInput = passwordInput;
   };
 
   confirmPasswordInputRef = (confirmPasswordInput: ?TextInput) => {
     this.confirmPasswordInput = confirmPasswordInput;
   };
 
   focusUsernameInput = () => {
     invariant(this.usernameInput, 'ref should be set');
     this.usernameInput.focus();
   };
 
   focusPasswordInput = () => {
     invariant(this.passwordInput, 'ref should be set');
     this.passwordInput.focus();
   };
 
   focusConfirmPasswordInput = () => {
     invariant(this.confirmPasswordInput, 'ref should be set');
     this.confirmPasswordInput.focus();
   };
 
   onTermsOfUsePressed = () => {
     void Linking.openURL('https://comm.app/terms');
   };
 
   onPrivacyPolicyPressed = () => {
     void Linking.openURL('https://comm.app/privacy');
   };
 
   onChangeUsernameInputText = (text: string) => {
-    this.props.registerState.setState({ usernameInputText: text });
+    this.props.legacyRegisterState.setState({ usernameInputText: text });
   };
 
   onChangePasswordInputText = (text: string) => {
-    const stateUpdate: Partial<WritableRegisterState> = {};
+    const stateUpdate: Partial<WritableLegacyRegisterState> = {};
     stateUpdate.passwordInputText = text;
     if (this.passwordBeingAutoFilled) {
       this.passwordBeingAutoFilled = false;
       stateUpdate.confirmPasswordInputText = text;
     }
-    this.props.registerState.setState(stateUpdate);
+    this.props.legacyRegisterState.setState(stateUpdate);
   };
 
   onPasswordKeyPress = (event: KeyPressEvent) => {
     const { key } = event.nativeEvent;
     if (
       key.length > 1 &&
       key !== 'Backspace' &&
       key !== 'Enter' &&
-      this.props.registerState.state.confirmPasswordInputText.length === 0
+      this.props.legacyRegisterState.state.confirmPasswordInputText.length === 0
     ) {
       this.passwordBeingAutoFilled = true;
     }
   };
 
   onChangeConfirmPasswordInputText = (text: string) => {
-    this.props.registerState.setState({ confirmPasswordInputText: text });
+    this.props.legacyRegisterState.setState({ confirmPasswordInputText: text });
   };
 
   onConfirmPasswordFocus = () => {
     this.setState({ confirmPasswordFocused: true });
   };
 
   onSubmit = async () => {
     this.props.setActiveAlert(true);
-    if (this.props.registerState.state.passwordInputText === '') {
+    if (this.props.legacyRegisterState.state.passwordInputText === '') {
       Alert.alert(
         'Empty password',
         'Password cannot be empty',
         [{ text: 'OK', onPress: this.onPasswordAlertAcknowledged }],
         { cancelable: false },
       );
     } else if (
-      this.props.registerState.state.passwordInputText !==
-      this.props.registerState.state.confirmPasswordInputText
+      this.props.legacyRegisterState.state.passwordInputText !==
+      this.props.legacyRegisterState.state.confirmPasswordInputText
     ) {
       Alert.alert(
         'Passwords don’t match',
         'Password fields must contain the same password',
         [{ text: 'OK', onPress: this.onPasswordAlertAcknowledged }],
         { cancelable: false },
       );
     } else if (
-      this.props.registerState.state.usernameInputText.search(
+      this.props.legacyRegisterState.state.usernameInputText.search(
         validUsernameRegex,
       ) === -1
     ) {
       Alert.alert(
         'Invalid username',
         'Usernames must be at least six characters long, start with either a ' +
           'letter or a number, and may contain only letters, numbers, or the ' +
           'characters “-” and “_”',
         [{ text: 'OK', onPress: this.onUsernameAlertAcknowledged }],
         { cancelable: false },
       );
     } else {
       Keyboard.dismiss();
       const extraInfo = await this.props.logInExtraInfo();
       const initialNotificationsEncryptedMessage =
         await this.props.getInitialNotificationsEncryptedMessage();
       void this.props.dispatchActionPromise(
-        keyserverRegisterActionTypes,
-        this.registerAction({
+        legacyKeyserverRegisterActionTypes,
+        this.legacyRegisterAction({
           ...extraInfo,
           initialNotificationsEncryptedMessage,
         }),
         undefined,
         ({ calendarQuery: extraInfo.calendarQuery }: LogInStartingPayload),
       );
     }
   };
 
   onPasswordAlertAcknowledged = () => {
     this.props.setActiveAlert(false);
-    this.props.registerState.setState(
+    this.props.legacyRegisterState.setState(
       {
         passwordInputText: '',
         confirmPasswordInputText: '',
       },
       () => {
         invariant(this.passwordInput, 'ref should exist');
         this.passwordInput.focus();
       },
     );
   };
 
   onUsernameAlertAcknowledged = () => {
     this.props.setActiveAlert(false);
-    this.props.registerState.setState(
+    this.props.legacyRegisterState.setState(
       {
         usernameInputText: '',
       },
       () => {
         invariant(this.usernameInput, 'ref should exist');
         this.usernameInput.focus();
       },
     );
   };
 
-  async registerAction(extraInfo: LogInExtraInfo): Promise<RegisterResult> {
+  async legacyRegisterAction(
+    extraInfo: LogInExtraInfo,
+  ): Promise<LegacyRegisterResult> {
     try {
-      const result = await this.props.register({
+      const result = await this.props.legacyRegister({
         ...extraInfo,
-        username: this.props.registerState.state.usernameInputText,
-        password: this.props.registerState.state.passwordInputText,
+        username: this.props.legacyRegisterState.state.usernameInputText,
+        password: this.props.legacyRegisterState.state.passwordInputText,
       });
       this.props.setActiveAlert(false);
       this.props.dispatch({
         type: setDataLoadedActionType,
         payload: {
           dataLoaded: true,
         },
       });
       await setNativeCredentials({
         username: result.currentUserInfo.username,
-        password: this.props.registerState.state.passwordInputText,
+        password: this.props.legacyRegisterState.state.passwordInputText,
       });
       return result;
     } catch (e) {
       if (e.message === 'username_reserved') {
         Alert.alert(
           UsernameReservedAlertDetails.title,
           UsernameReservedAlertDetails.message,
           [{ text: 'OK', onPress: this.onUsernameAlertAcknowledged }],
           { cancelable: false },
         );
       } else if (e.message === 'username_taken') {
         Alert.alert(
           UsernameTakenAlertDetails.title,
           UsernameTakenAlertDetails.message,
           [{ text: 'OK', onPress: this.onUsernameAlertAcknowledged }],
           { cancelable: false },
         );
       } else if (e.message === 'client_version_unsupported') {
         Alert.alert(
           AppOutOfDateAlertDetails.title,
           AppOutOfDateAlertDetails.message,
           [{ text: 'OK', onPress: this.onAppOutOfDateAlertAcknowledged }],
           { cancelable: false },
         );
       } else {
         Alert.alert(
           UnknownErrorAlertDetails.title,
           UnknownErrorAlertDetails.message,
           [{ text: 'OK', onPress: this.onUnknownErrorAlertAcknowledged }],
           { cancelable: false },
         );
       }
       throw e;
     }
   }
 
   onUnknownErrorAlertAcknowledged = () => {
     this.props.setActiveAlert(false);
-    this.props.registerState.setState(
+    this.props.legacyRegisterState.setState(
       {
         usernameInputText: '',
         passwordInputText: '',
         confirmPasswordInputText: '',
       },
       () => {
         invariant(this.usernameInput, 'ref should exist');
         this.usernameInput.focus();
       },
     );
   };
 
   onAppOutOfDateAlertAcknowledged = () => {
     this.props.setActiveAlert(false);
   };
 }
 
 const styles = StyleSheet.create({
   container: {
     zIndex: 2,
   },
   footer: {
     alignItems: 'stretch',
     flexDirection: 'row',
     flexShrink: 1,
     justifyContent: 'space-between',
     paddingLeft: 24,
   },
   hyperlinkText: {
     color: '#036AFF',
     fontWeight: 'bold',
   },
   icon: {
     bottom: 10,
     left: 4,
     position: 'absolute',
   },
   input: {
     paddingLeft: 35,
   },
   notice: {
     alignSelf: 'center',
     display: 'flex',
     flexShrink: 1,
     maxWidth: 190,
     paddingBottom: 18,
     paddingRight: 8,
     paddingTop: 12,
   },
   noticeText: {
     color: '#444',
     fontSize: 13,
     lineHeight: 20,
     textAlign: 'center',
   },
   row: {
     marginHorizontal: 24,
   },
 });
 
 const registerLoadingStatusSelector = createLoadingStatusSelector(
-  keyserverRegisterActionTypes,
+  legacyKeyserverRegisterActionTypes,
 );
 const olmSessionInitializationDataLoadingStatusSelector =
   createLoadingStatusSelector(getOlmSessionInitializationDataActionTypes);
 
-const ConnectedRegisterPanel: React.ComponentType<BaseProps> =
-  React.memo<BaseProps>(function ConnectedRegisterPanel(props: BaseProps) {
+const ConnectedLegacyRegisterPanel: React.ComponentType<BaseProps> =
+  React.memo<BaseProps>(function ConnectedLegacyRegisterPanel(
+    props: BaseProps,
+  ) {
     const registerLoadingStatus = useSelector(registerLoadingStatusSelector);
     const olmSessionInitializationDataLoadingStatus = useSelector(
       olmSessionInitializationDataLoadingStatusSelector,
     );
     const loadingStatus = combineLoadingStatuses(
       registerLoadingStatus,
       olmSessionInitializationDataLoadingStatus,
     );
 
     const logInExtraInfo = useSelector(nativeLogInExtraInfoSelector);
 
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
-    const callRegister = useLegacyAshoatKeyserverCall(keyserverRegister);
+    const callLegacyRegister = useLegacyAshoatKeyserverCall(
+      legacyKeyserverRegister,
+    );
     const getInitialNotificationsEncryptedMessage =
       useInitialNotificationsEncryptedMessage(authoritativeKeyserverID);
 
     return (
-      <RegisterPanel
+      <LegacyRegisterPanel
         {...props}
         loadingStatus={loadingStatus}
         logInExtraInfo={logInExtraInfo}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
-        register={callRegister}
+        legacyRegister={callLegacyRegister}
         getInitialNotificationsEncryptedMessage={
           getInitialNotificationsEncryptedMessage
         }
       />
     );
   });
 
-export default ConnectedRegisterPanel;
+export default ConnectedLegacyRegisterPanel;
diff --git a/native/account/logged-out-modal.react.js b/native/account/logged-out-modal.react.js
index c6f99e0b2..fa2adb100 100644
--- a/native/account/logged-out-modal.react.js
+++ b/native/account/logged-out-modal.react.js
@@ -1,819 +1,822 @@
 // @flow
 
 import Icon from '@expo/vector-icons/FontAwesome.js';
 import _isEqual from 'lodash/fp/isEqual.js';
 import * as React from 'react';
 import {
   View,
   Text,
   TouchableOpacity,
   Image,
   Keyboard,
   Platform,
   BackHandler,
   ActivityIndicator,
 } from 'react-native';
 import Animated, { EasingNode } from 'react-native-reanimated';
 import { SafeAreaView } from 'react-native-safe-area-context';
 
 import { setActiveSessionRecoveryActionType } from 'lib/keyserver-conn/keyserver-conn-types.js';
 import { cookieSelector } from 'lib/selectors/keyserver-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { recoveryFromReduxActionSources } from 'lib/types/account-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { usingCommServicesAccessToken } from 'lib/utils/services-utils.js';
 
 import { splashBackgroundURI } from './background-info.js';
 import FullscreenSIWEPanel from './fullscreen-siwe-panel.react.js';
+import LegacyRegisterPanel from './legacy-register-panel.react.js';
+import type { LegacyRegisterState } from './legacy-register-panel.react.js';
 import LogInPanel from './log-in-panel.react.js';
 import type { LogInState } from './log-in-panel.react.js';
 import LoggedOutStaffInfo from './logged-out-staff-info.react.js';
-import RegisterPanel from './register-panel.react.js';
-import type { RegisterState } from './register-panel.react.js';
 import { enableNewRegistrationMode } from './registration/registration-types.js';
 import { authoritativeKeyserverID } from '../authoritative-keyserver.js';
 import KeyboardAvoidingView from '../components/keyboard-avoiding-view.react.js';
 import ConnectedStatusBar from '../connected-status-bar.react.js';
 import {
   addKeyboardShowListener,
   addKeyboardDismissListener,
   removeKeyboardListener,
 } from '../keyboard/keyboard.js';
 import { createIsForegroundSelector } from '../navigation/nav-selectors.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import type { RootNavigationProp } from '../navigation/root-navigator.react.js';
 import {
   type NavigationRoute,
   LoggedOutModalRouteName,
   RegistrationRouteName,
   QRCodeSignInNavigatorRouteName,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { usePersistedStateLoaded } from '../selectors/app-state-selectors.js';
 import {
   type DerivedDimensionsInfo,
   derivedDimensionsInfoSelector,
 } from '../selectors/dimensions-selectors.js';
 import { splashStyleSelector } from '../splash.js';
 import { useStyles } from '../themes/colors.js';
 import type {
   EventSubscription,
   KeyboardEvent,
 } from '../types/react-native.js';
 import type { ImageStyle } from '../types/styles.js';
 import {
   runTiming,
   ratchetAlongWithKeyboardHeight,
 } from '../utils/animation-utils.js';
 import {
   type StateContainer,
   type StateChange,
   setStateForContainer,
 } from '../utils/state-container.js';
 import EthereumLogo from '../vectors/ethereum-logo.react.js';
 
 let initialAppLoad = true;
 const safeAreaEdges = ['top', 'bottom'];
 
 const {
   Value,
   Node,
   Clock,
   block,
   set,
   call,
   cond,
   not,
   and,
   eq,
   neq,
   lessThan,
   greaterOrEq,
   add,
   sub,
   divide,
   max,
   stopClock,
   clockRunning,
 } = Animated;
 
 export type LoggedOutMode =
   | 'loading'
   | 'prompt'
   | 'log-in'
   | 'register'
   | 'siwe';
 const modeNumbers: { [LoggedOutMode]: number } = {
   'loading': 0,
   'prompt': 1,
   'log-in': 2,
   'register': 3,
   'siwe': 4,
 };
 function isPastPrompt(modeValue: Node) {
   return and(
     neq(modeValue, modeNumbers['loading']),
     neq(modeValue, modeNumbers['prompt']),
   );
 }
 
 const unboundStyles = {
   animationContainer: {
     flex: 1,
   },
   backButton: {
     position: 'absolute',
     top: 13,
   },
   button: {
     borderRadius: 4,
     marginBottom: 4,
     marginTop: 4,
     marginLeft: 4,
     marginRight: 4,
     paddingBottom: 14,
     paddingLeft: 18,
     paddingRight: 18,
     paddingTop: 14,
     flex: 1,
   },
   buttonContainer: {
     bottom: 0,
     left: 0,
     marginLeft: 26,
     marginRight: 26,
     paddingBottom: 20,
     position: 'absolute',
     right: 0,
   },
   buttonText: {
     fontFamily: 'OpenSans-Semibold',
     fontSize: 17,
     textAlign: 'center',
   },
   classicAuthButton: {
     backgroundColor: 'purpleButton',
   },
   classicAuthButtonText: {
     color: 'whiteText',
   },
   registerButtons: {
     flexDirection: 'row',
   },
   signInButtons: {
     flexDirection: 'row',
   },
   container: {
     backgroundColor: 'transparent',
     flex: 1,
   },
   header: {
     color: 'white',
     fontFamily: Platform.OS === 'ios' ? 'IBMPlexSans' : 'IBMPlexSans-Medium',
     fontSize: 56,
     fontWeight: '500',
     lineHeight: 66,
     textAlign: 'center',
   },
   loadingIndicator: {
     paddingTop: 15,
   },
   modalBackground: {
     bottom: 0,
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
   siweButton: {
     backgroundColor: 'siweButton',
     flex: 1,
     flexDirection: 'row',
     justifyContent: 'center',
   },
   siweButtonText: {
     color: 'siweButtonText',
   },
   siweOr: {
     flex: 1,
     flexDirection: 'row',
     marginBottom: 18,
     marginTop: 14,
   },
   siweOrLeftHR: {
     borderColor: 'logInSpacer',
     borderTopWidth: 1,
     flex: 1,
     marginRight: 18,
     marginTop: 10,
   },
   siweOrRightHR: {
     borderColor: 'logInSpacer',
     borderTopWidth: 1,
     flex: 1,
     marginLeft: 18,
     marginTop: 10,
   },
   siweOrText: {
     color: 'whiteText',
     fontSize: 17,
     textAlign: 'center',
   },
   siweIcon: {
     paddingRight: 10,
   },
 };
 
 type BaseProps = {
   +navigation: RootNavigationProp<'LoggedOutModal'>,
   +route: NavigationRoute<'LoggedOutModal'>,
 };
 
 type Props = {
   ...BaseProps,
   // Navigation state
   +isForeground: boolean,
   // Redux state
   +persistedStateLoaded: boolean,
   +rehydrateConcluded: boolean,
   +cookie: ?string,
   +loggedIn: boolean,
   +dimensions: DerivedDimensionsInfo,
   +splashStyle: ImageStyle,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatch: Dispatch,
 };
 type State = {
   +mode: LoggedOutMode,
   +nextMode: LoggedOutMode,
   +logInState: StateContainer<LogInState>,
-  +registerState: StateContainer<RegisterState>,
+  +legacyRegisterState: StateContainer<LegacyRegisterState>,
 };
 class LoggedOutModal extends React.PureComponent<Props, State> {
   keyboardShowListener: ?EventSubscription;
   keyboardHideListener: ?EventSubscription;
 
   mounted = false;
   nextMode: LoggedOutMode = 'loading';
   activeAlert = false;
 
   contentHeight: Value;
   keyboardHeightValue: Value = new Value(0);
   modeValue: Value;
 
   buttonOpacity: Value;
   panelPaddingTopValue: Node;
   panelOpacityValue: Node;
 
   constructor(props: Props) {
     super(props);
 
     // Man, this is a lot of boilerplate just to containerize some state.
     // Mostly due to Flow typing requirements...
     const setLogInState = setStateForContainer(
       this.guardedSetState,
       (change: Partial<LogInState>) => (fullState: State) => ({
         logInState: {
           ...fullState.logInState,
           state: { ...fullState.logInState.state, ...change },
         },
       }),
     );
-    const setRegisterState = setStateForContainer<State, RegisterState>(
+    const setLegacyRegisterState = setStateForContainer<
+      State,
+      LegacyRegisterState,
+    >(
       this.guardedSetState,
-      (change: Partial<RegisterState>) => (fullState: State) => ({
-        registerState: {
-          ...fullState.registerState,
-          state: { ...fullState.registerState.state, ...change },
+      (change: Partial<LegacyRegisterState>) => (fullState: State) => ({
+        legacyRegisterState: {
+          ...fullState.legacyRegisterState,
+          state: { ...fullState.legacyRegisterState.state, ...change },
         },
       }),
     );
 
     const initialMode = props.persistedStateLoaded ? 'prompt' : 'loading';
     this.state = {
       mode: initialMode,
       nextMode: initialMode,
       logInState: {
         state: {
           usernameInputText: null,
           passwordInputText: null,
         },
         setState: setLogInState,
       },
-      registerState: {
+      legacyRegisterState: {
         state: {
           usernameInputText: '',
           passwordInputText: '',
           confirmPasswordInputText: '',
         },
-        setState: setRegisterState,
+        setState: setLegacyRegisterState,
       },
     };
     this.nextMode = initialMode;
 
     this.contentHeight = new Value(props.dimensions.safeAreaHeight);
     this.modeValue = new Value(modeNumbers[this.nextMode]);
 
     this.buttonOpacity = new Value(props.persistedStateLoaded ? 1 : 0);
     this.panelPaddingTopValue = this.panelPaddingTop();
     this.panelOpacityValue = this.panelOpacity();
   }
 
   guardedSetState = (change: StateChange<State>, callback?: () => mixed) => {
     if (this.mounted) {
       this.setState(change, callback);
     }
   };
 
   setMode(newMode: LoggedOutMode) {
     this.nextMode = newMode;
     this.guardedSetState({ mode: newMode, nextMode: newMode });
     this.modeValue.setValue(modeNumbers[newMode]);
   }
 
   proceedToNextMode = () => {
     this.guardedSetState({ mode: this.nextMode });
   };
 
   componentDidMount() {
     this.mounted = true;
     if (this.props.rehydrateConcluded) {
       this.onInitialAppLoad();
     }
     if (this.props.isForeground) {
       this.onForeground();
     }
   }
 
   componentWillUnmount() {
     this.mounted = false;
     if (this.props.isForeground) {
       this.onBackground();
     }
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (!prevProps.persistedStateLoaded && this.props.persistedStateLoaded) {
       this.setMode('prompt');
     }
     if (!prevProps.rehydrateConcluded && this.props.rehydrateConcluded) {
       this.onInitialAppLoad();
     }
     if (!prevProps.isForeground && this.props.isForeground) {
       this.onForeground();
     } else if (prevProps.isForeground && !this.props.isForeground) {
       this.onBackground();
     }
 
     if (this.state.mode === 'prompt' && prevState.mode !== 'prompt') {
       this.buttonOpacity.setValue(0);
       Animated.timing(this.buttonOpacity, {
         easing: EasingNode.out(EasingNode.ease),
         duration: 250,
         toValue: 1.0,
       }).start();
     }
 
     const newContentHeight = this.props.dimensions.safeAreaHeight;
     const oldContentHeight = prevProps.dimensions.safeAreaHeight;
     if (newContentHeight !== oldContentHeight) {
       this.contentHeight.setValue(newContentHeight);
     }
   }
 
   onForeground() {
     this.keyboardShowListener = addKeyboardShowListener(this.keyboardShow);
     this.keyboardHideListener = addKeyboardDismissListener(this.keyboardHide);
     BackHandler.addEventListener('hardwareBackPress', this.hardwareBack);
   }
 
   onBackground() {
     if (this.keyboardShowListener) {
       removeKeyboardListener(this.keyboardShowListener);
       this.keyboardShowListener = null;
     }
     if (this.keyboardHideListener) {
       removeKeyboardListener(this.keyboardHideListener);
       this.keyboardHideListener = null;
     }
     BackHandler.removeEventListener('hardwareBackPress', this.hardwareBack);
   }
 
   // This gets triggered when an app is killed and restarted
   // Not when it is returned from being backgrounded
   onInitialAppLoad() {
     if (!initialAppLoad) {
       return;
     }
     initialAppLoad = false;
 
     if (usingCommServicesAccessToken || __DEV__) {
       return;
     }
 
     const { loggedIn, cookie, dispatch } = this.props;
     const hasUserCookie = cookie && cookie.startsWith('user=');
     if (loggedIn === !!hasUserCookie) {
       return;
     }
 
     const actionSource = loggedIn
       ? recoveryFromReduxActionSources.appStartReduxLoggedInButInvalidCookie
       : recoveryFromReduxActionSources.appStartCookieLoggedInButInvalidRedux;
     dispatch({
       type: setActiveSessionRecoveryActionType,
       payload: {
         activeSessionRecovery: actionSource,
         keyserverID: authoritativeKeyserverID,
       },
     });
   }
 
   hardwareBack: () => boolean = () => {
     if (this.nextMode !== 'prompt') {
       this.goBackToPrompt();
       return true;
     }
     return false;
   };
 
   panelPaddingTop(): Node {
     const headerHeight = Platform.OS === 'ios' ? 62.33 : 58.54;
     const promptButtonsSize = Platform.OS === 'ios' ? 40 : 61;
     const logInContainerSize = 140;
     const registerPanelSize = Platform.OS === 'ios' ? 181 : 180;
     const siwePanelSize = 250;
 
     const containerSize = add(
       headerHeight,
       cond(not(isPastPrompt(this.modeValue)), promptButtonsSize, 0),
       cond(eq(this.modeValue, modeNumbers['log-in']), logInContainerSize, 0),
       cond(eq(this.modeValue, modeNumbers['register']), registerPanelSize, 0),
       cond(eq(this.modeValue, modeNumbers['siwe']), siwePanelSize, 0),
     );
     const potentialPanelPaddingTop = divide(
       max(sub(this.contentHeight, this.keyboardHeightValue, containerSize), 0),
       2,
     );
 
     const panelPaddingTop = new Value(-1);
     const targetPanelPaddingTop = new Value(-1);
     const prevModeValue = new Value(modeNumbers[this.nextMode]);
     const clock = new Clock();
     const keyboardTimeoutClock = new Clock();
     return block([
       cond(lessThan(panelPaddingTop, 0), [
         set(panelPaddingTop, potentialPanelPaddingTop),
         set(targetPanelPaddingTop, potentialPanelPaddingTop),
       ]),
       cond(
         lessThan(this.keyboardHeightValue, 0),
         [
           runTiming(keyboardTimeoutClock, 0, 1, true, { duration: 500 }),
           cond(
             not(clockRunning(keyboardTimeoutClock)),
             set(this.keyboardHeightValue, 0),
           ),
         ],
         stopClock(keyboardTimeoutClock),
       ),
       cond(
         and(
           greaterOrEq(this.keyboardHeightValue, 0),
           neq(prevModeValue, this.modeValue),
         ),
         [
           stopClock(clock),
           cond(
             neq(isPastPrompt(prevModeValue), isPastPrompt(this.modeValue)),
             set(targetPanelPaddingTop, potentialPanelPaddingTop),
           ),
           set(prevModeValue, this.modeValue),
         ],
       ),
       ratchetAlongWithKeyboardHeight(this.keyboardHeightValue, [
         stopClock(clock),
         set(targetPanelPaddingTop, potentialPanelPaddingTop),
       ]),
       cond(
         neq(panelPaddingTop, targetPanelPaddingTop),
         set(
           panelPaddingTop,
           runTiming(clock, panelPaddingTop, targetPanelPaddingTop),
         ),
       ),
       panelPaddingTop,
     ]);
   }
 
   panelOpacity(): Node {
     const targetPanelOpacity = isPastPrompt(this.modeValue);
 
     const panelOpacity = new Value(-1);
     const prevPanelOpacity = new Value(-1);
     const prevTargetPanelOpacity = new Value(-1);
     const clock = new Clock();
     return block([
       cond(lessThan(panelOpacity, 0), [
         set(panelOpacity, targetPanelOpacity),
         set(prevPanelOpacity, targetPanelOpacity),
         set(prevTargetPanelOpacity, targetPanelOpacity),
       ]),
       cond(greaterOrEq(this.keyboardHeightValue, 0), [
         cond(neq(targetPanelOpacity, prevTargetPanelOpacity), [
           stopClock(clock),
           set(prevTargetPanelOpacity, targetPanelOpacity),
         ]),
         cond(
           neq(panelOpacity, targetPanelOpacity),
           set(panelOpacity, runTiming(clock, panelOpacity, targetPanelOpacity)),
         ),
       ]),
       cond(
         and(eq(panelOpacity, 0), neq(prevPanelOpacity, 0)),
         call([], this.proceedToNextMode),
       ),
       set(prevPanelOpacity, panelOpacity),
       panelOpacity,
     ]);
   }
 
   keyboardShow = (event: KeyboardEvent) => {
     if (
       event.startCoordinates &&
       _isEqual(event.startCoordinates)(event.endCoordinates)
     ) {
       return;
     }
     const keyboardHeight: number = Platform.select({
       // Android doesn't include the bottomInset in this height measurement
       android: event.endCoordinates.height,
       default: Math.max(
         event.endCoordinates.height - this.props.dimensions.bottomInset,
         0,
       ),
     });
     this.keyboardHeightValue.setValue(keyboardHeight);
   };
 
   keyboardHide = () => {
     if (!this.activeAlert) {
       this.keyboardHeightValue.setValue(0);
     }
   };
 
   setActiveAlert = (activeAlert: boolean) => {
     this.activeAlert = activeAlert;
   };
 
   goBackToPrompt = () => {
     this.nextMode = 'prompt';
     this.guardedSetState({ nextMode: 'prompt' });
     this.keyboardHeightValue.setValue(0);
     this.modeValue.setValue(modeNumbers['prompt']);
     Keyboard.dismiss();
   };
 
   render(): React.Node {
     const { styles } = this.props;
 
     const siweButton = (
       <>
         <TouchableOpacity
           onPress={this.onPressSIWE}
           style={[styles.button, styles.siweButton]}
           activeOpacity={0.6}
         >
           <View style={styles.siweIcon}>
             <EthereumLogo />
           </View>
           <Text style={[styles.buttonText, styles.siweButtonText]}>
             Sign in with Ethereum
           </Text>
         </TouchableOpacity>
         <View style={styles.siweOr}>
           <View style={styles.siweOrLeftHR} />
           <Text style={styles.siweOrText}>or</Text>
           <View style={styles.siweOrRightHR} />
         </View>
       </>
     );
 
     let panel = null;
     let buttons = null;
     if (this.state.mode === 'log-in') {
       panel = (
         <LogInPanel
           setActiveAlert={this.setActiveAlert}
           opacityValue={this.panelOpacityValue}
           logInState={this.state.logInState}
         />
       );
     } else if (this.state.mode === 'register') {
       panel = (
-        <RegisterPanel
+        <LegacyRegisterPanel
           setActiveAlert={this.setActiveAlert}
           opacityValue={this.panelOpacityValue}
-          registerState={this.state.registerState}
+          legacyRegisterState={this.state.legacyRegisterState}
         />
       );
     } else if (this.state.mode === 'prompt') {
       const opacityStyle = { opacity: this.buttonOpacity };
 
       const registerButtons = [];
       registerButtons.push(
         <TouchableOpacity
           onPress={this.onPressRegister}
           style={[styles.button, styles.classicAuthButton]}
           activeOpacity={0.6}
           key="old"
         >
           <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
             Register
           </Text>
         </TouchableOpacity>,
       );
       if (enableNewRegistrationMode) {
         registerButtons.push(
           <TouchableOpacity
             onPress={this.onPressNewRegister}
             style={[styles.button, styles.classicAuthButton]}
             activeOpacity={0.6}
             key="new"
           >
             <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
               Register (new)
             </Text>
           </TouchableOpacity>,
         );
       }
 
       const signInButtons = [];
       signInButtons.push(
         <TouchableOpacity
           onPress={this.onPressLogIn}
           style={[styles.button, styles.classicAuthButton]}
           activeOpacity={0.6}
           key="login-form"
         >
           <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
             Sign in
           </Text>
         </TouchableOpacity>,
       );
       if (__DEV__) {
         signInButtons.push(
           <TouchableOpacity
             onPress={this.onPressQRCodeSignIn}
             style={[styles.button, styles.classicAuthButton]}
             activeOpacity={0.6}
             key="qr-code-login"
           >
             <Text style={[styles.buttonText, styles.classicAuthButtonText]}>
               Sign in (QR)
             </Text>
           </TouchableOpacity>,
         );
       }
 
       buttons = (
         <Animated.View style={[styles.buttonContainer, opacityStyle]}>
           <LoggedOutStaffInfo />
           {siweButton}
           <View style={styles.signInButtons}>{signInButtons}</View>
           <View style={styles.registerButtons}>{registerButtons}</View>
         </Animated.View>
       );
     } else if (this.state.mode === 'loading') {
       panel = (
         <ActivityIndicator
           color="white"
           size="large"
           style={styles.loadingIndicator}
         />
       );
     }
 
     const windowWidth = this.props.dimensions.width;
     const buttonStyle = {
       opacity: this.panelOpacityValue,
       left: windowWidth < 360 ? 28 : 40,
     };
     const padding = { paddingTop: this.panelPaddingTopValue };
 
     const animatedContent = (
       <Animated.View style={[styles.animationContainer, padding]}>
         <View>
           <Text style={styles.header}>Comm</Text>
           <Animated.View style={[styles.backButton, buttonStyle]}>
             <TouchableOpacity activeOpacity={0.6} onPress={this.hardwareBack}>
               <Icon name="arrow-circle-o-left" size={36} color="#FFFFFFAA" />
             </TouchableOpacity>
           </Animated.View>
         </View>
         {panel}
       </Animated.View>
     );
 
     let siwePanel;
     if (this.state.mode === 'siwe') {
       siwePanel = (
         <FullscreenSIWEPanel
           goBackToPrompt={this.goBackToPrompt}
           closing={this.state.nextMode === 'prompt'}
         />
       );
     }
 
     const backgroundSource = { uri: splashBackgroundURI };
     return (
       <React.Fragment>
         <ConnectedStatusBar barStyle="light-content" />
         <Image
           source={backgroundSource}
           style={[styles.modalBackground, this.props.splashStyle]}
         />
         <SafeAreaView style={styles.container} edges={safeAreaEdges}>
           <KeyboardAvoidingView behavior="padding" style={styles.container}>
             {animatedContent}
             {buttons}
           </KeyboardAvoidingView>
         </SafeAreaView>
         {siwePanel}
       </React.Fragment>
     );
   }
 
   onPressSIWE = () => {
     this.setMode('siwe');
   };
 
   onPressLogIn = () => {
     if (Platform.OS !== 'ios') {
       // For some strange reason, iOS's password management logic doesn't
       // realize that the username and password fields in LogInPanel are related
       // if the username field gets focused on mount. To avoid this issue we
       // need the username and password fields to both appear on-screen before
       // we focus the username field. However, when we set keyboardHeightValue
       // to -1 here, we are telling our Reanimated logic to wait until the
       // keyboard appears before showing LogInPanel. Since we need LogInPanel
       // to appear before the username field is focused, we need to avoid this
       // behavior on iOS.
       this.keyboardHeightValue.setValue(-1);
     }
     this.setMode('log-in');
   };
 
   onPressQRCodeSignIn = () => {
     this.props.navigation.navigate(QRCodeSignInNavigatorRouteName);
   };
 
   onPressRegister = () => {
     this.keyboardHeightValue.setValue(-1);
     this.setMode('register');
   };
 
   onPressNewRegister = () => {
     this.props.navigation.navigate(RegistrationRouteName);
   };
 }
 
 const isForegroundSelector = createIsForegroundSelector(
   LoggedOutModalRouteName,
 );
 
 const ConnectedLoggedOutModal: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedLoggedOutModal(props: BaseProps) {
     const navContext = React.useContext(NavContext);
     const isForeground = isForegroundSelector(navContext);
 
     const rehydrateConcluded = useSelector(
       state => !!(state._persist && state._persist.rehydrated && navContext),
     );
     const persistedStateLoaded = usePersistedStateLoaded();
     const cookie = useSelector(cookieSelector(authoritativeKeyserverID));
     const loggedIn = useSelector(isLoggedIn);
     const dimensions = useSelector(derivedDimensionsInfoSelector);
     const splashStyle = useSelector(splashStyleSelector);
     const styles = useStyles(unboundStyles);
 
     const dispatch = useDispatch();
     return (
       <LoggedOutModal
         {...props}
         isForeground={isForeground}
         persistedStateLoaded={persistedStateLoaded}
         rehydrateConcluded={rehydrateConcluded}
         cookie={cookie}
         loggedIn={loggedIn}
         dimensions={dimensions}
         splashStyle={splashStyle}
         styles={styles}
         dispatch={dispatch}
       />
     );
   });
 
 export default ConnectedLoggedOutModal;
diff --git a/native/account/registration/registration-server-call.js b/native/account/registration/registration-server-call.js
index 3a059d7f9..cfc271967 100644
--- a/native/account/registration/registration-server-call.js
+++ b/native/account/registration/registration-server-call.js
@@ -1,421 +1,423 @@
 // @flow
 
 import * as React from 'react';
 
 import { setDataLoadedActionType } from 'lib/actions/client-db-store-actions.js';
 import { setSyncedMetadataEntryActionType } from 'lib/actions/synced-metadata-actions.js';
 import {
-  keyserverRegisterActionTypes,
-  keyserverRegister,
+  legacyKeyserverRegisterActionTypes,
+  legacyKeyserverRegister,
   useIdentityPasswordRegister,
   identityRegisterActionTypes,
 } from 'lib/actions/user-actions.js';
 import { useKeyserverAuth } from 'lib/keyserver-conn/keyserver-auth.js';
 import { useLegacyAshoatKeyserverCall } from 'lib/keyserver-conn/legacy-keyserver-call.js';
 import { isLoggedInToKeyserver } from 'lib/selectors/user-selectors.js';
 import {
   type LogInStartingPayload,
   logInActionSources,
 } from 'lib/types/account-types.js';
 import { syncedMetadataNames } from 'lib/types/synced-metadata-types.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { usingCommServicesAccessToken } from 'lib/utils/services-utils.js';
 import { setURLPrefix } from 'lib/utils/url-utils.js';
 
 import type {
   RegistrationServerCallInput,
   UsernameAccountSelection,
   AvatarData,
 } from './registration-types.js';
 import { authoritativeKeyserverID } from '../../authoritative-keyserver.js';
 import {
   useNativeSetUserAvatar,
   useUploadSelectedMedia,
 } from '../../avatars/avatar-hooks.js';
 import { commCoreModule } from '../../native-modules.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { nativeLogInExtraInfoSelector } from '../../selectors/account-selectors.js';
 import {
   AppOutOfDateAlertDetails,
   UsernameReservedAlertDetails,
   UsernameTakenAlertDetails,
   UnknownErrorAlertDetails,
 } from '../../utils/alert-messages.js';
 import Alert from '../../utils/alert.js';
 import { setNativeCredentials } from '../native-credentials.js';
 import {
   useLegacySIWEServerCall,
   useIdentityWalletRegisterCall,
 } from '../siwe-hooks.js';
 
 // We can't just do everything in one async callback, since the server calls
 // would get bound to Redux state from before the registration. The registration
 // flow has multiple steps where critical Redux state is changed, where
 // subsequent steps depend on accessing the updated Redux state.
 
 // To address this, we break the registration process up into multiple steps.
 // When each step completes we update the currentStep state, and we have Redux
 // selectors that trigger useEffects for subsequent steps when relevant data
 // starts to appear in Redux.
 
 type CurrentStep =
   | { +step: 'inactive' }
   | {
       +step: 'identity_registration_dispatched',
       +clearCachedSelections: () => void,
       +avatarData: ?AvatarData,
       +credentialsToSave: ?{ +username: string, +password: string },
       +resolve: () => void,
       +reject: Error => void,
     }
   | {
       +step: 'authoritative_keyserver_registration_dispatched',
       +clearCachedSelections: () => void,
       +avatarData: ?AvatarData,
       +credentialsToSave: ?{ +username: string, +password: string },
       +resolve: () => void,
       +reject: Error => void,
     };
 
 const inactiveStep = { step: 'inactive' };
 
 function useRegistrationServerCall(): RegistrationServerCallInput => Promise<void> {
   const [currentStep, setCurrentStep] =
     React.useState<CurrentStep>(inactiveStep);
 
   // STEP 1: ACCOUNT REGISTRATION
 
   const logInExtraInfo = useSelector(nativeLogInExtraInfoSelector);
 
   const dispatchActionPromise = useDispatchActionPromise();
-  const callKeyserverRegister = useLegacyAshoatKeyserverCall(keyserverRegister);
+  const callLegacyKeyserverRegister = useLegacyAshoatKeyserverCall(
+    legacyKeyserverRegister,
+  );
   const callIdentityPasswordRegister = useIdentityPasswordRegister();
 
   const identityRegisterUsernameAccount = React.useCallback(
     async (
       accountSelection: UsernameAccountSelection,
       farcasterID: ?string,
     ) => {
       const identityRegisterPromise = (async () => {
         try {
           return await callIdentityPasswordRegister(
             accountSelection.username,
             accountSelection.password,
             farcasterID,
           );
         } catch (e) {
           if (e.message === 'username reserved') {
             Alert.alert(
               UsernameReservedAlertDetails.title,
               UsernameReservedAlertDetails.message,
             );
           } else if (e.message === 'username already exists') {
             Alert.alert(
               UsernameTakenAlertDetails.title,
               UsernameTakenAlertDetails.message,
             );
           } else if (e.message === 'Unsupported version') {
             Alert.alert(
               AppOutOfDateAlertDetails.title,
               AppOutOfDateAlertDetails.message,
             );
           } else {
             Alert.alert(
               UnknownErrorAlertDetails.title,
               UnknownErrorAlertDetails.message,
             );
           }
           throw e;
         }
       })();
       void dispatchActionPromise(
         identityRegisterActionTypes,
         identityRegisterPromise,
       );
       await identityRegisterPromise;
     },
     [callIdentityPasswordRegister, dispatchActionPromise],
   );
 
-  const keyserverRegisterUsernameAccount = React.useCallback(
+  const legacyKeyserverRegisterUsernameAccount = React.useCallback(
     async (
       accountSelection: UsernameAccountSelection,
       keyserverURL: string,
     ) => {
       const extraInfo = await logInExtraInfo();
-      const keyserverRegisterPromise = (async () => {
+      const legacyKeyserverRegisterPromise = (async () => {
         try {
-          return await callKeyserverRegister(
+          return await callLegacyKeyserverRegister(
             {
               ...extraInfo,
               username: accountSelection.username,
               password: accountSelection.password,
             },
             {
               urlPrefixOverride: keyserverURL,
             },
           );
         } catch (e) {
           if (e.message === 'username_reserved') {
             Alert.alert(
               UsernameReservedAlertDetails.title,
               UsernameReservedAlertDetails.message,
             );
           } else if (e.message === 'username_taken') {
             Alert.alert(
               UsernameTakenAlertDetails.title,
               UsernameTakenAlertDetails.message,
             );
           } else if (e.message === 'client_version_unsupported') {
             Alert.alert(
               AppOutOfDateAlertDetails.title,
               AppOutOfDateAlertDetails.message,
             );
           } else {
             Alert.alert(
               UnknownErrorAlertDetails.title,
               UnknownErrorAlertDetails.message,
             );
           }
           throw e;
         }
       })();
       void dispatchActionPromise(
-        keyserverRegisterActionTypes,
-        keyserverRegisterPromise,
+        legacyKeyserverRegisterActionTypes,
+        legacyKeyserverRegisterPromise,
         undefined,
         ({ calendarQuery: extraInfo.calendarQuery }: LogInStartingPayload),
       );
-      await keyserverRegisterPromise;
+      await legacyKeyserverRegisterPromise;
     },
-    [logInExtraInfo, callKeyserverRegister, dispatchActionPromise],
+    [logInExtraInfo, callLegacyKeyserverRegister, dispatchActionPromise],
   );
 
   const legacySiweServerCall = useLegacySIWEServerCall();
   const identityWalletRegisterCall = useIdentityWalletRegisterCall();
   const dispatch = useDispatch();
   const returnedFunc = React.useCallback(
     (input: RegistrationServerCallInput) =>
       new Promise<void>(
         // eslint-disable-next-line no-async-promise-executor
         async (resolve, reject) => {
           try {
             if (currentStep.step !== 'inactive') {
               return;
             }
             const {
               accountSelection,
               avatarData,
               keyserverURL,
               farcasterID,
               siweBackupSecrets,
               clearCachedSelections,
             } = input;
             if (
               accountSelection.accountType === 'username' &&
               !usingCommServicesAccessToken
             ) {
-              await keyserverRegisterUsernameAccount(
+              await legacyKeyserverRegisterUsernameAccount(
                 accountSelection,
                 keyserverURL,
               );
             } else if (accountSelection.accountType === 'username') {
               await identityRegisterUsernameAccount(
                 accountSelection,
                 farcasterID,
               );
             } else if (!usingCommServicesAccessToken) {
               try {
                 await legacySiweServerCall(accountSelection, {
                   urlPrefixOverride: keyserverURL,
                 });
               } catch (e) {
                 Alert.alert(
                   UnknownErrorAlertDetails.title,
                   UnknownErrorAlertDetails.message,
                 );
                 throw e;
               }
             } else {
               try {
                 await identityWalletRegisterCall({
                   address: accountSelection.address,
                   message: accountSelection.message,
                   signature: accountSelection.signature,
                   fid: farcasterID,
                 });
               } catch (e) {
                 Alert.alert(
                   UnknownErrorAlertDetails.title,
                   UnknownErrorAlertDetails.message,
                 );
                 throw e;
               }
             }
             dispatch({
               type: setURLPrefix,
               payload: keyserverURL,
             });
             if (farcasterID) {
               dispatch({
                 type: setSyncedMetadataEntryActionType,
                 payload: {
                   name: syncedMetadataNames.CURRENT_USER_FID,
                   data: farcasterID,
                 },
               });
             }
             if (siweBackupSecrets) {
               await commCoreModule.setSIWEBackupSecrets(siweBackupSecrets);
             }
             const credentialsToSave =
               accountSelection.accountType === 'username'
                 ? {
                     username: accountSelection.username,
                     password: accountSelection.password,
                   }
                 : null;
             setCurrentStep({
               step: 'identity_registration_dispatched',
               avatarData,
               clearCachedSelections,
               credentialsToSave,
               resolve,
               reject,
             });
           } catch (e) {
             reject(e);
           }
         },
       ),
     [
       currentStep,
-      keyserverRegisterUsernameAccount,
+      legacyKeyserverRegisterUsernameAccount,
       identityRegisterUsernameAccount,
       legacySiweServerCall,
       dispatch,
       identityWalletRegisterCall,
     ],
   );
 
   // STEP 2: REGISTERING ON AUTHORITATIVE KEYSERVER
 
   const keyserverAuth = useKeyserverAuth(authoritativeKeyserverID);
 
   const isRegisteredOnIdentity = useSelector(
     state =>
       !!state.commServicesAccessToken &&
       !!state.currentUserInfo &&
       !state.currentUserInfo.anonymous,
   );
 
   const registeringOnAuthoritativeKeyserverRef = React.useRef(false);
   React.useEffect(() => {
     if (
       !isRegisteredOnIdentity ||
       currentStep.step !== 'identity_registration_dispatched' ||
       registeringOnAuthoritativeKeyserverRef.current
     ) {
       return;
     }
     registeringOnAuthoritativeKeyserverRef.current = true;
     const {
       avatarData,
       clearCachedSelections,
       credentialsToSave,
       resolve,
       reject,
     } = currentStep;
     void (async () => {
       try {
         await keyserverAuth({
           authActionSource: process.env.BROWSER
             ? logInActionSources.keyserverAuthFromWeb
             : logInActionSources.keyserverAuthFromNative,
           setInProgress: () => {},
           hasBeenCancelled: () => false,
           doNotRegister: false,
         });
         setCurrentStep({
           step: 'authoritative_keyserver_registration_dispatched',
           avatarData,
           clearCachedSelections,
           credentialsToSave,
           resolve,
           reject,
         });
       } catch (e) {
         reject(e);
         setCurrentStep(inactiveStep);
       } finally {
         registeringOnAuthoritativeKeyserverRef.current = false;
       }
     })();
   }, [currentStep, isRegisteredOnIdentity, keyserverAuth]);
 
   // STEP 3: SETTING AVATAR
 
   const uploadSelectedMedia = useUploadSelectedMedia();
   const nativeSetUserAvatar = useNativeSetUserAvatar();
 
   const isLoggedInToAuthoritativeKeyserver = useSelector(
     isLoggedInToKeyserver(authoritativeKeyserverID),
   );
 
   const avatarBeingSetRef = React.useRef(false);
   React.useEffect(() => {
     if (
       !isLoggedInToAuthoritativeKeyserver ||
       currentStep.step !== 'authoritative_keyserver_registration_dispatched' ||
       avatarBeingSetRef.current
     ) {
       return;
     }
     avatarBeingSetRef.current = true;
     const { avatarData, resolve, clearCachedSelections, credentialsToSave } =
       currentStep;
     void (async () => {
       try {
         if (!avatarData) {
           return;
         }
         let updateUserAvatarRequest;
         if (!avatarData.needsUpload) {
           ({ updateUserAvatarRequest } = avatarData);
         } else {
           const { mediaSelection } = avatarData;
           updateUserAvatarRequest = await uploadSelectedMedia(mediaSelection);
           if (!updateUserAvatarRequest) {
             return;
           }
         }
         await nativeSetUserAvatar(updateUserAvatarRequest);
       } finally {
         dispatch({
           type: setDataLoadedActionType,
           payload: {
             dataLoaded: true,
           },
         });
         clearCachedSelections();
         if (credentialsToSave) {
           void setNativeCredentials(credentialsToSave);
         }
         setCurrentStep(inactiveStep);
         avatarBeingSetRef.current = false;
         resolve();
       }
     })();
   }, [
     currentStep,
     isLoggedInToAuthoritativeKeyserver,
     uploadSelectedMedia,
     nativeSetUserAvatar,
     dispatch,
   ]);
 
   return returnedFunc;
 }
 
 export { useRegistrationServerCall };