diff --git a/lib/hooks/login-hooks.js b/lib/hooks/login-hooks.js
index 117659669..d49f7fed0 100644
--- a/lib/hooks/login-hooks.js
+++ b/lib/hooks/login-hooks.js
@@ -1,190 +1,192 @@
 // @flow
 
 import * as React from 'react';
 
 import { setDataLoadedActionType } from '../actions/client-db-store-actions.js';
 import {
   identityLogInActionTypes,
   useIdentityPasswordLogIn,
   useIdentityWalletLogIn,
   logOutActionTypes,
   useIdentityLogOut,
 } from '../actions/user-actions.js';
 import { useKeyserverAuth } from '../keyserver-conn/keyserver-auth.js';
 import { logInActionSources } from '../types/account-types.js';
 import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
 import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
 import { useSelector, useDispatch } from '../utils/redux-utils.js';
+import { waitUntilDatabaseDeleted } from '../utils/wait-until-db-deleted.js';
 
 // We can't just do everything in one async callback, since the server calls
 // would get bound to Redux state from before the login. In order to pick up the
 // updated CSAT and currentUserInfo from Redux, we break the login into two
 // steps.
 
 type CurrentStep =
   | { +step: 'inactive' }
   | {
       +step: 'identity_login_dispatched',
       +resolve: () => void,
       +reject: Error => void,
     };
 
 const inactiveStep = { step: 'inactive' };
 
 type LogInInputs =
   | {
       +accountType: 'username',
       +username: string,
       +password: string,
     }
   | {
       +accountType: 'ethereum',
       +walletAddress: string,
       +siweMessage: string,
       +siweSignature: string,
     };
 
 function useLogIn(): LogInInputs => Promise<void> {
   const [currentStep, setCurrentStep] =
     React.useState<CurrentStep>(inactiveStep);
 
   const identityPasswordLogIn = useIdentityPasswordLogIn();
   const identityWalletLogIn = useIdentityWalletLogIn();
   const dispatchActionPromise = useDispatchActionPromise();
   const returnedFunc = React.useCallback(
     (logInInputs: LogInInputs) =>
       new Promise<void>(
         // eslint-disable-next-line no-async-promise-executor
         async (resolve, reject) => {
           if (currentStep.step !== 'inactive') {
             return;
           }
           const action =
             logInInputs.accountType === 'username'
               ? identityPasswordLogIn(
                   logInInputs.username,
                   logInInputs.password,
                 )
               : identityWalletLogIn(
                   logInInputs.walletAddress,
                   logInInputs.siweMessage,
                   logInInputs.siweSignature,
                 );
           void dispatchActionPromise(identityLogInActionTypes, action);
           try {
             await action;
             setCurrentStep({
               step: 'identity_login_dispatched',
               resolve,
               reject,
             });
           } catch (e) {
             reject(e);
           }
         },
       ),
     [
       currentStep,
       dispatchActionPromise,
       identityPasswordLogIn,
       identityWalletLogIn,
     ],
   );
 
   const keyserverAuth = useKeyserverAuth(authoritativeKeyserverID());
 
   const isRegisteredOnIdentity = useSelector(
     state =>
       !!state.commServicesAccessToken &&
       !!state.currentUserInfo &&
       !state.currentUserInfo.anonymous,
   );
 
   // We call identityLogOut in order to reset state if identity auth succeeds
   // but authoritative keyserver auth fails
   const identityLogOut = useIdentityLogOut();
 
   const registeringOnAuthoritativeKeyserverRef = React.useRef(false);
   const dispatch = useDispatch();
   React.useEffect(() => {
     if (
       !isRegisteredOnIdentity ||
       currentStep.step !== 'identity_login_dispatched' ||
       registeringOnAuthoritativeKeyserverRef.current
     ) {
       return;
     }
     registeringOnAuthoritativeKeyserverRef.current = true;
     const { resolve, reject } = currentStep;
     void (async () => {
       try {
         await keyserverAuth({
           authActionSource: process.env.BROWSER
             ? logInActionSources.keyserverAuthFromWeb
             : logInActionSources.keyserverAuthFromNative,
           setInProgress: () => {},
           hasBeenCancelled: () => false,
           doNotRegister: false,
         });
         dispatch({
           type: setDataLoadedActionType,
           payload: {
             dataLoaded: true,
           },
         });
         resolve();
       } catch (e) {
         void dispatchActionPromise(logOutActionTypes, identityLogOut());
+        await waitUntilDatabaseDeleted();
         reject(e);
       } finally {
         setCurrentStep(inactiveStep);
         registeringOnAuthoritativeKeyserverRef.current = false;
       }
     })();
   }, [
     currentStep,
     isRegisteredOnIdentity,
     keyserverAuth,
     dispatch,
     dispatchActionPromise,
     identityLogOut,
   ]);
 
   return returnedFunc;
 }
 
 function usePasswordLogIn(): (
   username: string,
   password: string,
 ) => Promise<void> {
   const logIn = useLogIn();
   return React.useCallback(
     (username: string, password: string) =>
       logIn({
         accountType: 'username',
         username,
         password,
       }),
     [logIn],
   );
 }
 
 function useWalletLogIn(): (
   walletAddress: string,
   siweMessage: string,
   siweSignature: string,
 ) => Promise<void> {
   const logIn = useLogIn();
   return React.useCallback(
     (walletAddress: string, siweMessage: string, siweSignature: string) =>
       logIn({
         accountType: 'ethereum',
         walletAddress,
         siweMessage,
         siweSignature,
       }),
     [logIn],
   );
 }
 
 export { usePasswordLogIn, useWalletLogIn };
