@ethora/chat-component-rn 26.7.9 → 26.8.1

package/src/helpers/mimeToExtension.ts

@@ -289,9 +289,25 @@ export function ensureFilenameHasExtension(
   return `${base}${getExtensionForMime(mime)}`;
 }
 
-// NOTE: the "which name wins" decision (originalName vs the stored
-// fileName vs the URL) lives in helpers/getDisplayFileName.ts - that is
-// the single source of truth used across display, save, share and
-// download call sites (bug #40: this used to be duplicated here with
-// the priority backwards, so attachments showed/saved under the
-// server's hash name instead of the sender's original one).
+/**
+ * Best-effort filename derivation for a message bubble:
+ *   - server-provided `fileName`
+ *   - server-provided `originalName`
+ *   - URL pathname
+ *   - generic `media_<timestamp>` so we never render an empty label
+ *
+ * Always returns a string with a valid extension.
+ */
+export function deriveDisplayFilename(opts: {
+  fileName?: string | null;
+  originalName?: string | null;
+  url?: string | null;
+  mime?: string | null;
+}): string {
+  const candidate =
+    (opts.fileName && opts.fileName.trim()) ||
+    (opts.originalName && opts.originalName.trim()) ||
+    filenameFromUrl(opts.url) ||
+    '';
+  return ensureFilenameHasExtension(candidate, opts.mime);
+}

package/src/helpers/resolveInitBeforeLoadUser.ts

@@ -1,12 +1,12 @@
-import { setBaseURL } from '../networking/apiClient';
-import { refreshAuthTokens, isRefreshFatalError } from '../networking/authRefresh';
+import http, { setBaseURL } from '../networking/apiClient';
 import { loginViaJwt } from '../networking/api-requests/auth.api';
 import { getMyUser } from '../networking/api-requests/user.api';
 import { IConfig, User } from '../types/types';
 import { store } from '../roomStore';
 import { setUser } from '../roomStore/chatSettingsSlice';
 import { walletToUsername } from './walletUsername';
