@ethora/chat-component-rn 26.4.1

package/src/networking/apiClient.ts

@@ -0,0 +1,149 @@
+import axios from 'axios';
+import { store } from '../roomStore';
+
+import { logout, refreshTokens } from '../roomStore/chatSettingsSlice';
+import { appToken as defaultAppToken } from '../../api.config';
+import { installAxiosCapture } from '../utils/devLogger';
+
+const DEFAULT_BASE_URL = 'https://api.chat.ethora.com/v1';
+
+let currentBaseURL = DEFAULT_BASE_URL;
+let currentAppToken: string = defaultAppToken;
+
+const http = axios.create({
+  baseURL: currentBaseURL,
+});
+
+// Dev-logger hook: capture every request + response on the shared
+// `http` instance.
+installAxiosCapture(http);
+
+export function setBaseURL(baseUrl?: string, appToken?: string) {
+  if (baseUrl && baseUrl !== currentBaseURL) {
+    currentBaseURL = baseUrl;
+    http.defaults.baseURL = baseUrl;
+  }
+  if (appToken && appToken !== currentAppToken) {
+    currentAppToken = appToken;
+  }
+}
+
+export function getCurrentAppToken() {
+  return currentAppToken;
+}
+
+export function getCurrentBaseURL() {
+  return currentBaseURL;
+}
+
+export function refresh(): Promise<{
+  data: { refreshToken: string; token: string };
+}> {
+  return new Promise((resolve, reject) => {
+    const user = store.getState().chatSettingStore.user;
+    try {
+      http
+        .post(
+          '/users/login/refresh',
+          {},
+          { headers: { Authorization: user.refreshToken } }
+        )
+        .then((response) => {
+          store.dispatch(
+            refreshTokens({
+              token: response.data.token,
+              refreshToken: response.data.refreshToken,
+            })
+          );
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    } catch (error) {
+      console.log('errr');
+      store.dispatch(logout());
+    }
+  });
+}
+
+let isRefreshing = false;
+let failedQueue: any[] = [];
+
+const addRequestToQueue = (config: any) => {
+  return new Promise((resolve, reject) => {
+    failedQueue.push({ resolve, reject, config });
+  });
+};
+
+const processQueue = (newAccessToken: string) => {
+  for (const request of failedQueue) {
+    if (newAccessToken) {
+      request.config.headers.Authorization = newAccessToken;
+    }
+
+    request.resolve(http(request.config));
+  }
+
+  failedQueue = [];
+};
+
+http.interceptors.response.use(
+  (response) => response,
+  async (error) => {
+    // BUGFIX: the original condition was `if (!enabled)` — inverted, so
+    // turning `refreshTokens.enabled: true` actually DISABLED the refresh
+    // path on 401. Use the correct sense.
+    if (store.getState().chatSettingStore?.config?.refreshTokens?.enabled) {
+      if (
+        store.getState().chatSettingStore?.config?.refreshTokens
+          ?.refreshFunction
+      ) {
+        const { refreshToken, accessToken } = store
+          .getState()
+          .chatSettingStore?.config?.refreshTokens?.refreshFunction();
+        store.dispatch(
+          refreshTokens({
+            token: accessToken,
+            refreshToken: refreshToken,
+          })
+        );
+        return;
+      } else {
+        const originalRequest = error.config;
+
+        if (!error.response || error.response.status !== 401) {
+          throw error;
+        }
+        if (
+          originalRequest.url === '/users/login/refresh' ||
+          originalRequest.url === '/users/login'
+        ) {
+          return Promise.reject(error);
+        }
+
+        originalRequest._retry = true;
+
+        if (isRefreshing) {
+          const retryOriginalRequest = addRequestToQueue(originalRequest);
+
+          return retryOriginalRequest;
+        } else {
+          isRefreshing = true;
+          try {
+            const tokens = await refresh();
+            console.log('tokens', tokens);
+            isRefreshing = false;
+            originalRequest.headers.Authorization = tokens.data.token;
+            processQueue(tokens.data.token);
+            return http(originalRequest);
+          } catch (refreshErr) {
+            isRefreshing = false;
+            return refreshErr;
+          }
+        }
+      }
+    }
+  }
+);
+
+export default http;

package/src/networking/helpers/refreshChecker.ts

@@ -0,0 +1,13 @@
+export const refreshHelper = (
+  isEnabled: boolean,
+  refreshFunc: any,
+  logoutClb: any
+) => {
+  if (isEnabled) {
+    try {
+      refreshFunc();
+    } catch (error) {
+      logoutClb();
+    }
+  }
+};

package/src/networking/stanzaHandlers.ts

@@ -0,0 +1,418 @@
+import { Element } from 'ltx';
+import { store } from '../roomStore';
+import {
+  addRoom,
+  addRoomMessage,
+  deleteRoomMessage,
+  editRoomMessage,
+  setComposing,
+  setCurrentRoom,
+  setRoomRole,
+  updateRoom,
+} from '../roomStore/roomsSlice';
+import { IRoom } from '../types/types';
+import { createMessageFromXml } from '../helpers/createMessageFromXml';
+import { getDataFromXml } from '../helpers/getDataFromXml';
+import { setDeleteModal } from '../roomStore/chatSettingsSlice';
+import { messageNotificationManager } from '../utils/messageNotificationManager';
+
+// TO DO: we are thinking to refactor this code in the following way:
+// each stanza will be parsed for 'type'
+// then it will be handled based on the type
+// XMPP parsing will be done universally as a pre-processing step
+// then handlers for different types will work with a Javascript object
+// types: standard, coin transfer, is composing, attachment (media), token (nft) or smart contract
+// types can be added into our chat protocol (XMPP stanza add field type="") to make it easier to parse here
+
+//core default
+const onRealtimeMessage = async (stanza: Element) => {
+  if (
+    !stanza?.getChild('result') &&
+    !stanza.getChild('composing') &&
+    !stanza.getChild('paused') &&
+    !stanza.getChild('subject') &&
+    !stanza.is('iq') &&
+    stanza.attrs.id !== 'deleteMessageStanza'
+  ) {
+    const body = stanza?.getChild('body');
+    const archived = stanza?.getChild('archived');
+    const data = stanza?.getChild('data');
+    const id = archived?.attrs.id;
+
+    const deleted = stanza
+      .getChild('result')
+      ?.getChild('forwarded')
+      ?.getChild('message')
+      ?.getChild('deleted');
+
+    if (!data) {
+      console.log(stanza.toString());
+      console.log('Missing data elements in real-time message.');
+      return;
+    }
+
+    if (!data.attrs.senderJID) {
+      console.log(stanza.toString());
+      console.log(data.attrs.senderJID);
+
+      console.log('Missing sender information in real-time message.');
+      return;
+    }
+
+    // Use the same parser as MAM so the message carries `xmppId` (the
+    // outer stanza id = our original send id). insertMessageWithDelimiter
+    // dedupes by xmppId, which is how the optimistic pending bubble flips
+    // to delivered in-place instead of rendering twice.
+    const parsed = await getDataFromXml(stanza);
+    const { data: pData, id: pId, body: pBody, ...pRest } = parsed || ({} as any);
+    const message = await createMessageFromXml({
+      data: pData || data.attrs,
+      id: pId || id,
+      body: pBody,
+      ...pRest,
+      isDeleted: !!deleted || !!(pRest as any)?.deleted,
+    });
+
+    const roomJID = stanza.attrs.from.split('/')[0];
+    store.dispatch(
+      addRoomMessage({
+        roomJID,
+        message,
+      })
+    );
+
+    // Trigger in-app notification (manager dedupes + drops own messages
+    // for empty bodies). Self-messages are filtered by sender check.
+    try {
+      const state = store.getState();
+      const currentUserWallet = (state.chatSettingStore.user?.walletAddress || '').toLowerCase();
+      const senderJID = String(data.attrs.senderJID || '').toLowerCase();
+      if (currentUserWallet && senderJID.includes(currentUserWallet)) {
+        return message; // own message, skip toast
+      }
+      const room = state.rooms.rooms[roomJID];
+      const roomName = room?.title || room?.name || '';
+      const senderName = [
+        data.attrs.senderFirstName,
+        data.attrs.senderLastName,
+      ]
+        .filter(Boolean)
+        .join(' ')
+        .trim() || 'New message';
+      messageNotificationManager.showNotification(
+        message,
+        roomName,
+        senderName,
+        roomJID
+      );
+    } catch (err) {
+      console.warn('notification dispatch failed', err);
+    }
+    return message;
+  }
+};
+
+const onDeleteMessage = async (stanza: Element) => {
+  if (stanza.attrs.id === 'deleteMessageStanza') {
+    const deleted = stanza.getChild('delete');
+    const stanzaId = stanza.getChild('stanza-id');
+
+    if (!deleted) {
+      return;
+    }
+
+    store.dispatch(
+      deleteRoomMessage({
+        roomJID: stanzaId.attrs.by,
+        messageId: deleted.attrs.id,
+      })
+    );
+    store.dispatch(setDeleteModal({ isDeleteModal: false }));
+  }
+};
+
+const onEditMessage = async (stanza: Element) => {
+  if (stanza?.attrs?.id?.includes('edit-message')) {
+    const stanzaId = stanza.getChild('stanza-id');
+    const replace = stanza.getChild('replace');
+
+    if (!stanzaId && !replace) {
+      return;
+    }
+
+    store.dispatch(
+      editRoomMessage({
+        roomJID: stanzaId.attrs.by,
+        messageId: replace.attrs.id,
+        text: replace.attrs.text,
+      })
+    );
+  }
+};
+
+const onMessageHistory = async (stanza: any) => {
+  if (
+    stanza.is('message') &&
+    stanza.children[0].attrs.xmlns === 'urn:xmpp:mam:2'
+  ) {
+    // console.log("stanza -->", stanza.toString());
+    const body = stanza
+      .getChild('result')
+      ?.getChild('forwarded')
+      ?.getChild('message')
+      ?.getChild('body');
+    const data = stanza
+      .getChild('result')
+      ?.getChild('forwarded')
+      ?.getChild('message')
+      ?.getChild('data');
+    const deleted = stanza
+      .getChild('result')
+      ?.getChild('forwarded')
+      ?.getChild('message')
+      ?.getChild('deleted');
+
+    const delay = stanza
+      .getChild('result')
+      ?.getChild('forwarded')
+      ?.getChild('delay');
+    const id = stanza.getChild('result')?.attrs.id;
+    if (!delay) {
+      if (stanza.getChild('subject')) {
+        console.log('Subject.');
+        return;
+      }
+      if (!data || !body || !id) {
+        console.log('Missing required elements in message history.');
+        return;
+      }
+    }
+    // console.log(stanza.attrs.from);
+
+    if (
+      !data?.attrs ||
+      !data.attrs.senderFirstName ||
+      !data.attrs.senderLastName ||
+      !data.attrs.senderJID
+    ) {
+      // console.log(
+      //   "Missing sender information in message history.",
+      //   stanza.toString()
+      // );
+      return;
+    }
+    const message = await createMessageFromXml(
+      data.attrs,
+      body,
+      id,
+      stanza.attrs.from,
+      !!deleted
+    );
+    store.dispatch(
+      addRoomMessage({
+        roomJID: stanza.attrs.from,
+        message,
+      })
+    );
+  }
+};
+
+const handleComposing = async (stanza: Element, currentUser: string) => {
+  if (stanza.getChild('paused') || stanza.getChild('composing')) {
+    const composingUser = stanza.attrs?.from?.split('/')?.[1];
+
+    // Normalize both sides the same way before comparing — previously
+    // we lower-cased the currentUser but only stripped underscores from
+    // the composingUser, so wallet-style IDs with underscores
+    // ("foo_bar") never matched their own MUC nick ("foo_bar") and the
+    // user saw a typing indicator for their own keystrokes.
+    const norm = (s?: string) =>
+      (s || '').toLowerCase().replace(/_/g, '');
+
+    // Secondary self-check via the <data senderJID="..."> attribute —
+    // covers the case where the MUC resource part differs from the
+    // raw xmppUsername (custom nick formats, JID-mode resources, etc.).
+    const senderJID = stanza.getChild('data')?.attrs?.senderJID || '';
+    const senderLocal = senderJID.split('@')[0] || '';
+    const state = store.getState();
+    const selfUser = state.chatSettingStore?.user;
+    const selfXmppUsername = selfUser?.xmppUsername || '';
+    const selfWallet = selfUser?.walletAddress || '';
+    const isSelf =
+      (composingUser && norm(currentUser) === norm(composingUser)) ||
+      (senderLocal && norm(senderLocal) === norm(selfXmppUsername)) ||
+      (senderLocal && norm(senderLocal).includes(norm(selfWallet)));
+
+    if (composingUser && !isSelf) {
+      const chatJID = stanza.attrs?.from.split('/')[0];
+
+      let composingList = [];
+
+      stanza?.getChild('composing')
+        ? composingList.push(
+            stanza.getChild('data')?.attrs?.fullName?.split(' ')?.[0] || 'User'
+          )
+        : composingList.pop();
+
+      store.dispatch(
+        setComposing({
+          chatJID: chatJID,
+          composing: !!stanza?.getChild('composing'),
+          composingList,
+        })
+      );
+    }
+  }
+};
+
+const onPresenceInRoom = (stanza: Element | any) => {
+  if (stanza.attrs.id === 'presenceInRoom' && !stanza.getChild('error')) {
+    const roomJID: string = stanza.attrs.from.split('/')[0];
+    const role: string = stanza?.children[1]?.children[0]?.attrs.role;
+    store.dispatch(setRoomRole({ chatJID: roomJID, role: role }));
+  }
+};
+
+const onChatInvite = async (stanza: Element, client: any) => {
+  if (stanza.is('message') && stanza.attrs.type !== 'groupchat') {
+    // check if it is invite
+    const chatId = stanza.attrs.from;
+    const xEls = stanza.getChildren('x');
+
+    for (const el of xEls) {
+      const child = el.getChild('invite');
+
+      if (child) {
+        const chat = store.getState().rooms.rooms[chatId];
+        if (chat) {
+          return;
+        }
+
+        await client.presenceInRoomStanza(chatId);
+        await client.getRoomsStanza();
+      }
+    }
+  }
+};
+
+const onGetMembers = (stanza: Element) => {
+  const jid = store.getState().rooms.activeRoomJID;
+  // Defensive: many iq stanzas don't have an id (server pings,
+  // disco#info responses, etc.).
+  if (String(stanza.attrs?.id || '') !== 'roomMemberInfo') {return;}
+  // The original implementation used the browser-only DOMParser, which
+  // throws `ReferenceError: Property 'DOMParser' doesn't exist` in
+  // React Native. Walk the ltx element tree directly instead — the
+  // shape is the same: nested <query><activity .../></query> children.
+  try {
+    const queries = (stanza as any).getChildren?.('query') || [];
+    const activities: any[] = [];
+    for (const q of queries) {
+      const acts = q?.getChildren?.('activity') || [];
+      for (const a of acts) {activities.push(a);}
+    }
+    const roomMembers = activities.map((a: any) => ({
+      name: a?.attrs?.name,
+      role: a?.attrs?.role,
+      ban_status: a?.attrs?.ban_status,
+      last_active: Number(a?.attrs?.last_active),
+      jid: a?.attrs?.jid,
+    }));
+    if (jid) {
+      store.dispatch(updateRoom({ jid, updates: { roomMembers } as any }));
+    }
+  } catch (err) {
+    console.warn('onGetMembers parse failed', err);
+  }
+};
+
+const onGetRoomInfo = (stanza: Element) => {
+  if (stanza.attrs.id === 'roomInfo' && !stanza.getChild('error')) {
+  }
+};
+
+const onGetLastMessageArchive = (stanza: Element, _xmpp: any) => {
+  if (stanza.attrs.id === 'GetLastArchive') {
+  }
+};
+
+const onNewRoomCreated = (stanza: Element, xmpp: any) => {
+  store.dispatch(setCurrentRoom({ roomJID: stanza.attrs.from }));
+  xmpp.getRoomsStanza();
+};
+
+const onGetChatRooms = (stanza: Element, xmpp: any) => {
+  if (
+    stanza.attrs.id === 'getUserRooms' &&
+    Array.isArray(stanza.getChild('query')?.children)
+  ) {
+    stanza.getChild('query')?.children.forEach(async (result: any) => {
+      const currentChatRooms = store.getState().rooms.rooms;
+
+      const isRoomAlreadyAdded = Object.values(currentChatRooms).some(
+        (element) => element.jid === result?.attrs?.jid
+      );
+
+      if (!isRoomAlreadyAdded) {
+        try {
+          const roomData: IRoom = {
+            jid: result?.attrs?.jid || '',
+            name: result?.attrs?.name || '',
+            id: '',
+            title: result?.attrs?.name || '',
+            usersCnt: Number(result?.attrs?.users_cnt || 0),
+            messages: [],
+            isLoading: false,
+            roomBg:
+              result?.attrs?.room_background !== 'none'
+                ? result?.attrs?.room_background
+                : null,
+            icon:
+              result?.attrs?.room_thumbnail !== 'none'
+                ? result?.attrs?.room_thumbnail
+                : null,
+            unreadMessages: 0,
+            lastViewedTimestamp: 0,
+          };
+
+          store.dispatch(addRoom({ roomData: { ...roomData } }));
+
+          if (!store.getState().rooms.activeRoomJID) {
+            store.dispatch(setCurrentRoom({ roomJID: roomData.jid }));
+          }
+
+          if (roomData.jid) {
+            xmpp.presenceInRoomStanza(roomData.jid);
+          }
+        } catch (error) {}
+      }
+    });
+  }
+};
+
+// No-op stubs for handlers that handleStanzas.xmpp.ts imports but the
+// RN side hasn't ported yet. Without these the bundle compiles but
+// require() returns undefined at runtime → "X is not a function".
+const onMessageError = (_stanza: Element, _xmpp?: any) => {};
+const onReactionMessage = (_stanza: Element) => {};
+const onReactionHistory = (_stanza: Element) => {};
+const onRoomKicked = (_stanza: Element) => {};
+
+export {
+  onRealtimeMessage,
+  onMessageHistory,
+  onPresenceInRoom,
+  onGetLastMessageArchive,
+  handleComposing,
+  onGetChatRooms,
+  onNewRoomCreated,
+  onGetMembers,
+  onGetRoomInfo,
+  onDeleteMessage,
+  onEditMessage,
+  onChatInvite,
+  onMessageError,
+  onReactionMessage,
+  onReactionHistory,
+  onRoomKicked,
+};

package/src/networking/xmpp/actionSetTimestampToPrivateStore.xmpp.ts

@@ -0,0 +1,37 @@
+import { getChatsPrivateStoreRequest } from './getChatsPrivateStoreRequest.xmpp';
+import { setChatsPrivateStoreRequest } from './setChatsPrivateStoreRequest.xmpp';
+
+const populateChats = (chats: string[], timestamp: string): string => {
+  const populatedData = chats.reduce(
+    (acc, chat) => {
+      acc[chat] = timestamp;
+      return acc;
+    },
+    {} as Record<string, string>
+  );
+
+  return JSON.stringify(populatedData);
+};
+
+export async function actionSetTimestampToPrivateStore(
+  client: any,
+  chatId: string,
+  timestamp: number,
+  chats?: string[]
+) {
+  let storeObj: any = await getChatsPrivateStoreRequest(client);
+
+  if (storeObj && typeof storeObj === 'object') {
+    storeObj[chatId] = timestamp;
+
+    const str = JSON.stringify(storeObj);
+    await setChatsPrivateStoreRequest(client, str);
+    return true;
+  } else {
+    await setChatsPrivateStoreRequest(
+      client,
+      populateChats(chats, timestamp.toString())
+    );
+    return true;
+  }
+}

package/src/networking/xmpp/allRoomPresences.xmpp.ts

@@ -0,0 +1,10 @@
+import { Client, xml } from '@xmpp/client';
+import { store } from '../../roomStore';
+import { presenceInRoom } from './presenceInRoom.xmpp';
+
+export async function allRoomPresences(client: Client) {
+  const rooms = store.getState().rooms.rooms;
+  await Promise.all(
+    Object.keys(rooms).map((roomJid) => presenceInRoom(client, roomJid))
+  );
+}

package/src/networking/xmpp/createPrivateRoom.xmpp.ts

@@ -0,0 +1,26 @@
+import { Client } from '@xmpp/client';
+import { createRoomPresence } from './createRoomPresence.xmpp';
+import { setMeAsOwner } from './setMeAsOwner.xmpp';
+import { roomConfig } from './roomConfig.xmpp';
+import { CONFERENCE_DOMAIN } from '../../helpers/constants/PLATFORM_CONSTANTS';
+
+export async function createPrivateRoom(
+  title: string,
+  description: string,
+  to: string,
+  client: Client
+) {
+  console.log(title, description, to);
+
+  const roomHash = to;
+  const roomId = `${roomHash}${CONFERENCE_DOMAIN}`;
+
+  try {
+    await createRoomPresence(roomId, client);
+    await setMeAsOwner(roomId, client);
+    await roomConfig(roomId, title, description, client);
+  } catch (error) {
+    console.log(error);
+  }
+  return roomId;
+}

package/src/networking/xmpp/createRoom.xmpp.ts

@@ -0,0 +1,35 @@
+import { sha256 } from 'js-sha256';
+
+import { Client } from '@xmpp/client';
+import { createRoomPresence } from './createRoomPresence.xmpp';
+import { setMeAsOwner } from './setMeAsOwner.xmpp';
+import { roomConfig } from './roomConfig.xmpp';
+import { CONFERENCE_DOMAIN } from '../../helpers/constants/PLATFORM_CONSTANTS';
+import { pushSubscriptionService } from '../../services/pushSubscriptionService';
+
+export async function createRoom(
+  title: string,
+  description: string,
+  client: Client
+) {
+  const randomNumber = Math.round(Math.random() * 100_000);
+  const chatNameWithSalt = title + Date.now() + randomNumber;
+  const roomHash = sha256(chatNameWithSalt);
+  const roomId = `${roomHash}${CONFERENCE_DOMAIN}`;
+
+  try {
+    await createRoomPresence(roomId, client);
+    await setMeAsOwner(roomId, client);
+    await roomConfig(roomId, title, description, client);
+
+    const userNick = client.jid?.getLocal();
+    await pushSubscriptionService
+      .subscribeToRoom(client, roomId, userNick)
+      .catch((error) => {
+        console.error('Failed to subscribe to new room for push:', error);
+      });
+  } catch (error) {
+    console.log(error);
+  }
+  return roomId;
+}