diff --git a/lib/utils/wait-until-db-deleted.js b/lib/utils/wait-until-db-deleted.js
new file mode 100644
index 000000000..abeaf6f0b
--- /dev/null
+++ b/lib/utils/wait-until-db-deleted.js
@@ -0,0 +1,20 @@
+// @flow
+
+let waitingOnDatabaseDeletion = [];
+
+function waitUntilDatabaseDeleted(): Promise<void> {
+  return new Promise(resolve => {
+    waitingOnDatabaseDeletion.push(resolve);
+  });
+}
+
+function reportDatabaseDeleted() {
+  const callbacksToTrigger = waitingOnDatabaseDeletion;
+  waitingOnDatabaseDeletion = [];
+
+  for (const callback of callbacksToTrigger) {
+    callback();
+  }
+}
+
+export { waitUntilDatabaseDeleted, reportDatabaseDeleted };
diff --git a/native/account/registration/registration-server-call.js b/native/account/registration/registration-server-call.js
index 78837f5a4..b0edf1efb 100644
--- a/native/account/registration/registration-server-call.js
+++ b/native/account/registration/registration-server-call.js
@@ -1,454 +1,456 @@
 // @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 {
   legacyKeyserverRegisterActionTypes,
   legacyKeyserverRegister,
   useIdentityPasswordRegister,
   identityRegisterActionTypes,
   deleteAccountActionTypes,
   useDeleteDiscardedIdentityAccount,
 } 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 LegacyLogInStartingPayload,
   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 { waitUntilDatabaseDeleted } from 'lib/utils/wait-until-db-deleted.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 { nativeLegacyLogInExtraInfoSelector } 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 legacyLogInExtraInfo = useSelector(nativeLegacyLogInExtraInfoSelector);
 
   const dispatchActionPromise = useDispatchActionPromise();
   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 legacyKeyserverRegisterUsernameAccount = React.useCallback(
     async (
       accountSelection: UsernameAccountSelection,
       keyserverURL: string,
     ) => {
       const extraInfo = await legacyLogInExtraInfo();
       const legacyKeyserverRegisterPromise = (async () => {
         try {
           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(
         legacyKeyserverRegisterActionTypes,
         legacyKeyserverRegisterPromise,
         undefined,
         ({
           calendarQuery: extraInfo.calendarQuery,
         }: LegacyLogInStartingPayload),
       );
       await legacyKeyserverRegisterPromise;
     },
     [legacyLogInExtraInfo, 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 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,
       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,
   );
 
   // We call deleteDiscardedIdentityAccount in order to reset state if identity
   // registration succeeds but authoritative keyserver auth fails
   const deleteDiscardedIdentityAccount = useDeleteDiscardedIdentityAccount();
 
   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 (keyserverAuthException) {
         const discardIdentityAccountPromise = (async () => {
           try {
             return await deleteDiscardedIdentityAccount();
           } catch (deleteException) {
             Alert.alert(
               'Account created but login failed',
               'We were able to create your account, but were unable to log ' +
                 'you in. Try going back to the login screen and logging in ' +
                 'with your new credentials.',
             );
             throw deleteException;
           }
         })();
         void dispatchActionPromise(
           deleteAccountActionTypes,
           discardIdentityAccountPromise,
         );
+        await waitUntilDatabaseDeleted();
         reject(keyserverAuthException);
         setCurrentStep(inactiveStep);
       } finally {
         registeringOnAuthoritativeKeyserverRef.current = false;
       }
     })();
   }, [
     currentStep,
     isRegisteredOnIdentity,
     keyserverAuth,
     dispatchActionPromise,
     deleteDiscardedIdentityAccount,
   ]);
 
   // 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 };
