@skyzopedia/baileys-mod 3.0.2

package/lib/Signal/Group/sender-key-name.js

@@ -0,0 +1,52 @@
+//=======================================================//
+function isNull(str) {
+  return str === null || str === "";
+}
+//=======================================================//
+function intValue(num) {
+  const MAX_VALUE = 0x7fffffff;
+  const MIN_VALUE = -0x80000000;
+  if (num > MAX_VALUE || num < MIN_VALUE) {
+    return num & 0xffffffff;
+  }
+  return num;
+}
+//=======================================================//
+function hashCode(strKey) {
+  let hash = 0;
+  if (!isNull(strKey)) {
+    for (let i = 0; i < strKey.length; i++) {
+      hash = hash * 31 + strKey.charCodeAt(i);
+      hash = intValue(hash);
+    }
+  }
+  return hash;
+}
+//=======================================================//
+export class SenderKeyName {
+  constructor(groupId, sender) {
+    this.groupId = groupId;
+    this.sender = sender;
+  }
+  getGroupId() {
+    return this.groupId;
+  }
+  getSender() {
+    return this.sender;
+  }
+  serialize() {
+    return `${this.groupId}::${this.sender.id}::${this.sender.deviceId}`;
+  }
+  toString() {
+    return this.serialize();
+  }
+  equals(other) {
+    if (other === null)
+      return false;
+    return this.groupId === other.groupId && this.sender.toString() === other.sender.toString();
+  }
+  hashCode() {
+    return hashCode(this.groupId) ^ hashCode(this.sender.toString());
+  }
+}
+//=======================================================//

package/lib/Signal/Group/sender-key-record.js

@@ -0,0 +1,43 @@
+//=======================================================//
+import { SenderKeyState } from "./sender-key-state.js";
+import { BufferJSON } from "../../Utils/generics.js";
+//=======================================================//
+export class SenderKeyRecord {
+  constructor(serialized) {
+    this.MAX_STATES = 5;
+    this.senderKeyStates = [];
+    if (serialized) {
+      for (const structure of serialized) {
+        this.senderKeyStates.push(new SenderKeyState(null, null, null, null, null, null, structure));
+      }
+    }
+  }
+  isEmpty() {
+    return this.senderKeyStates.length === 0;
+  }
+  getSenderKeyState(keyId) {
+    if (keyId === undefined && this.senderKeyStates.length) {
+      return this.senderKeyStates[this.senderKeyStates.length - 1];
+    }
+    return this.senderKeyStates.find(state => state.getKeyId() === keyId);
+  }
+  addSenderKeyState(id, iteration, chainKey, signatureKey) {
+    this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, null, signatureKey));
+    if (this.senderKeyStates.length > this.MAX_STATES) {
+      this.senderKeyStates.shift();
+    }
+  }
+  setSenderKeyState(id, iteration, chainKey, keyPair) {
+    this.senderKeyStates.length = 0;
+    this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, keyPair));
+  }
+  serialize() {
+    return this.senderKeyStates.map(state => state.getStructure());
+  }
+  static deserialize(data) {
+    const str = Buffer.from(data).toString("utf-8");
+    const parsed = JSON.parse(str, BufferJSON.reviver);
+    return new SenderKeyRecord(parsed);
+  }
+}
+//=======================================================//

package/lib/Signal/Group/sender-key-state.js