-import { secureUserStorage } from './secureUserStorage';
+import { asyncLocalStorage } from '../hooks/useLocalStorage';
+import { localStorageConstants } from './constants/LOCAL_STORAGE';
 
 interface ResolveInitBeforeLoadUserOptions {
   config?: IConfig;
@@ -46,107 +46,15 @@ const normalizeUserForXmpp = (user?: User | null): User | null => {
   return { ...user, xmppUsername: normalizedXmppUsername };
 };
 
-// Hermes has no atob/Buffer; hand-decode just enough base64url to read a
-// JWT's `iat`. Claims are ASCII so the byte-per-char string is fine.
-const B64_ALPHABET =
-  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-const readJwtIat = (token?: string | null): number => {
-  if (!token || typeof token !== 'string') {return 0;}
-  const part = token.split('.')[1];
-  if (!part) {return 0;}
-  try {
-    const clean = part.replace(/-/g, '+').replace(/_/g, '/');
-    let out = '';
-    let buffer = 0;
-    let bits = 0;
-    for (let i = 0; i < clean.length; i++) {
-      const idx = B64_ALPHABET.indexOf(clean[i]);
-      if (idx === -1) {continue;}
-      buffer = (buffer << 6) | idx;
-      bits += 6;
-      if (bits >= 8) {
-        bits -= 8;
-        out += String.fromCharCode((buffer >> bits) & 0xff);
-      }
-    }
-    const iat = JSON.parse(out)?.iat;
-    return typeof iat === 'number' ? iat : 0;
-  } catch {
-    return 0;
-  }
-};
-
-/**
- * A `userLogin.user` is typically a snapshot the host captured at ITS
- * login time and re-presents verbatim on every mount, while this SDK
- * keeps rotating the session and persisting the newest pair to
- * `ETHORA_USER`. Taking the snapshot as-is therefore discards the live
- * session in favour of an ever-aging copy: media goes blank the moment
- * the snapshot has no `fileToken` (secure-files URLs 401 without it),
- * and once the snapshot's refresh token ages out entirely the account
- * looks dead even though the SDK held a working session all along.
- *
- * So, for the SAME account only, prefer whichever refresh pair was
- * minted later (JWT `iat` decides — a host that genuinely re-logged-in
- * hands us newer tokens and wins), and fill in a missing `fileToken`
- * from the persisted copy either way.
- */
-const adoptFresherPersistedSession = async (candidate: User): Promise<User> => {
-  try {
-    const stored = await secureUserStorage().get();
-    if (!stored) {return candidate;}
-
-    const sameUser =
-      (candidate._id && stored._id && candidate._id === stored._id) ||
-      (candidate.xmppUsername &&
-        stored.xmppUsername &&
-        candidate.xmppUsername === stored.xmppUsername);
-    if (!sameUser) {return candidate;}
-
-    const merged = { ...candidate };
-
-    if (
-      stored.refreshToken &&
-      readJwtIat(stored.refreshToken) > readJwtIat(candidate.refreshToken)
-    ) {
-      merged.refreshToken = stored.refreshToken;
-      if (stored.token) {merged.token = stored.token;}
-      if (stored.fileToken) {merged.fileToken = stored.fileToken;}
-    }
-
-    if (!merged.fileToken && stored.fileToken) {
-      merged.fileToken = stored.fileToken;
-    }
-
-    return merged;
-  } catch {
-    return candidate;
-  }
-};
-
-/**
- * Bootstrap rotation.
- *
- * Was a second, independent `/users/login/refresh` caller that bypassed
- * every lock in the SDK — and, worse, only wrote the rotated token to
- * the store on the happy path, so several of the early-return branches
- * below used to drop it. Under the backend's reuse detection a dropped
- * rotation means the next launch presents a burned token and the
- * session is killed.
- *
- * `refreshAuthTokens` persists the new pair before it resolves, so by
- * the time this returns the rotation is safe no matter which branch the
- * caller takes afterwards. The explicit token is required here: during
- * bootstrap the candidate session isn't in the store yet.
- */
 const refreshWithToken = async (refreshToken: string) => {
-  const result = await refreshAuthTokens({ refreshToken });
+  const response = await http.post(
+    '/users/login/refresh',
+    {},
+    { headers: { Authorization: refreshToken } }
+  );
   return {
-    token: result.token,
-    refreshToken: result.refreshToken || refreshToken,
-    xmppPassword: result.xmppPassword || '',
-    fileToken: result.fileToken || '',
+    token: response?.data?.token || '',
+    refreshToken: response?.data?.refreshToken || refreshToken,
   };
 };
 
@@ -179,15 +87,11 @@ const tryHydrateViaMy = async (
 
   let workingToken = candidate?.token || '';
   let workingRefresh = candidate?.refreshToken || '';
-  let rotatedXmppPassword = '';
-  let workingFileToken = candidate?.fileToken || '';
 
   const candidateWithCurrentTokens = (): User => ({
     ...candidate,
     token: workingToken || candidate.token,
     refreshToken: workingRefresh || candidate.refreshToken,
-    xmppPassword: rotatedXmppPassword || candidate.xmppPassword,
-    fileToken: workingFileToken || candidate.fileToken,
   });
 
   const fallbackWithCreds = (): User | null => {
@@ -203,8 +107,6 @@ const tryHydrateViaMy = async (
       if (merged) {
         merged.token = workingToken || merged.token;
         merged.refreshToken = workingRefresh || merged.refreshToken;
-        merged.xmppPassword = rotatedXmppPassword || merged.xmppPassword;
-        merged.fileToken = workingFileToken || merged.fileToken;
       }
       return merged;
     } catch (error) {
@@ -225,8 +127,6 @@ const tryHydrateViaMy = async (
     const refreshed = await refreshWithToken(workingRefresh);
     workingToken = refreshed.token;
     workingRefresh = refreshed.refreshToken;
-    rotatedXmppPassword = refreshed.xmppPassword || rotatedXmppPassword;
-    workingFileToken = refreshed.fileToken || workingFileToken;
 
     try {
       const myUser = await getMyUser({ token: workingToken, endpoint: myEndpoint });
@@ -236,8 +136,6 @@ const tryHydrateViaMy = async (
       if (merged) {
         merged.token = workingToken || merged.token;
         merged.refreshToken = workingRefresh || merged.refreshToken;
-        merged.xmppPassword = rotatedXmppPassword || merged.xmppPassword;
-        merged.fileToken = workingFileToken || merged.fileToken;
       }
       return merged;
     } catch (myError) {
@@ -249,11 +147,6 @@ const tryHydrateViaMy = async (
     }
   } catch (error) {
     if (signal?.aborted || isAbortError(error)) {return null;}
-    // A fatal refresh verdict (reuse detected / token not found / stale
-    // with nothing newer around) carries no HTTP response, so it would
-    // otherwise fall through to `throw` — the session is simply dead,
-    // which for bootstrap means "nothing to restore".
-    if (isRefreshFatalError(error)) {return null;}
     if (isAuthError(error)) {return null;}
     throw error;
   }
@@ -269,15 +162,13 @@ export const resolveInitBeforeLoadUser = async (
     setBaseURL(config.baseUrl, config.customAppToken);
   }
 
-  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/v1/users/my';
+  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/users/my';
 
   // Priority 1: explicit userLogin
   const explicitUser = config?.userLogin?.enabled ? config?.userLogin?.user : null;
   if (explicitUser) {
     const candidate = normalizeUserForXmpp(explicitUser);
-    if (candidate && hasXmppCredentials(candidate)) {
-      return await adoptFresherPersistedSession(candidate);
-    }
+    if (candidate && hasXmppCredentials(candidate)) {return candidate;}
 
     const hydrated = await tryHydrateViaMy(explicitUser, myEndpoint, signal).catch(
       () => null
@@ -326,13 +217,13 @@ export const resolveInitBeforeLoadUser = async (
 
   // Priority 5: persisted user in AsyncStorage
   try {
-    const storedUser = await secureUserStorage().get();
+    const storedUser = await asyncLocalStorage<User>(localStorageConstants.ETHORA_USER).get();
     if (storedUser && (storedUser.token || storedUser.refreshToken || storedUser.xmppPassword)) {
       const hydrated = await tryHydrateViaMy(storedUser, myEndpoint, signal).catch(
         () => null
       );
       if (hydrated && hasXmppCredentials(hydrated)) {return hydrated;}
-      await secureUserStorage().remove();
+      await asyncLocalStorage(localStorageConstants.ETHORA_USER).remove();
     }
   } catch {
     // ignore storage errors
@@ -384,7 +275,7 @@ export const refreshUserCredentialsForXmpp = async (
     }
   }
 
-  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/v1/users/my';
+  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/users/my';
 
   // Priority 2: redux store user (covers userLogin + customLogin +
   // anything previously persisted into chatSettingStore.user). The
@@ -404,7 +295,9 @@ export const refreshUserCredentialsForXmpp = async (
   // should already mirror this, but if the redux state got cleared
   // mid-session (logout race) this gives us one last shot.
   try {
-    const storedUser = await secureUserStorage().get();
+    const storedUser = await asyncLocalStorage<User>(
+      localStorageConstants.ETHORA_USER
+    ).get();
     if (
       storedUser &&
       (storedUser.token || storedUser.refreshToken || storedUser.xmppPassword)

package/src/helpers/resolveLangSource.ts

@@ -0,0 +1,40 @@
+import { IConfig, Iso639_1Codes } from '../types/types';
+
+/**
+ * Legacy single-locale config (`translates.translations`) seeds langSource
+ * only when the host ACTUALLY set it.
+ *
+ * The condition used to be inverted (`!translates.translations`), so merely
+ * enabling translation fired `setLangSource(undefined)` on every XMPP init
+ * and wiped whatever the reader had picked from the globe — the language
+ * reset itself on every reconnect. Web fixed this; RN had not.
+ */
+export const resolveLegacyTranslatesLangSource = (
+  translatesConfig?: IConfig['translates']
+): Iso639_1Codes | undefined =>
+  translatesConfig?.enabled && translatesConfig?.translations
+    ? translatesConfig.translations
+    : undefined;
+
+/**
+ * A host drives the reader's language from OUTSIDE the component by setting
+ * `config.translates.readerLocale` (their own language switcher, or the
+ * testbed's Setup tab). Nothing was syncing it into `langSource`, so pinning
+ * it only redirected the incoming-translation lookup: the UI captions and
+ * the `<translate source>` on outgoing messages both kept following the
+ * unset `langSource`.
+ *
+ * Unlike web this keeps the FULL locale rather than the base language. RN's
+ * LANGUAGE_OPTIONS are region-tagged (`es-US`, `fr-CA`) because the region
+ * is forwarded to the translation service, and the in-chat picker stores
+ * that full form — so the external path has to store the same thing or the
+ * two would disagree. Caption lookups strip to the base themselves.
+ *
+ * Resolves only when actually set, so a host that leaves it unset never
+ * clobbers what the reader chose for themselves.
+ */
+export const resolveExternalReaderLocaleLangSource = (
+  readerLocale?: string
+): Iso639_1Codes | undefined =>
+  (readerLocale || undefined) as Iso639_1Codes | undefined;
+

package/src/helpers/xmppUsername.ts

@@ -0,0 +1,38 @@
+import { store } from '../roomStore';
+
+/**
+ * Collapse a duplicated `<appId>_` prefix down to one.
+ *
+ * Ported from the web SDK (src/helpers/xmppUsername.ts). Some senders stamp
+ * an already-qualified username and it gets qualified a second time, which
+ * yields `<appId>_<appId>_<userId>` — a key `usersSet` will never match.
+ *
+ * RN reads the appId off the logged-in user's own xmppUsername
+ * (`<appId>_<userId>`) since the chat store has no standalone `appId` field
+ * the way web's does.
+ */
+export const normalizeXmppUsername = (
+  value: string | undefined | null
+): string => {
+  if (!value) {
+    return '';
+  }
+  let result = String(value).trim();
+  if (!result) {
+    return '';
+  }
+
+  const ownXmpp = String(
+    store.getState().chatSettingStore?.user?.xmppUsername || ''
+  );
+  const appId = ownXmpp.includes('_') ? ownXmpp.split('_')[0] : '';
+  if (!appId) {
+    return result;
+  }
+
+  const prefix = `${appId}_`;
+  while (result.startsWith(prefix + prefix)) {
+    result = result.slice(prefix.length);
+  }
+  return result;
+};

package/src/hooks/useChatRoomFocus.ts

@@ -7,7 +7,6 @@ import {
   setVisibleRoom,
 } from '../roomStore/roomsSlice';
 import { store } from '../roomStore';
-import { getServerReadTimestamp } from '../helpers/getServerReadTimestamp';
 
 interface UseChatRoomFocusOptions {
   /** The room JID that the consumer's tab/screen is currently showing. */
@@ -33,10 +32,7 @@ interface UseChatRoomFocusOptions {
  * Without this hook, `useUnread()` will always return 0 for the chat
  * room because the SDK assumes "mounted == active". With this hook,
  * focus marks the room visible (clearing the badge) and blur stamps
- * `lastViewedTimestamp` to the newest SERVER-acknowledged message so
- * future messages count as unread. Deliberately not `Date.now()`: a
- * device clock running ahead would write a future marker that the
- * forward-only private-store merge could never correct again (bug #38).
+ * `lastViewedTimestamp = Date.now()` so future messages count as unread.
  *
  * Usage with React Navigation:
  *
@@ -63,16 +59,11 @@ export const useChatRoomFocus = ({
   });
 
   const leaveRoom = (jid: string) => {
-    const state = store.getState();
-    const rooms = state.rooms?.rooms;
-    const timestamp = getServerReadTimestamp(rooms?.[jid], state.roomHeapSlice);
-    // Only stamp when we actually have something to anchor to - skip
-    // rather than fall back to the device clock (bug #38).
-    if (timestamp > 0) {
-      dispatch(setLastViewedTimestamp({ chatJID: jid, timestamp }));
-    }
+    const timestamp = Date.now();
+    dispatch(setLastViewedTimestamp({ chatJID: jid, timestamp }));
     dispatch(clearVisibleRoom());
-    (state.chatSettingStore as any)?.client
+    const rooms = store.getState().rooms?.rooms;
+    (store.getState().chatSettingStore as any)?.client
       ?.flushLastViewedToPrivateStoreStanza(rooms, { visibleRoomJID: jid })
       .catch(() => {});
   };

package/src/hooks/useChatWrapperInit.ts

@@ -3,13 +3,15 @@
 import { useEffect, useRef, useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { IConfig } from '../types/types';
+import { resolveLegacyTranslatesLangSource } from '../helpers/resolveLangSource';
 import XmppClient from '../networking/xmppClient';
 import { AppDispatch, RootState } from '../roomStore';
 import { useXmppClient } from '../context/xmppProvider';
 import { chatAutoEnterer } from '../helpers/chatAutoEnterer';
 import { initRoomsPresence } from '../helpers/initRoomsPresence';
+import { updatedChatLastTimestamps } from '../helpers/updatedChatLastTimestamps';
 import { updateMessagesTillLast } from '../helpers/updateMessagesTillLast';
-import { refreshAuthTokensQuietly } from '../networking/authRefresh';
+import { refresh } from '../networking/apiClient';
 import { setLangSource, setConfig } from '../roomStore/chatSettingsSlice';
 import { setIsLoading } from '../roomStore/roomsSlice';
 import { useRoomState } from './useRoomState';
@@ -17,7 +19,6 @@ import { useChatSettingState } from './useChatSettingState';
 import { isChatIdPresentInArray } from '../helpers/isChatIdPresentInArray';
 import useGetNewArchRoom from './useGetNewArchRoom';
 import { getRoomsWithRetry } from '../helpers/getRoomsWithRetry';
-import { shallowEqual } from '../helpers/shallowEqual';
 
 interface useChatWrapperInitProps {
   roomJID: string | null | undefined;
@@ -65,20 +66,6 @@ const useChatWrapperInit = ({
     };
   }, [user.xmppPassword]);
 
-  // Presentational config flags (e.g. `disableHeader`) can change while the
-  // chat stays mounted — sync them to redux whenever `config` actually
-  // changes, not just at init. Shallow-equal guard: an inline object
-  // literal from the host is a fresh reference every render even when
-  // nothing in it changed, and dispatching unconditionally would re-render
-  // every config consumer on every host render.
-  const lastSyncedConfigRef = useRef<IConfig | undefined>(undefined);
-  useEffect(() => {
-    if (!shallowEqual(lastSyncedConfigRef.current, config)) {
-      lastSyncedConfigRef.current = config;
-      dispatch(setConfig(config));
-    }
-  }, [config, dispatch]);
-
   const getRoomsWithRertyRequest = async () => {
     setIsRetrying(true);
     const retryRooms = await getRoomsWithRetry(
@@ -111,8 +98,11 @@ const useChatWrapperInit = ({
     let retryTimeout: NodeJS.Timeout;
 
     const initXmmpClient = async () => {
-      if (config?.translates?.enabled && !config?.translates?.translations) {
-        dispatch(setLangSource(config?.translates?.translations));
+      const legacyLangSource = resolveLegacyTranslatesLangSource(
+        config?.translates
+      );
+      if (legacyLangSource) {
+        dispatch(setLangSource(legacyLangSource));
       }
 
       dispatch(setConfig(config));
@@ -169,21 +159,15 @@ const useChatWrapperInit = ({
                 }
               }
               try {
-                // getChatsPrivateStoreRequestStanza hydrates redux itself
-                // (dispatch(applyPrivateStoreMarkers(...)) internally,
-                // clamped + forward-only) - do not also apply the raw
-                // return value here. That used to double-dispatch via
-                // updatedChatLastTimestamps' unconditional
-                // setLastViewedTimestamp, which has neither the
-                // forward-only guard nor the future-marker clamp, so on
-                // every reconnect it could silently re-clobber a value
-                // the clamp had just corrected (bug #38).
                 const roomTimestampObject: any =
                   await newClient.getChatsPrivateStoreRequestStanza();
                 console.log(
                   'Got chats private store',
                   roomTimestampObject?.length || 0
                 );
+                if (roomTimestampObject) {
+                  updatedChatLastTimestamps(roomTimestampObject, dispatch);
+                }
                 if (!hasSyncedHistoryRef.current) {
                   console.log('Updating messages till last');
                   await updateMessagesTillLast(rooms, newClient);
@@ -199,7 +183,7 @@ const useChatWrapperInit = ({
               }
 
               {
-                config?.refreshTokens?.enabled && refreshAuthTokensQuietly();
+                config?.refreshTokens?.enabled && refresh();
               }
             } catch (error) {
               console.error(' Error during initialization', error);
@@ -225,15 +209,15 @@ const useChatWrapperInit = ({
             setInited(true);
             console.log(' Getting chats private store for existing client');
             try {
-              // See the "new client" branch above: getChatsPrivateStoreRequestStanza
-              // already hydrates redux (clamped + forward-only); do not
-              // also apply the raw return value here.
               const roomTimestampObject: any =
                 await client.getChatsPrivateStoreRequestStanza();
               console.log(
                 'Got chats private store for existing client',
                 roomTimestampObject?.length || 0
               );
+              if (roomTimestampObject) {
+                updatedChatLastTimestamps(roomTimestampObject, dispatch);
+              }
               if (!hasSyncedHistoryRef.current) {
                 console.log(
                   'Updating messages till last for existing client'
@@ -253,7 +237,7 @@ const useChatWrapperInit = ({
               setConnectionLost(false);
             }
             {
-              config?.refreshTokens?.enabled && refreshAuthTokensQuietly();
+              config?.refreshTokens?.enabled && refresh();
             }
           }
         }

package/src/hooks/useComposing.tsx

@@ -1,5 +1,4 @@
-import { useCallback, useEffect, useRef } from 'react';
-import { AppState, AppStateStatus } from 'react-native';
+import { useCallback, useEffect, useState } from 'react';
 import { useXmppClient } from '../context/xmppProvider';
 import { useSelector } from 'react-redux';
 import { RootState } from '../roomStore';
@@ -10,16 +9,8 @@ const useComposing = (config?: IConfig) => {
   const { client } = useXmppClient();
   const { activeRoomJID } = useSelector((state: RootState) => state.rooms);
   const { user } = useChatSettingState();
-  // RN keeps a focused TextInput focused when the app is backgrounded or
-  // the device is locked — nothing fires `onBlur`, so without this the
-  // other participant sees "typing…" for as long as the user is away.
-  // Tracks whether the input is *currently* focused, independent of the
-  // foreground/background transition, so we know whether to resume
-  // composing on return.
-  const isFocusedRef = useRef(false);
 
   const sendStartComposing = useCallback(() => {
-    isFocusedRef.current = true;
     if (config?.disableTypingIndicator) {
       return;
     }
@@ -33,7 +24,6 @@ const useComposing = (config?: IConfig) => {
   }, [activeRoomJID, client, config?.disableTypingIndicator, user.firstName, user.lastName]);
 
   const sendEndComposing = useCallback(() => {
-    isFocusedRef.current = false;
     if (config?.disableTypingIndicator) {
       return;
     }
@@ -54,32 +44,6 @@ const useComposing = (config?: IConfig) => {
     return () => clearTimeout(timerId);
   }, [sendEndComposing]);
 
-  // Foreground/background transition only — a pause in typing must NOT
-  // clear the indicator (that would flicker for a slowly-composing user),
-  // so this deliberately does not hook keystroke/idle timing at all.
-  useEffect(() => {
-    const handleAppStateChange = (nextState: AppStateStatus) => {
-      if (nextState !== 'active') {
-        if (isFocusedRef.current && !config?.disableTypingIndicator && client) {
-          client.sendTypingRequestStanza(
-            activeRoomJID || '',
-            `${user.firstName} ${user.lastName}`,
-            false
-          );
-        }
-      } else if (isFocusedRef.current && !config?.disableTypingIndicator && client) {
-        client.sendTypingRequestStanza(
-          activeRoomJID || '',
-          `${user.firstName} ${user.lastName}`,
-          true
-        );
-      }
-    };
-
-    const subscription = AppState.addEventListener('change', handleAppStateChange);
-    return () => subscription.remove();
-  }, [activeRoomJID, client, config?.disableTypingIndicator, user.firstName, user.lastName]);
-
   return { sendStartComposing, sendEndComposing };
 };
 

package/src/hooks/useLogout.tsx

@@ -9,7 +9,7 @@ import { clearHeap } from '../roomStore/roomHeapSlice';
 import { pushSubscriptionService } from '../services/pushSubscriptionService';
 import { clearRoomsRestCache } from '../networking/api-requests/rooms.api';
 import { clearPersistedState } from '../roomStore/persistence';
-import { secureUserStorage } from '../helpers/secureUserStorage';
+import { localStorageConstants } from '../helpers/constants/LOCAL_STORAGE';
 
 // AsyncStorage keys the library writes but that aren't cleared by any
 // slice reducer. Listed here so a single logout call wipes the full
@@ -120,23 +120,17 @@ const logoutService = {
 
     // 6. Stray keys the slices don't touch.
     try {
-      await AsyncStorage.multiRemove(LIBRARY_STRAY_KEYS);
+      await AsyncStorage.multiRemove([
+        ...LIBRARY_STRAY_KEYS,
+        // Belt-and-suspenders: the chat slice's `logout` reducer
+        // schedules an async remove of ETHORA_USER fire-and-forget;
+        // re-issue it here so the disk is provably clean before this
+        // Promise resolves.
+        localStorageConstants.ETHORA_USER,
+      ]);
     } catch (e) {
       console.warn('logoutService: stray-key clear failed', e);
     }
-
-    // 7. Belt-and-suspenders: the chat slice's `logout` reducer already
-    //    fires an async ETHORA_USER removal, but re-issue it here (via
-    //    the same secureUserStorage split the reducer uses) so BOTH the
-    //    plain-AsyncStorage profile half AND the Keychain/Keystore
-    //    secrets are provably gone before this Promise resolves — a bare
-    //    `AsyncStorage.removeItem(ETHORA_USER)` here would only clear the
-    //    profile half and leave the tokens behind.
-    try {
-      await secureUserStorage().remove();
-    } catch (e) {
-      console.warn('logoutService: secure user storage clear failed', e);
-    }
   },
 };
 

package/src/hooks/usePendingNotification.ts

@@ -4,7 +4,7 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 import { RootState } from '../roomStore';
 import { setCurrentRoom, clearPendingNotificationJid } from '../roomStore/roomsSlice';
 
-import { PENDING_NOTIFICATION_JID_KEY, readPendingJid } from '../helpers/pushPayload';
+const PENDING_NOTIFICATION_JID_KEY = 'ethora_pending_notification_jid';
 
 export function usePendingNotification() {
   const dispatch = useDispatch();
@@ -21,15 +21,21 @@ export function usePendingNotification() {
       let jidToOpen = pendingNotificationJid;
 
       if (!jidToOpen) {
-        jidToOpen = await readPendingJid();
+        try {
+          const storedJid = await AsyncStorage.getItem(PENDING_NOTIFICATION_JID_KEY);
+          if (storedJid) {
+            jidToOpen = storedJid;
+            await AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY);
+          }
+        } catch (error) {
+          console.error('Error reading from AsyncStorage:', error);
+        }
       }
 
       if (jidToOpen) {
         const room = rooms[jidToOpen];
         if (room) {
-          dispatch(clearPendingNotificationJid());
-          AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY).catch(() => undefined);
-          dispatch(setCurrentRoom({ roomJID: jidToOpen }));
+          return;
         }
       }
     };