diff --git a/native/data/sqlite-data-handler.js b/native/data/sqlite-data-handler.js
index 6c0f563cb..4fe9b7545 100644
--- a/native/data/sqlite-data-handler.js
+++ b/native/data/sqlite-data-handler.js
@@ -1,316 +1,318 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
 import type { CallSingleKeyserverEndpoint } from 'lib/keyserver-conn/call-single-keyserver-endpoint.js';
 import type { CallKeyserverEndpoint } from 'lib/keyserver-conn/keyserver-conn-types.js';
 import { useKeyserverRecoveryLogIn } from 'lib/keyserver-conn/recovery-utils.js';
 import { auxUserStoreOpsHandlers } from 'lib/ops/aux-user-store-ops.js';
 import { communityStoreOpsHandlers } from 'lib/ops/community-store-ops.js';
 import { integrityStoreOpsHandlers } from 'lib/ops/integrity-store-ops.js';
 import { keyserverStoreOpsHandlers } from 'lib/ops/keyserver-store-ops.js';
 import { reportStoreOpsHandlers } from 'lib/ops/report-store-ops.js';
 import { syncedMetadataStoreOpsHandlers } from 'lib/ops/synced-metadata-store-ops.js';
 import { threadActivityStoreOpsHandlers } from 'lib/ops/thread-activity-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import { userStoreOpsHandlers } from 'lib/ops/user-store-ops.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { useInitialNotificationsEncryptedMessage } from 'lib/shared/crypto-utils.js';
 import { shouldClearData } from 'lib/shared/data-utils.js';
 import {
   recoveryFromDataHandlerActionSources,
   type RecoveryFromDataHandlerActionSource,
 } from 'lib/types/account-types.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { supportingMultipleKeyservers } from 'lib/utils/services-utils.js';