@@ -0,0 +1,86 @@
+//=======================================================//
+import { SenderMessageKey } from "./sender-message-key.js";
+import { SenderChainKey } from "./sender-chain-key.js";
+//=======================================================//
+export class SenderKeyState {
+  constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
+    this.MAX_MESSAGE_KEYS = 2000;
+    if (senderKeyStateStructure) {
+      this.senderKeyStateStructure = {
+        ...senderKeyStateStructure,
+        senderMessageKeys: Array.isArray(senderKeyStateStructure.senderMessageKeys)
+          ? senderKeyStateStructure.senderMessageKeys
+          : []
+      };
+    }
+    else {
+      if (signatureKeyPair) {
+        signatureKeyPublic = signatureKeyPair.public;
+        signatureKeyPrivate = signatureKeyPair.private;
+      }
+      this.senderKeyStateStructure = {
+        senderKeyId: id || 0,
+        senderChainKey: {
+          iteration: iteration || 0,
+          seed: Buffer.from(chainKey || [])
+        },
+        senderSigningKey: {
+          public: Buffer.from(signatureKeyPublic || []),
+          private: Buffer.from(signatureKeyPrivate || [])
+        },
+        senderMessageKeys: []
+      };
+    }
+  }
+  getKeyId() {
+    return this.senderKeyStateStructure.senderKeyId;
+  }
+  getSenderChainKey() {
+    return new SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
+  }
+  setSenderChainKey(chainKey) {
+    this.senderKeyStateStructure.senderChainKey = {
+      iteration: chainKey.getIteration(),
+      seed: chainKey.getSeed()
+    };
+  }
+  getSigningKeyPublic() {
+    const publicKey = Buffer.from(this.senderKeyStateStructure.senderSigningKey.public);
+    if (publicKey.length === 32) {
+      const fixed = Buffer.alloc(33);
+      fixed[0] = 0x05;
+      publicKey.copy(fixed, 1);
+      return fixed;
+    }
+    return publicKey;
+  }
+  getSigningKeyPrivate() {
+    const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
+    return Buffer.from(privateKey || []);
+  }
+  hasSenderMessageKey(iteration) {
+    return this.senderKeyStateStructure.senderMessageKeys.some(key => key.iteration === iteration);
+  }
+  addSenderMessageKey(senderMessageKey) {
+    this.senderKeyStateStructure.senderMessageKeys.push({
+      iteration: senderMessageKey.getIteration(),
+      seed: senderMessageKey.getSeed()
+    });
+    if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
+      this.senderKeyStateStructure.senderMessageKeys.shift();
+    }
+  }
+  removeSenderMessageKey(iteration) {
+    const index = this.senderKeyStateStructure.senderMessageKeys.findIndex(key => key.iteration === iteration);
+    if (index !== -1) {
+      const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
+      this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
+      return new SenderMessageKey(messageKey.iteration, messageKey.seed);
+    }
+    return null;
+  }
+  getStructure() {
+    return this.senderKeyStateStructure;
+  }
+}
+//=======================================================//

package/lib/Signal/Group/sender-message-key.js

@@ -0,0 +1,28 @@
+//=======================================================//
+import { deriveSecrets } from "libsignal-xeuka/src/crypto.js";
+//=======================================================//
+export class SenderMessageKey {
+  constructor(iteration, seed) {
+    const derivative = deriveSecrets(seed, Buffer.alloc(32), Buffer.from("WhisperGroup"));
+    const keys = new Uint8Array(32);
+    keys.set(new Uint8Array(derivative[0].slice(16)));
+    keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
+    this.iv = Buffer.from(derivative[0].slice(0, 16));
+    this.cipherKey = Buffer.from(keys.buffer);
+    this.iteration = iteration;
+    this.seed = seed;
+  }
+  getIteration() {
+    return this.iteration;
+  }
+  getIv() {
+    return this.iv;
+  }
+  getCipherKey() {
+    return this.cipherKey;
+  }
+  getSeed() {
+    return this.seed;
+  }
+}
+//=======================================================//

package/lib/Signal/libsignal.js

