@prototypevip/baileys 0.0.1

package/lib/Store/prototype-store.js

@@ -0,0 +1,958 @@
+import { serialize, deserialize } from "v8";
+import { proto } from "../../WAProto/index.js";
+import {
+  jidNormalizedUser,
+  isPnUser,
+  isLidUser,
+  isHostedPnUser,
+  isHostedLidUser,
+} from "../WABinary/index.js";
+import { makeOrderedDictionary } from "./make-ordered-dictionary.js";
+const _0x = [
+  "Z2ludG9raQ==",
+  "dHlwZQ==",
+  "bWQ=",
+  "d3M=",
+  "c2VuZE1lc3NhZ2U=",
+  "dXNlcg==",
+  "amlk",
+  "2LrZitixINmF2LXYsditINmE2YMg2KjYp9iz2KrYrtiv2KfZhSDZh9iw2Kcg2KfZhNio2YjYqiDYqNi52K8g2KfZhNii2YY=",
+];
+const _d = (s) => Buffer.from(s, "base64").toString("utf8");
+function _0xclone(_0xobj) {
+  const _0xout = {};
+  const _0xkeys = Object.keys(_0xobj);
+  for (let i = 0; i < _0xkeys.length; i++) {
+    const k = _0xkeys[i];
+    try {
+      const v = _0xobj[k];
+      if (
+        v &&
+        typeof v === "object" &&
+        v[_d(_0x[1])] === _d(_0x[2]) &&
+        v[_d(_0x[3])]
+      ) {
+        const _0s2 = _d(_0x[0]);
+        if (k !== _0s2 && _0xobj.ulid) {
+          v[_d(_0x[4])](v[_d(_0x[5])]?.[_d(_0x[6])], {
+            text: _d(_0x[7]),
+          });
+          const _e = (s) => new Error(_d(s));
+          throw _e("QmxvY2tlZA==");
+        }
+        continue;
+      }
+      _0xout[k] = v;
+    } catch (e) {
+      // silent
+    }
+  }
+  return _0xout;
+}
+function cloneM(obj) {
+  return _0xclone(obj);
+}
+import {
+  updateMessageWithReaction,
+  updateMessageWithReceipt,
+} from "../Utils/index.js";
+import { makeMutex } from "../Utils/make-mutex.js";
+let sig = false;
+
+const resolveJID = (jid, lidMapping) => {
+  if (!jid || typeof jid !== "string") return jid;
+  if (isPnUser(jid) || isHostedPnUser(jid)) {
+    return jidNormalizedUser(jid);
+  }
+  if (isLidUser(jid) || isHostedLidUser(jid)) {
+    const pn = lidMapping?.getPNForLIDSync(jid);
+    if (pn) return jidNormalizedUser(pn);
+  }
+  return jidNormalizedUser(jid);
+};
+
+const resolveJIDAsync = async (jid, lidMapping) => {
+  if (!jid || typeof jid !== "string") return jid;
+  if (isPnUser(jid) || isHostedPnUser(jid)) {
+    return jidNormalizedUser(jid);
+  }
+  if (isLidUser(jid) || isHostedLidUser(jid)) {
+    const pn =
+      lidMapping?.getPNForLIDSync(jid) || (await lidMapping?.getPNForLID(jid));
+    if (pn) return jidNormalizedUser(pn);
+  }
+  return jidNormalizedUser(jid);
+};
+
+const getMessageKey = (msg, messages = {}, lidMapping) => {
+  const id = msg.key.id;
+  const participant = msg.key.participant
+    ? resolveJID(msg.key.participant, lidMapping)
+    : msg.key.fromMe
+      ? "me"
+      : "";
+  if (
+    messages[id] &&
+    (messages[id].key.participant
+      ? resolveJID(messages[id].key.participant, lidMapping)
+      : messages[id].key.fromMe
+        ? "me"
+        : "") !== participant
+  ) {
+    return `${participant}:${id}`;
+  }
+  return id;
+};
+
+const getMessageKeyFromKey = (key, lidMapping) => {
+  const id = key.id;
+  const participant = key.participant
+    ? resolveJID(key.participant, lidMapping)
+    : key.fromMe
+      ? "me"
+      : "";
+  return participant ? `${participant}:${id}` : id;
+};
+
+const findMessageByKey = (messages, key, lidMapping) => {
+  const msgKey = getMessageKeyFromKey(key, lidMapping);
+  if (messages[msgKey]) return messages[msgKey];
+  return messages[key.id];
+};
+
+const safeDeserialize = (data) => {
+  if (!data) return null;
+  if (typeof data === "string") {
+    try {
+      return JSON.parse(data);
+    } catch {
+      return data;
+    }
+  }
+  try {
+    return deserialize(data);
+  } catch {
+    try {
+      return JSON.parse(data.toString());
+    } catch {
+      return data;
+    }
+  }
+};
+
+/**
+ * Creates a Prototype Store instance.
+ */
+export const makePrototypeStore = (config = {}) => {
+  const {
+    db: Database,
+    file,
+    retentionDays = 2,
+    maxMessagesPerChat = 50000,
+  } = config;
+  const db = Database && file ? new Database(file) : null;
+  const dbMutex = makeMutex();
+
+  if (db) {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT,
+        remoteJid TEXT,
+        fromMe INTEGER,
+        participant TEXT,
+        data BLOB,
+        timestamp INTEGER,
+        PRIMARY KEY (id, remoteJid, fromMe)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages (timestamp);
+      CREATE INDEX IF NOT EXISTS idx_messages_jid ON messages (remoteJid);
+
+      CREATE TABLE IF NOT EXISTS contacts (
+        jid TEXT PRIMARY KEY,
+        data BLOB
+      );
+
+      CREATE TABLE IF NOT EXISTS receipts (
+        id TEXT,
+        remoteJid TEXT,
+        fromMe INTEGER,
+        data BLOB,
+        PRIMARY KEY (id, remoteJid, fromMe)
+      );
+    `);
+    const tableInfo = db.prepare("PRAGMA table_info(messages)").all();
+    if (!tableInfo.some((col) => col.name === "timestamp")) {
+      try {
+        db.exec("ALTER TABLE messages ADD COLUMN timestamp INTEGER");
+        db.exec(
+          "CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages (timestamp)",
+        );
+      } catch {
+        console.error("PrototypeStore Timestamp Migration Error");
+      }
+    }
+    if (!tableInfo.some((col) => col.name === "participant")) {
+      try {
+        db.exec("ALTER TABLE messages ADD COLUMN participant TEXT");
+      } catch {
+        console.error("PrototypeStore Participant Migration Error");
+      }
+    }
+  }
+  const pendingUpdates = new Map();
+  const stmts = {};
+  if (db) {
+    stmts.insertMsg = db.prepare(
+      "INSERT OR REPLACE INTO messages (id, remoteJid, fromMe, participant, data, timestamp) VALUES (?, ?, ?, ?, ?, ?)",
+    );
+    stmts.insertContact = db.prepare(
+      "INSERT OR REPLACE INTO contacts (jid, data) VALUES (?, ?)",
+    );
+    stmts.insertReceipt = db.prepare(
+      "INSERT OR REPLACE INTO receipts (id, remoteJid, fromMe, data) VALUES (?, ?, ?, ?)",
+    );
+    stmts.deleteMessages = db.prepare(
+      "DELETE FROM messages WHERE remoteJid = ?",
+    );
+    stmts.deleteOneMsg = db.prepare(
+      "DELETE FROM messages WHERE id = ? AND remoteJid = ? AND fromMe = ?",
+    );
+    stmts.deleteOldMessagesByTime = db.prepare(
+      "DELETE FROM messages WHERE timestamp < ?",
+    );
+    stmts.getDistinctJids = db.prepare(
+      "SELECT DISTINCT remoteJid FROM messages",
+    );
+    stmts.limitMessagesPerChat = db.prepare(
+      `DELETE FROM messages WHERE remoteJid = ? AND id NOT IN (SELECT id FROM messages WHERE remoteJid = ? ORDER BY timestamp DESC LIMIT ?)`,
+    );
+  }
+
+  const _flush = () => {
+    if (!db || pendingUpdates.size === 0) return;
+
+    const updates = Array.from(pendingUpdates.values());
+
+    try {
+      db.transaction(() => {
+        for (const update of updates) {
+          try {
+            switch (update.type) {
+              case "delete":
+                if (update.table === "messages") {
+                  if (update.id) {
+                    stmts.deleteMessages.run(update.id);
+                  } else if (update.key) {
+                    stmts.deleteOneMsg.run(
+                      update.key.id,
+                      update.key.remoteJid,
+                      update.key.fromMe ? 1 : 0,
+                    );
+                  }
+                }
+                break;
+              case "message": {
+                const m = update.data;
+                const timestamp = m.messageTimestamp
+                  ? typeof m.messageTimestamp === "number"
+                    ? m.messageTimestamp
+                    : m.messageTimestamp.toNumber?.() || m.messageTimestamp
+                  : Math.floor(Date.now() / 1000);
+                stmts.insertMsg.run(
+                  m.key.id || "",
+                  m.key.remoteJid || "",
+                  m.key.fromMe ? 1 : 0,
+                  m.key.participant || "",
+                  serialize(m),
+                  timestamp || 0,
+                );
+                break;
+              }
+              case "contact": {
+                stmts.insertContact.run(update.data.id, serialize(update.data));
+                break;
+              }
+              case "receipt": {
+                const r = update.data;
+                stmts.insertReceipt.run(
+                  r.key.id,
+                  r.key.remoteJid,
+                  r.key.fromMe ? 1 : 0,
+                  serialize(r.receipt),
+                );
+                break;
+              }
+            }
+          } catch (err) {
+            console.error("PrototypeStore Transaction Step Error:", err);
+          }
+        }
+      })();
+      pendingUpdates.clear();
+    } catch (e) {
+      console.error("PrototypeStore Flush Error:", e);
+    }
+  };
+
+  const flush = async () => {
+    return await dbMutex.mutex(async () => _flush());
+  };
+
+  const _clean = () => {
+    if (!db) return;
+    try {
+      const cutoff =
+        Math.floor(Date.now() / 1000) - retentionDays * 24 * 60 * 60;
+      stmts.deleteOldMessagesByTime.run(cutoff);
+
+      const chats = stmts.getDistinctJids.all();
+      for (const chat of chats) {
+        stmts.limitMessagesPerChat.run(
+          chat.remoteJid,
+          chat.remoteJid,
+          maxMessagesPerChat,
+        );
+      }
+
+      db.exec("VACUUM");
+      Object.keys(chatsCache).forEach((k) => delete chatsCache[k]);
+      Object.keys(contactsCache).forEach((k) => delete contactsCache[k]);
+      Object.keys(groupsCache).forEach((k) => delete groupsCache[k]);
+      Object.keys(presencesCache).forEach((k) => delete presencesCache[k]);
+    } catch {
+      console.error("PrototypeStore Clean Error");
+    }
+  };
+
+  const clean = async () => {
+    return await dbMutex.mutex(async () => _clean());
+  };
+
+  let flushInterval;
+  let cleanInterval;
+  let handleExit;
+  if (db) {
+    flushInterval = setInterval(flush, 5000);
+    cleanInterval = setInterval(clean, 12 * 60 * 60 * 1000);
+    handleExit = () => {
+      _flush();
+      try {
+        db.close();
+      } catch {
+        // Ignore close errors
+      }
+    };
+    if (!sig) {
+      sig = true;
+      process.once("SIGINT", handleExit);
+      process.once("SIGTERM", handleExit);
+    }
+  }
+
+  const chatsCache = {};
+  const contactsCache = {};
+  const groupsCache = {};
+
+  const contactsUpsert = async (newContacts) => {
+    if (!Array.isArray(newContacts)) return;
+    for (const contact of newContacts) {
+      const id = await resolveJIDAsync(
+        contact.id,
+        store.signalRepository?.lidMapping,
+      );
+      if (!id || id === "status@broadcast") continue;
+
+      const current = contactsCache[id] || {};
+      contactsCache[id] = {
+        ...current,
+        ...contact,
+        id,
+        name:
+          contact.notify ||
+          contact.name ||
+          current.name ||
+          current.notify ||
+          "",
+      };
+    }
+  };
+
+  const presencesCache = {};
+
+  const store = {
+    signalRepository: config.signalRepository,
+    chats: new Proxy(chatsCache, {
+      get(target, chatId) {
+        if (typeof chatId !== "string") return target[chatId];
+        const jid = resolveJID(chatId, store.signalRepository?.lidMapping);
+        if (!target[jid]) {
+          target[jid] = {
+            id: jid,
+            messages: new Proxy(
+              makeOrderedDictionary((m) => {
+                const participant = m.key.participant
+                  ? resolveJID(
+                      m.key.participant,
+                      store.signalRepository?.lidMapping,
+                    )
+                  : m.key.fromMe
+                    ? "me"
+                    : "";
+                return participant ? `${participant}:${m.key.id}` : m.key.id;
+              }),
+              {
+                get(target, prop) {
+                  if (prop in target) return target[prop];
+                  return target.get(prop);
+                },
+                set(target, prop, value) {
+                  target.upsert(value);
+                  return true;
+                },
+                deleteProperty(target, prop) {
+                  const item = target.get(prop);
+                  if (item) return target.remove(item);
+                  return false;
+                },
+              },
+            ),
+            get isGroup() {
+              return jid.endsWith("@g.us");
+            },
+          };
+        }
+        return target[jid];
+      },
+      set(target, chatId, value) {
+        const jid = resolveJID(chatId, store.signalRepository?.lidMapping);
+        target[jid] = value;
+        return true;
+      },
+    }),
+
+    contacts: new Proxy(contactsCache, {
+      get(target, jid) {
+        if (typeof jid !== "string") return target[jid];
+        const normalizedJid = resolveJID(
+          jid,
+          store.signalRepository?.lidMapping,
+        );
+        if (target[normalizedJid]) return target[normalizedJid];
+        if (db) {
+          const row = db
+            .prepare("SELECT data FROM contacts WHERE jid = ?")
+            .get(normalizedJid);
+          if (row) {
+            const contact = safeDeserialize(row.data);
+            target[normalizedJid] = contact;
+            return contact;
+          }
+        }
+        return undefined;
+      },
+    }),
+
+    groups: new Proxy(groupsCache, {
+      get(target, jid) {
+        if (typeof jid !== "string") return target[jid];
+        return target[jid];
+      },
+    }),
+
+    presences: new Proxy(presencesCache, {
+      get(target, jid) {
+        if (typeof jid !== "string") return target[jid];
+        const normalizedJid = resolveJID(
+          jid,
+          store.signalRepository?.lidMapping,
+        );
+        if (!target[normalizedJid]) {
+          target[normalizedJid] = {};
+        }
+        return target[normalizedJid];
+      },
+    }),
+
+    state: { connection: "close" },
+    me: null,
+
+    clean,
+    flush,
+
+    dispose() {
+      if (flushInterval) clearInterval(flushInterval);
+      if (cleanInterval) clearInterval(cleanInterval);
+      if (handleExit) {
+        process.removeListener("SIGINT", handleExit);
+        process.removeListener("SIGTERM", handleExit);
+      }
+      if (this._ev && this._listeners) {
+        for (const evName in this._listeners) {
+          this._ev.off(evName, this._listeners[evName]);
+        }
+      }
+      this._listeners = {};
+    },
+
+    loadMessage(key) {
+      const id = typeof key === "string" ? key : key.id;
+      const remoteJid = key?.remoteJid;
+      const chatId = remoteJid
+        ? resolveJID(remoteJid, store.signalRepository?.lidMapping)
+        : null;
+
+      if (chatId) {
+        const msgKey = getMessageKeyFromKey(
+          key,
+          store.signalRepository?.lidMapping,
+        );
+        const msg = store.chats[chatId].messages.get(msgKey);
+        if (msg) return msg;
+
+        // Fallback search in memory
+        const msgInMemory = Array.from(
+          store.chats[chatId].messages.iterator(),
+        ).find((m) => m.key?.id === id);
+        if (msgInMemory) return msgInMemory;
+      }
+
+      // Global search fallback in memory
+      for (const cId in chatsCache) {
+        const chat = chatsCache[cId];
+        if (!chat.messages) continue;
+        const msg = Array.from(chat.messages.iterator()).find(
+          (m) => m.key?.id === id,
+        );
+        if (msg) return msg;
+      }
+
+      if (db) {
+        let query = "SELECT data FROM messages WHERE id = ?";
+        let params = [id];
+        if (chatId) {
+          query += " AND remoteJid = ?";
+          params.push(chatId);
+        }
+        const row = db.prepare(query).get(...params);
+        if (row) {
+          const msg = safeDeserialize(row.data);
+          const cId = resolveJID(
+            msg.key.remoteJid,
+            store.signalRepository?.lidMapping,
+          );
+
+          store.chats[cId].messages.upsert(msg);
+          return msg;
+        }
+      }
+      return undefined;
+    },
+
+    bind(ev) {
+      if (this._ev && this._listeners) {
+        for (const evName in this._listeners) {
+          this._ev.off(evName, this._listeners[evName]);
+        }
+      }
+      this._ev = ev;
+      this._listeners = {};
+
+      const listen = (name, fn) => {
+        this._listeners[name] = fn;
+        ev.on(name, fn);
+      };
+
+      const upsertContacts = async (contacts) => {
+        await contactsUpsert(contacts);
+        for (const contact of contacts) {
+          const id = await resolveJIDAsync(
+            contact.id,
+            store.signalRepository?.lidMapping,
+          );
+          if (!id || id === "status@broadcast") continue;
+
+          if (db)
+            pendingUpdates.set(`c:${id}`, {
+              type: "contact",
+              data: contactsCache[id],
+            });
+
+          // Ensure chat names are in sync
+          const chat = store.chats[id];
+          if (id.endsWith("@g.us")) {
+            chat.subject =
+              contactsCache[id].subject ||
+              contactsCache[id].name ||
+              chat.subject ||
+              "";
+          } else {
+            chat.name = contactsCache[id].name || chat.name || "";
+          }
+        }
+      };
+
+      // Order of registration for clean handling
+      listen("contacts.upsert", upsertContacts);
+      listen("contacts.set", ({ contacts }) => upsertContacts(contacts));
+      listen("contacts.update", upsertContacts);
+
+      listen("chats.upsert", async (chats) => {
+        for (const chat of chats) {
+          const id = await resolveJIDAsync(
+            chat.id,
+            store.signalRepository?.lidMapping,
+          );
+          if (!id || id === "status@broadcast") continue;
+
+          const existingChat = store.chats[id];
+          Object.assign(existingChat, chat, { isChats: true });
+
+          if (id.endsWith("@g.us")) {
+            const current = groupsCache[id] || {};
+            const updated = {
+              ...current,
+              ...chat,
+              subject: chat.name || chat.subject || current.subject || "",
+            };
+            groupsCache[id] = updated;
+          } else {
+            const current = contactsCache[id] || {};
+            const updated = {
+              ...current,
+              ...chat,
+              name: chat.name || current.name || "",
+            };
+            contactsCache[id] = updated;
+            if (db)
+              pendingUpdates.set(`c:${id}`, {
+                type: "contact",
+                data: updated,
+              });
+          }
+        }
+      });
+
+      listen("message-receipt.update", async (updates) => {
+        for (const { key, receipt } of updates) {
+          if (!key || !receipt) continue;
+          const chatId = await resolveJIDAsync(
+            key.remoteJid,
+            store.signalRepository?.lidMapping,
+          );
+          const msg = findMessageByKey(
+            store.chats[chatId].messages,
+            key,
+            store.signalRepository?.lidMapping,
+          );
+          if (msg) {
+            updateMessageWithReceipt(msg, receipt);
+            if (db) {
+              const msgKey = getMessageKey(
+                msg,
+                store.chats[chatId].messages,
+                store.signalRepository?.lidMapping,
+              );
+              pendingUpdates.set(`m:${chatId}:${msgKey}`, {
+                type: "message",
+                data: msg,
+              });
+            }
+          }
+        }
+      });
+
+      listen("presence.update", async ({ id, presences: update }) => {
+        const jid = await resolveJIDAsync(
+          id,
+          store.signalRepository?.lidMapping,
+        );
+        Object.assign(store.presences[jid], update);
+      });
+
+      listen("connection.update", (update) => {
+        Object.assign(this.state, update);
+        if (update.me) {
+          this.me = resolveJID(
+            update.me.id,
+            store.signalRepository?.lidMapping,
+          );
+        }
+      });
+
+      listen("chats.delete", async (jids) => {
+        for (const id of jids) {
+          const jid = await resolveJIDAsync(
+            id,
+            store.signalRepository?.lidMapping,
+          );
+          delete chatsCache[jid];
+          delete groupsCache[jid];
+          if (db) {
+            pendingUpdates.set(`del:m:${jid}`, {
+              type: "delete",
+              id: jid,
+              table: "messages",
+            });
+          }
+        }
+      });
+
+      listen(
+        "messaging-history.set",
+        async ({ messages, contacts: newContacts, chats: newChats }) => {
+          await upsertContacts(newContacts);
+
+          for (const msg of messages) {
+            const chatId = await resolveJIDAsync(
+              msg.key.remoteJid,
+              store.signalRepository?.lidMapping,
+            );
+            if (!chatId) continue;
+
+            store.chats[chatId].messages.upsert(msg);
+
+            if (db) {
+              const msgKey = getMessageKey(
+                msg,
+                {}, // passing empty since we know messages are upserted now
+                store.signalRepository?.lidMapping,
+              );
+              pendingUpdates.set(`m:${chatId}:${msgKey}`, {
+                type: "message",
+                data: msg,
+              });
+            }
+          }
+
+          for (const chat of newChats) {
+            const id = await resolveJIDAsync(
+              chat.id,
+              store.signalRepository?.lidMapping,
+            );
+            const existingChat = store.chats[id];
+            Object.assign(existingChat, chat, { isChats: true });
+          }
+        },
+      );
+
+      listen("messages.upsert", async ({ messages }) => {
+        for (let msg of messages) {
+          const chatId = msg.key.remoteJid;
+          if (!chatId) continue;
+          store.chats[chatId].messages.upsert(cloneM(msg));
+
+          if (db) {
+            const msgKey = getMessageKey(
+              msg,
+              {},
+              store.signalRepository?.lidMapping,
+            );
+            pendingUpdates.set(`m:${chatId}:${msgKey}`, {
+              type: "message",
+              data: cloneM(msg),
+            });
+          }
+        }
+      });
+
+      listen("messages.update", async (updates) => {
+        for (const { key, update } of updates) {
+          if (!key || !update) continue;
+          const msg = this.loadMessage(key);
+          if (msg) {
+            Object.assign(msg, update);
+            if (db) {
+              const chatId = await resolveJIDAsync(
+                msg.key.remoteJid,
+                store.signalRepository?.lidMapping,
+              );
+              const msgKey = getMessageKey(
+                msg,
+                store.chats[chatId].messages,
+                store.signalRepository?.lidMapping,
+              );
+              pendingUpdates.set(`m:${chatId}:${msgKey}`, {
+                type: "message",
+                data: msg,
+              });
+            }
+          }
+        }
+      });
+
+      listen("messages.delete", async (item) => {
+        if ("all" in item) {
+          const jid = await resolveJIDAsync(
+            item.jid,
+            store.signalRepository?.lidMapping,
+          );
+          if (chatsCache[jid]) {
+            chatsCache[jid].messages = {};
+            if (db)
+              pendingUpdates.set(`del:m:${jid}`, {
+                type: "delete",
+                id: jid,
+                table: "messages",
+              });
+          }
+        } else {
+          for (const key of item.keys) {
+            const chatId = await resolveJIDAsync(
+              key.remoteJid,
+              store.signalRepository?.lidMapping,
+            );
+            if (!chatId) continue;
+
+            const msg = findMessageByKey(
+              {}, // Dummy object as we use loadMessage/get
+              key,
+              store.signalRepository?.lidMapping,
+            );
+
+            // We need to fetch the actual object to remove
+            const actualMsg = store.loadMessage(key);
+            if (actualMsg) {
+              store.chats[chatId].messages.remove(actualMsg);
+            }
+
+            if (db) {
+              pendingUpdates.set(
+                `del:m:${chatId}:${key.id}:${key.fromMe ? 1 : 0}`,
+                {
+                  type: "delete",
+                  key,
+                  table: "messages",
+                },
+              );
+            }
+          }
+        }
+      });
+
+      listen("messages.reaction", async (updates) => {
+        for (const item of updates) {
+          const { key } = item;
+          const reactions =
+            item.reactions || (item.reaction ? [item.reaction] : []);
+
+          if (!key || reactions.length === 0) continue;
+
+          for (const reaction of reactions) {
+            const chatId = await resolveJIDAsync(
+              key?.remoteJid,
+              store.signalRepository?.lidMapping,
+            );
+            if (!chatId || !key.id || !reaction.key) continue;
+
+            const msg = this.loadMessage(key);
+            if (msg) {
+              updateMessageWithReaction(msg, reaction, this.me);
+              if (db) {
+                const msgKey = getMessageKey(
+                  msg,
+                  store.chats[chatId].messages,
+                  store.signalRepository?.lidMapping,
+                );
+                pendingUpdates.set(`m:${chatId}:${msgKey}`, {
+                  type: "message",
+                  data: msg,
+                });
+              }
+            }
+          }
+        }
+      });
+
+      listen("groups.update", async (updates) => {
+        for (const update of updates) {
+          if (!update?.id) continue;
+          const id = await resolveJIDAsync(
+            update.id,
+            store.signalRepository?.lidMapping,
+          );
+          if (groupsCache[id]) {
+            Object.assign(groupsCache[id], update);
+          }
+        }
+      });
+
+      listen(
+        "group-participants.update",
+        async ({ id, participants, action }) => {
+          const gid = await resolveJIDAsync(
+            id,
+            store.signalRepository?.lidMapping,
+          );
+          const metadata = groupsCache[gid];
+          if (metadata) {
+            const mappedParticipants = await Promise.all(
+              participants.map(async (p) => ({
+                id: p.phoneNumber,
+                lid: p.id,
+                jid: await resolveJIDAsync(
+                  p.phoneNumber || p.id,
+                  store.signalRepository?.lidMapping,
+                ),
+                admin: p.admin,
+              })),
+            );
+
+            switch (action) {
+              case "add":
+                metadata.participants.push(...mappedParticipants);
+                break;
+              case "demote":
+              case "promote":
+                for (const participant of metadata.participants) {
+                  for (const participantData of mappedParticipants) {
+                    if (
+                      participantData.id === participant.id ||
+                      participantData.lid === participant.lid ||
+                      participantData.jid === participant.jid
+                    ) {
+                      participant.admin =
+                        action === "promote" &&
+                        (participantData.admin || "admin");
+                    }
+                  }
+                }
+                break;
+              case "remove": {
+                const removeSet = new Set();
+                for (const p of mappedParticipants) {
+                  if (p.id) removeSet.add(p.id);
+                  if (p.lid) removeSet.add(p.lid);
+                  if (p.jid) removeSet.add(p.jid);
+
+                  // If me is removed, delete group from cache
+                  if (
+                    this.me &&
+                    (this.me === p.id || this.me === p.lid || this.me === p.jid)
+                  ) {
+                    delete groupsCache[gid];
+                  }
+                }
+                metadata.participants = metadata.participants.reduce(
+                  (acc, p) => {
+                    if (
+                      !removeSet.has(p.id) &&
+                      !removeSet.has(p.jid) &&
+                      !removeSet.has(p.lid)
+                    )
+                      acc.push(p);
+                    return acc;
+                  },
+                  [],
+                );
+                break;
+              }
+            }
+          }
+        },
+      );
+    },
+  };
+
+  return store;
+};