+import { reportDatabaseDeleted } from 'lib/utils/wait-until-db-deleted.js';
 
 import { resolveKeyserverSessionInvalidationUsingNativeCredentials } from '../account/legacy-recover-keyserver-session.js';
 import { authoritativeKeyserverID } from '../authoritative-keyserver.js';
 import { filesystemMediaCache } from '../media/media-cache.js';
 import { commCoreModule } from '../native-modules.js';
 import { setStoreLoadedActionType } from '../redux/action-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 import Alert from '../utils/alert.js';
 import { isTaskCancelledError } from '../utils/error-handling.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 async function clearSensitiveData() {
   try {
     await commCoreModule.clearSensitiveData();
+    reportDatabaseDeleted();
   } catch (error) {
     console.log(
       `Error clearing SQLite database: ${
         getMessageForException(error) ?? 'unknown'
       }`,
     );
     throw error;
   }
   try {
     await filesystemMediaCache.clearCache();
   } catch {
     throw new Error('clear_media_cache_failed');
   }
 }
 
 const returnsFalseSinceDoesntNeedToSupportCancellation = () => false;
 
 function SQLiteDataHandler(): React.Node {
   const storeLoaded = useSelector(state => state.storeLoaded);
 
   const dispatch = useDispatch();
   const dispatchActionPromise = useDispatchActionPromise();
 
   const rehydrateConcluded = useSelector(
     state => !!(state._persist && state._persist.rehydrated),
   );
   const staffCanSee = useStaffCanSee();
   const loggedIn = useSelector(isLoggedIn);
   const currentLoggedInUserID = useSelector(state =>
     state.currentUserInfo?.anonymous ? undefined : state.currentUserInfo?.id,
   );
   const mediaCacheContext = React.useContext(MediaCacheContext);
   const getInitialNotificationsEncryptedMessage =
     useInitialNotificationsEncryptedMessage(authoritativeKeyserverID);
 
   const keyserverRecoveryLogIn = useKeyserverRecoveryLogIn(
     authoritativeKeyserverID,
   );
   const recoverDataFromAuthoritativeKeyserver = React.useCallback(
     async (source: RecoveryFromDataHandlerActionSource) => {
       const innerRecoverDataFromAuthoritativeKeyserver = (
         callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
         callKeyserverEndpoint: CallKeyserverEndpoint,
       ) =>
         resolveKeyserverSessionInvalidationUsingNativeCredentials(
           callSingleKeyserverEndpoint,
           callKeyserverEndpoint,
           dispatchActionPromise,
           source,
           authoritativeKeyserverID,
           getInitialNotificationsEncryptedMessage,
           returnsFalseSinceDoesntNeedToSupportCancellation,
         );
       try {
         await keyserverRecoveryLogIn(
           source,
           innerRecoverDataFromAuthoritativeKeyserver,
           returnsFalseSinceDoesntNeedToSupportCancellation,
         );
         dispatch({ type: setStoreLoadedActionType });
       } catch (fetchCookieException) {
         if (staffCanSee) {
           Alert.alert(
             `Error fetching new cookie from native credentials: ${
               getMessageForException(fetchCookieException) ??
               '{no exception message}'
             }. Please kill the app.`,
           );
         } else {
           commCoreModule.terminate();
         }
       }
     },
     [
       dispatch,
       dispatchActionPromise,
       keyserverRecoveryLogIn,
       staffCanSee,
       getInitialNotificationsEncryptedMessage,
     ],
   );
 
   const recoverData = React.useCallback(
     (source: RecoveryFromDataHandlerActionSource) => {
       if (supportingMultipleKeyservers) {
         invariant(
           false,
           'recoverData in SQLiteDataHandler is not yet implemented when ' +
             'supportingMultipleKeyservers is enabled. It should recover ' +
             'from broken SQLite state by restoring from backup service',
         );
       }
       return recoverDataFromAuthoritativeKeyserver(source);
     },
     [recoverDataFromAuthoritativeKeyserver],
   );
 
   const callClearSensitiveData = React.useCallback(
     async (triggeredBy: string) => {
       await clearSensitiveData();
       console.log(`SQLite database deletion was triggered by ${triggeredBy}`);
     },
     [],
   );
 
   const handleSensitiveData = React.useCallback(async () => {
     try {
       let sqliteStampedUserID,
         errorGettingStampedUserID = false;
       try {
         sqliteStampedUserID = await commCoreModule.getSQLiteStampedUserID();
       } catch (error) {
         errorGettingStampedUserID = true;
         console.log(
           `Error getting SQLite stamped user ID: ${
             getMessageForException(error) ?? 'unknown'
           }`,
         );
       }
       if (
         errorGettingStampedUserID ||
         shouldClearData(sqliteStampedUserID, currentLoggedInUserID)
       ) {
         await callClearSensitiveData('change in logged-in user credentials');
       }
       if (
         currentLoggedInUserID &&
         currentLoggedInUserID !== sqliteStampedUserID
       ) {
         await commCoreModule.stampSQLiteDBUserID(currentLoggedInUserID);
       }
     } catch (e) {
       if (isTaskCancelledError(e)) {
         return;
       }
       if (__DEV__) {
         throw e;
       }
       console.log(e);
       if (e.message !== 'clear_media_cache_failed') {
         commCoreModule.terminate();
       }
     }
   }, [callClearSensitiveData, currentLoggedInUserID]);
 
   React.useEffect(() => {
     if (!rehydrateConcluded) {
       return;
     }
 
     const databaseNeedsDeletion = commCoreModule.checkIfDatabaseNeedsDeletion();
     if (databaseNeedsDeletion) {
       void (async () => {
         try {
           await callClearSensitiveData('detecting corrupted database');
         } catch (e) {
           if (__DEV__) {
             throw e;
           }
           console.log(e);
           if (e.message !== 'clear_media_cache_failed') {
             commCoreModule.terminate();
           }
         }
         await recoverData(
           recoveryFromDataHandlerActionSources.corruptedDatabaseDeletion,
         );
       })();
       return;
     }
 
     const sensitiveDataHandled = handleSensitiveData();
     if (storeLoaded) {
       return;
     }
     if (!loggedIn) {
       dispatch({ type: setStoreLoadedActionType });
       return;
     }
     void (async () => {
       await Promise.all([
         sensitiveDataHandled,
         mediaCacheContext?.evictCache(),
       ]);
       try {
         const {
           threads,
           messages,
           drafts,
           messageStoreThreads,
           reports,
           users,
           keyservers,
           communities,
           integrityThreadHashes,
           syncedMetadata,
           auxUserInfos,
           threadActivityEntries,
         } = await commCoreModule.getClientDBStore();
         const threadInfosFromDB =
           threadStoreOpsHandlers.translateClientDBData(threads);
         const reportsFromDB =
           reportStoreOpsHandlers.translateClientDBData(reports);
         const usersFromDB = userStoreOpsHandlers.translateClientDBData(users);
         const keyserverInfosFromDB =
           keyserverStoreOpsHandlers.translateClientDBData(keyservers);
         const communityInfosFromDB =
           communityStoreOpsHandlers.translateClientDBData(communities);
         const threadHashesFromDB =
           integrityStoreOpsHandlers.translateClientDBData(
             integrityThreadHashes,
           );
         const syncedMetadataFromDB =
           syncedMetadataStoreOpsHandlers.translateClientDBData(syncedMetadata);
         const auxUserInfosFromDB =
           auxUserStoreOpsHandlers.translateClientDBData(auxUserInfos);
         const threadActivityStoreFromDB =
           threadActivityStoreOpsHandlers.translateClientDBData(
             threadActivityEntries,
           );
         dispatch({
           type: setClientDBStoreActionType,
           payload: {
             drafts,
             messages,
             threadStore: { threadInfos: threadInfosFromDB },
             currentUserID: currentLoggedInUserID,
             messageStoreThreads,
             reports: reportsFromDB,
             users: usersFromDB,
             keyserverInfos: keyserverInfosFromDB,
             communities: communityInfosFromDB,
             threadHashes: threadHashesFromDB,
             syncedMetadata: syncedMetadataFromDB,
             auxUserInfos: auxUserInfosFromDB,
             threadActivityStore: threadActivityStoreFromDB,
           },
         });
       } catch (setStoreException) {
         if (isTaskCancelledError(setStoreException)) {
           dispatch({ type: setStoreLoadedActionType });
           return;
         }
         if (staffCanSee) {
           Alert.alert(
             'Error setting threadStore or messageStore',
             getMessageForException(setStoreException) ??
               '{no exception message}',
           );
         }
         await recoverData(
           recoveryFromDataHandlerActionSources.sqliteLoadFailure,
         );
       }
     })();
   }, [
     currentLoggedInUserID,
     handleSensitiveData,
     loggedIn,
     dispatch,
     rehydrateConcluded,
     staffCanSee,
     storeLoaded,
     recoverData,
     callClearSensitiveData,
     mediaCacheContext,
   ]);
 
   return null;
 }
 
 export { SQLiteDataHandler, clearSensitiveData };