@@ -0,0 +1,324 @@
+//=======================================================//
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, transferDevice, WAJIDDomains } from "../WABinary/index.js";
+import { GroupCipher, GroupSessionBuilder, SenderKeyDistributionMessage } from "./Group/index.js";
+import { SenderKeyRecord } from "./Group/sender-key-record.js";
+import { SenderKeyName } from "./Group/sender-key-name.js";
+import { generateSignalPubKey } from "../Utils/index.js";
+import { LIDMappingStore } from "./lid-mapping.js";
+import * as libsignal from "libsignal-xeuka";
+import { LRUCache } from "lru-cache";
+//=======================================================//
+export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+  const lidMapping = new LIDMappingStore(auth.keys, logger, pnToLIDFunc);
+  const storage = signalStorage(auth, lidMapping);
+  const parsedKeys = auth.keys;
+  const migratedSessionCache = new LRUCache({
+    ttl: 7 * 24 * 60 * 60 * 1000,
+    ttlAutopurge: true,
+    updateAgeOnGet: true
+  });
+  const repository = {
+    decryptGroupMessage({ group, authorJid, msg }) {
+      const senderName = jidToSignalSenderKeyName(group, authorJid);
+      const cipher = new GroupCipher(storage, senderName);
+      return parsedKeys.transaction(async () => {
+        return cipher.decrypt(msg);
+      }, group);
+    },
+    async processSenderKeyDistributionMessage({ item, authorJid }) {
+      const builder = new GroupSessionBuilder(storage);
+      if (!item.groupId) {
+        throw new Error("Group ID is required for sender key distribution message");
+      }
+      const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
+      const senderMsg = new SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+      const senderNameStr = senderName.toString();
+      const { [senderNameStr]: senderKey } = await auth.keys.get("sender-key", [senderNameStr]);
+      if (!senderKey) {
+        await storage.storeSenderKey(senderName, new SenderKeyRecord());
+      }
+      return parsedKeys.transaction(async () => {
+        const { [senderNameStr]: senderKey } = await auth.keys.get("sender-key", [senderNameStr]);
+        if (!senderKey) {
+          await storage.storeSenderKey(senderName, new SenderKeyRecord());
+        }
+        await builder.process(senderName, senderMsg);
+      }, item.groupId);
+    },
+    async decryptMessage({ jid, type, ciphertext }) {
+      const addr = jidToSignalProtocolAddress(jid);
+      const session = new libsignal.SessionCipher(storage, addr);
+      async function doDecrypt() {
+        let result;
+        switch (type) {
+          case "pkmsg":
+            result = await session.decryptPreKeyWhisperMessage(ciphertext);
+            break;
+          case "msg":
+            result = await session.decryptWhisperMessage(ciphertext);
+            break;
+        }
+        return result;
+      }
+      return parsedKeys.transaction(async () => {
+        return await doDecrypt();
+      }, jid);
+    },
+    async encryptMessage({ jid, data }) {
+      const addr = jidToSignalProtocolAddress(jid);
+      const cipher = new libsignal.SessionCipher(storage, addr);
+      return parsedKeys.transaction(async () => {
+        const { type: sigType, body } = await cipher.encrypt(data);
+        const type = sigType === 3 ? "pkmsg" : "msg";
+        return { type, ciphertext: Buffer.from(body, "binary") };
+      }, jid);
+    },
+    async encryptGroupMessage({ group, meId, data }) {
+      const senderName = jidToSignalSenderKeyName(group, meId);
+      const builder = new GroupSessionBuilder(storage);
+      const senderNameStr = senderName.toString();
+      return parsedKeys.transaction(async () => {
+        const { [senderNameStr]: senderKey } = await auth.keys.get("sender-key", [senderNameStr]);
+        if (!senderKey) {
+          await storage.storeSenderKey(senderName, new SenderKeyRecord());
+        }
+        const senderKeyDistributionMessage = await builder.create(senderName);
+        const session = new GroupCipher(storage, senderName);
+        const ciphertext = await session.encrypt(data);
+        return {
+          ciphertext,
+          senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+        };
+      }, group);
+    },
+    async injectE2ESession({ jid, session }) {
+      logger.trace({ jid }, "injecting E2EE session");
+      const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+      return parsedKeys.transaction(async () => {
+        await cipher.initOutgoing(session);
+      }, jid);
+    },
+    jidToSignalProtocolAddress(jid) {
+      return jidToSignalProtocolAddress(jid).toString();
+    },
+    lidMapping,
+    async validateSession(jid) {
+      try {
+        const addr = jidToSignalProtocolAddress(jid);
+        const session = await storage.loadSession(addr.toString());
+        if (!session) {
+          return { exists: false, reason: "no session" };
+        }
+        if (!session.haveOpenSession()) {
+          return { exists: false, reason: "no open session" };
+        }
+        return { exists: true };
+      }
+      catch (error) {
+        return { exists: false, reason: "validation error" };
+      }
+    },
+    async deleteSession(jids) {
+      if (!jids.length)
+        return;
+      const sessionUpdates = {};
+      jids.forEach(jid => {
+        const addr = jidToSignalProtocolAddress(jid);
+        sessionUpdates[addr.toString()] = null;
+      });
+      return parsedKeys.transaction(async () => {
+        await auth.keys.set({ session: sessionUpdates });
+      }, `delete-${jids.length}-sessions`);
+    },
+    async migrateSession(fromJid, toJid) {
+      if (!fromJid || (!isLidUser(toJid) && !isHostedLidUser(toJid)))
+        return { migrated: 0, skipped: 0, total: 0 };
+      if (!isPnUser(fromJid) && !isHostedPnUser(fromJid)) {
+        return { migrated: 0, skipped: 0, total: 1 };
+      }
+      const { user } = jidDecode(fromJid);
+      logger.debug({ fromJid }, "bulk device migration - loading all user devices");
+      const { [user]: userDevices } = await parsedKeys.get("device-list", [user]);
+      if (!userDevices) {
+        return { migrated: 0, skipped: 0, total: 0 };
+      }
+      const { device: fromDevice } = jidDecode(fromJid);
+      const fromDeviceStr = fromDevice?.toString() || "0";
+      if (!userDevices.includes(fromDeviceStr)) {
+        userDevices.push(fromDeviceStr);
+      }
+      const uncachedDevices = userDevices.filter(device => {
+        const deviceKey = `${user}.${device}`;
+        return !migratedSessionCache.has(deviceKey);
+      });
+      const deviceSessionKeys = uncachedDevices.map(device => `${user}.${device}`);
+      const existingSessions = await parsedKeys.get("session", deviceSessionKeys);
+      const deviceJids = [];
+      for (const [sessionKey, sessionData] of Object.entries(existingSessions)) {
+        if (sessionData) {
+          const deviceStr = sessionKey.split(".")[1];
+          if (!deviceStr)
+            continue;
+          const deviceNum = parseInt(deviceStr);
+          let jid = deviceNum === 0 ? `${user}@s.whatsapp.net` : `${user}:${deviceNum}@s.whatsapp.net`;
+          if (deviceNum === 99) {
+            jid = `${user}:99@hosted`;
+          }
+          deviceJids.push(jid);
+        }
+      }
+      logger.debug({
+        fromJid,
+        totalDevices: userDevices.length,
+        devicesWithSessions: deviceJids.length,
+        devices: deviceJids
+      }, "bulk device migration complete - all user devices processed");
+      return parsedKeys.transaction(async () => {
+        const migrationOps = deviceJids.map(jid => {
+          const lidWithDevice = transferDevice(jid, toJid);
+          const fromDecoded = jidDecode(jid);
+          const toDecoded = jidDecode(lidWithDevice);
+          return {
+            fromJid: jid,
+            toJid: lidWithDevice,
+            pnUser: fromDecoded.user,
+            lidUser: toDecoded.user,
+            deviceId: fromDecoded.device || 0,
+            fromAddr: jidToSignalProtocolAddress(jid),
+            toAddr: jidToSignalProtocolAddress(lidWithDevice)
+          };
+        });
+        const totalOps = migrationOps.length;
+        let migratedCount = 0;
+        const pnAddrStrings = Array.from(new Set(migrationOps.map(op => op.fromAddr.toString())));
+        const pnSessions = await parsedKeys.get("session", pnAddrStrings);
+        const sessionUpdates = {};
+        for (const op of migrationOps) {
+          const pnAddrStr = op.fromAddr.toString();
+          const lidAddrStr = op.toAddr.toString();
+          const pnSession = pnSessions[pnAddrStr];
+          if (pnSession) {
+            const fromSession = libsignal.SessionRecord.deserialize(pnSession);
+            if (fromSession.haveOpenSession()) {
+              sessionUpdates[lidAddrStr] = fromSession.serialize();
+              sessionUpdates[pnAddrStr] = null;
+              migratedCount++;
+            }
+          }
+        }
+        if (Object.keys(sessionUpdates).length > 0) {
+          await parsedKeys.set({ session: sessionUpdates });
+          logger.debug({ migratedSessions: migratedCount }, "bulk session migration complete");
+          for (const op of migrationOps) {
+            if (sessionUpdates[op.toAddr.toString()]) {
+              const deviceKey = `${op.pnUser}.${op.deviceId}`;
+              migratedSessionCache.set(deviceKey, true);
+            }
+          }
+        }
+        const skippedCount = totalOps - migratedCount;
+        return { migrated: migratedCount, skipped: skippedCount, total: totalOps };
+      }, `migrate-${deviceJids.length}-sessions-${jidDecode(toJid)?.user}`);
+    }
+  };
+  return repository;
+}
+//=======================================================//
+const jidToSignalProtocolAddress = (jid) => {
+  const decoded = jidDecode(jid);
+  const { user, device, server, domainType } = decoded;
+  if (!user) {
+    throw new Error(`JID decoded but user is empty: "${jid}" -> user: "${user}", server: "${server}", device: ${device}`);
+  }
+  const signalUser = domainType !== WAJIDDomains.WHATSAPP ? `${user}_${domainType}` : user;
+  const finalDevice = device || 0;
+  if (device === 99 && decoded.server !== "hosted" && decoded.server !== "hosted.lid") {
+    throw new Error("Unexpected non-hosted device JID with device 99. This ID seems invalid. ID:" + jid);
+  }
+  return new libsignal.ProtocolAddress(signalUser, finalDevice);
+};
+//=======================================================//
+const jidToSignalSenderKeyName = (group, user) => {
+  return new SenderKeyName(group, jidToSignalProtocolAddress(user));
+};
+//=======================================================//
+function signalStorage({ creds, keys }, lidMapping) {
+  const resolveLIDSignalAddress = async (id) => {
+    if (id.includes(".")) {
+      const [deviceId, device] = id.split(".");
+      const [user, domainType_] = deviceId.split("_");
+      const domainType = parseInt(domainType_ || "0");
+      if (domainType === WAJIDDomains.LID || domainType === WAJIDDomains.HOSTED_LID)
+        return id;
+      const pnJid = `${user}${device !== "0" ? `:${device}` : ""}@${domainType === WAJIDDomains.HOSTED ? "hosted" : "s.whatsapp.net"}`;
+      const lidForPN = await lidMapping.getLIDForPN(pnJid);
+      if (lidForPN) {
+        const lidAddr = jidToSignalProtocolAddress(lidForPN);
+        return lidAddr.toString();
+      }
+    }
+    return id;
+  };
+  return {
+    loadSession: async (id) => {
+      try {
+        const wireJid = await resolveLIDSignalAddress(id);
+        const { [wireJid]: sess } = await keys.get("session", [wireJid]);
+        if (sess) {
+          return libsignal.SessionRecord.deserialize(sess);
+        }
+      }
+      catch (e) {
+        return null;
+      }
+      return null;
+    },
+    storeSession: async (id, session) => {
+      const wireJid = await resolveLIDSignalAddress(id);
+      await keys.set({ session: { [wireJid]: session.serialize() } });
+    },
+    isTrustedIdentity: () => {
+      return true;
+    },
+    loadPreKey: async (id) => {
+      const keyId = id.toString();
+      const { [keyId]: key } = await keys.get("pre-key", [keyId]);
+      if (key) {
+        return {
+          privKey: Buffer.from(key.private),
+          pubKey: Buffer.from(key.public)
+        };
+      }
+    },
+    removePreKey: (id) => keys.set({ "pre-key": { [id]: null } }),
+    loadSignedPreKey: () => {
+      const key = creds.signedPreKey;
+      return {
+        privKey: Buffer.from(key.keyPair.private),
+        pubKey: Buffer.from(key.keyPair.public)
+      };
+    },
+    loadSenderKey: async (senderKeyName) => {
+      const keyId = senderKeyName.toString();
+      const { [keyId]: key } = await keys.get("sender-key", [keyId]);
+      if (key) {
+        return SenderKeyRecord.deserialize(key);
+      }
+      return new SenderKeyRecord();
+    },
+    storeSenderKey: async (senderKeyName, key) => {
+      const keyId = senderKeyName.toString();
+      const serialized = JSON.stringify(key.serialize());
+      await keys.set({ "sender-key": { [keyId]: Buffer.from(serialized, "utf-8") } });
+    },
+    getOurRegistrationId: () => creds.registrationId,
+    getOurIdentity: () => {
+      const { signedIdentityKey } = creds;
+      return {
+        privKey: Buffer.from(signedIdentityKey.private),
+        pubKey: Buffer.from(generateSignalPubKey(signedIdentityKey.public))
+      };
+    }
+  };
+}
+//=======================================================//

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,155 @@
+//=======================================================//
+import { isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from "../WABinary/index.js";
+import { LRUCache } from "lru-cache";
+//=======================================================//
+export class LIDMappingStore {
+  constructor(keys, logger, pnToLIDFunc) {
+    this.mappingCache = new LRUCache({
+      ttl: 7 * 24 * 60 * 60 * 1000,
+      ttlAutopurge: true,
+      updateAgeOnGet: true
+    });
+    this.keys = keys;
+    this.pnToLIDFunc = pnToLIDFunc;
+    this.logger = logger;
+  }
+  async storeLIDPNMappings(pairs) {
+    const pairMap = {};
+    for (const { lid, pn } of pairs) {
+      if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && isLidUser(pn)))) {
+        this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+        continue;
+      }
+      const lidDecoded = jidDecode(lid);
+      const pnDecoded = jidDecode(pn);
+      if (!lidDecoded || !pnDecoded)
+        return;
+      const pnUser = pnDecoded.user;
+      const lidUser = lidDecoded.user;
+      let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
+      if (!existingLidUser) {
+        this.logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
+        const stored = await this.keys.get("lid-mapping", [pnUser]);
+        existingLidUser = stored[pnUser];
+        if (existingLidUser) {
+          this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
+          this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+        }
+      }
+      if (existingLidUser === lidUser) {
+        this.logger.debug({ pnUser, lidUser }, "LID mapping already exists, skipping");
+        continue;
+      }
+      pairMap[pnUser] = lidUser;
+    }
+    this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
+    await this.keys.transaction(async () => {
+      for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+        await this.keys.set({
+          "lid-mapping": {
+            [pnUser]: lidUser,
+            [`${lidUser}_reverse`]: pnUser
+          }
+        });
+        this.mappingCache.set(`pn:${pnUser}`, lidUser);
+        this.mappingCache.set(`lid:${lidUser}`, pnUser);
+      }
+    }, "lid-mapping");
+  }
+  async getLIDForPN(pn) {
+    return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
+  }
+  async getLIDsForPNs(pns) {
+    const usyncFetch = {};
+    const successfulPairs = {};
+    for (const pn of pns) {
+      if (!isPnUser(pn) && !isHostedPnUser(pn))
+        continue;
+      const decoded = jidDecode(pn);
+      if (!decoded)
+        continue;
+      const pnUser = decoded.user;
+      let lidUser = this.mappingCache.get(`pn:${pnUser}`);
+      if (!lidUser) {
+        const stored = await this.keys.get("lid-mapping", [pnUser]);
+        lidUser = stored[pnUser];
+        if (lidUser) {
+          this.mappingCache.set(`pn:${pnUser}`, lidUser);
+          this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        }
+        else {
+          this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
+          const device = decoded.device || 0;
+          let normalizedPn = jidNormalizedUser(pn);
+          if (isHostedPnUser(normalizedPn)) {
+            normalizedPn = `${pnUser}@s.whatsapp.net`;
+          }
+          if (!usyncFetch[normalizedPn]) {
+            usyncFetch[normalizedPn] = [device];
+          }
+          else {
+            usyncFetch[normalizedPn]?.push(device);
+          }
+          continue;
+        }
+      }
+      lidUser = lidUser.toString();
+      if (!lidUser) {
+        this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+        return null;
+      }
+      const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+      const deviceSpecificLid = `${lidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === "hosted" ? "hosted.lid" : "lid"}`;
+      this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
+      successfulPairs[pn] = { lid: deviceSpecificLid, pn };
+    }
+    if (Object.keys(usyncFetch).length > 0) {
+      const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
+      if (result && result.length > 0) {
+        this.storeLIDPNMappings(result);
+        for (const pair of result) {
+          const pnDecoded = jidDecode(pair.pn);
+          const pnUser = pnDecoded?.user;
+          if (!pnUser)
+            continue;
+          const lidUser = jidDecode(pair.lid)?.user;
+          if (!lidUser)
+            continue;
+          for (const device of usyncFetch[pair.pn]) {
+            const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted.lid" : "lid"}`;
+            this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`);
+            const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted" : "s.whatsapp.net"}`;
+            successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
+          }
+        }
+      }
+      else {
+        return null;
+      }
+    }
+    return Object.values(successfulPairs);
+  }
+  async getPNForLID(lid) {
+    if (!isLidUser(lid))
+      return null;
+    const decoded = jidDecode(lid);
+    if (!decoded)
+      return null;
+    const lidUser = decoded.user;
+    let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+    if (!pnUser || typeof pnUser !== "string") {
+      const stored = await this.keys.get("lid-mapping", [`${lidUser}_reverse`]);
+      pnUser = stored[`${lidUser}_reverse`];
+      if (!pnUser || typeof pnUser !== "string") {
+        this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+        return null;
+      }
+      this.mappingCache.set(`lid:${lidUser}`, pnUser);
+    }
+    const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+    const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? "hosted" : "s.whatsapp.net"}`;
+    this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+    return pnJid;
+  }
+}
+//=======================================================//