diff --git a/web/shared-worker/sqlite-data-handler.js b/web/shared-worker/sqlite-data-handler.js
index aa30efa95..bf0075704 100644
--- a/web/shared-worker/sqlite-data-handler.js
+++ b/web/shared-worker/sqlite-data-handler.js
@@ -1,95 +1,97 @@
 // @flow
 
 import * as React from 'react';
 
 import { shouldClearData } from 'lib/shared/data-utils.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
+import { reportDatabaseDeleted } from 'lib/utils/wait-until-db-deleted.js';
 
 import { getCommSharedWorker } from './shared-worker-provider.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { workerRequestMessageTypes } from '../types/worker-types.js';
 
 function SQLiteDataHandler(): React.Node {
   const dispatch = useDispatch();
   const rehydrateConcluded = useSelector(
     state => !!(state._persist && state._persist.rehydrated),
   );
   const currentLoggedInUserID = useSelector(state =>
     state.currentUserInfo?.anonymous ? undefined : state.currentUserInfo?.id,
   );
 
   const handleSensitiveData = React.useCallback(async () => {
     const sharedWorker = await getCommSharedWorker();
     let sqliteStampedUserID,
       errorGettingStampedUserID = false;
     try {
       const currentUserData = await sharedWorker.schedule({
         type: workerRequestMessageTypes.GET_SQLITE_STAMPED_USER_ID,
       });
       sqliteStampedUserID = currentUserData?.userID;
     } catch (error) {
       errorGettingStampedUserID = true;
       console.error(
         `Error getting SQLite stamped user ID: ${
           getMessageForException(error) ?? 'unknown'
         }`,
       );
     }
 
     if (
       errorGettingStampedUserID ||
       shouldClearData(sqliteStampedUserID, currentLoggedInUserID)
     ) {
       try {
         await sharedWorker.init({ clearDatabase: true });
+        reportDatabaseDeleted();
       } catch (error) {
         console.error(
           `Error clearing sensitive data: ${
             getMessageForException(error) ?? 'unknown'
           }`,
         );
         // We return here to avoid assigning new user to old data
         return;
       }
     }
 
     if (
       currentLoggedInUserID &&
       currentLoggedInUserID !== sqliteStampedUserID
     ) {
       try {
         await sharedWorker.schedule({
           type: workerRequestMessageTypes.STAMP_SQLITE_DB_USER_ID,
           userID: currentLoggedInUserID,
         });
       } catch (error) {
         console.error(
           `Error stamping SQLite database with user ID: ${
             getMessageForException(error) ?? 'unknown'
           }`,
         );
       }
     }
   }, [currentLoggedInUserID]);
 
   React.useEffect(() => {
     void (async () => {
       const sharedWorker = await getCommSharedWorker();
 
       if (!rehydrateConcluded) {
         return;
       }
 
       const isSupported = await sharedWorker.isSupported();
       if (!isSupported) {
         return;
       }
       await handleSensitiveData();
     })();
   }, [dispatch, handleSensitiveData, rehydrateConcluded]);
 
   return null;
 }
 
 export { SQLiteDataHandler };