davexbaileys 2.5.22 → 2.5.24

package/README.md

@@ -1,208 +1,41 @@
 # davexbaileys
-[![npm version](https://img.shields.io/npm/v/davexbaileys?style=flat-square&color=blue)](https://www.npmjs.com/package/davexbaileys)
+
+  [![npm version](https://img.shields.io/npm/v/davexbaileys?style=flat-square&color=blue)](https://www.npmjs.com/package/davexbaileys)
   [![npm downloads](https://img.shields.io/npm/dm/davexbaileys?style=flat-square&color=green)](https://www.npmjs.com/package/davexbaileys)
   [![npm total](https://img.shields.io/npm/dt/davexbaileys?style=flat-square&color=orange&label=total+downloads)](https://www.npmjs.com/package/davexbaileys)
   [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](LICENSE)
   [![Node.js >=20](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen?style=flat-square)](https://nodejs.org)
 
-  
-  A lightweight, full-featured WhatsApp Web API library for Node.js — maintained by **Dave Tech**.
+  > A lightweight, full-featured WhatsApp Web API library for Node.js — maintained by **Dave Tech**.
 
-  ## Installation
+  ## Install
 
   ```bash
   npm install davexbaileys
   ```
 
+  ## Requirements
+
+  - **Node.js** `>=20.0.0` (same as official [@whiskeysockets/baileys](https://github.com/WhiskeySockets/Baileys))
+
   ## Quick Start
 
   ```js
   const { makeWASocket, useMultiFileAuthState, fetchLatestBaileysVersion } = require('davexbaileys');
 
   const { version } = await fetchLatestBaileysVersion();
-  const { state, saveCreds } = await useMultiFileAuthState('auth_info');
+  const { state, saveCreds } = await useMultiFileAuthState('./auth');
   const sock = makeWASocket({ version, auth: state });
   sock.ev.on('creds.update', saveCreds);
   ```
 
-  ---
-
-  ## Feature Reference
-
-  ### Connection & Version
-  - `fetchLatestBaileysVersion()` — get bundled WA version
-  - `fetchLatestWaWebVersion()` — fetch live WA version from WhatsApp web
-  - Multi-device (MD) with pairing code or QR
-  - Auto reconnect, smart keepalive
-
-  ---
-
-  ### Messaging
-  - Send text, images, videos, audio, documents, stickers, GIFs, reactions, polls, contacts, locations, events
-  - Edit, delete, forward messages
-  - Quote/reply, mention contacts
-  - `sock.sendMessage(jid, { pin: key })` — pin/unpin a message in a chat
-  - `sock.pinMessage(jid, key, type)` — explicit pin (type=1 pin, type=2 unpin)
-
-  ---
-
-  ### Private Chat Commands
-  | Method | Description |
-  |--------|-------------|
-  | `sock.pinChat(jid, true/false)` | Pin or unpin a chat |
-  | `sock.archiveChat(jid, lastMsgs)` | Archive a chat |
-  | `sock.unarchiveChat(jid, lastMsgs)` | Unarchive a chat |
-  | `sock.markChatRead(jid, lastMsgs)` | Mark chat as read |
-  | `sock.markChatUnread(jid, lastMsgs)` | Mark chat as unread |
-  | `sock.muteChat(jid, durationMs)` | Mute a chat (ms=0 to unmute) |
-  | `sock.unmuteChat(jid)` | Unmute a chat |
-  | `sock.deleteChat(jid, lastMsgs)` | Delete a chat |
-  | `sock.clearChat(jid, lastMsgs)` | Clear all messages |
-  | `sock.star(jid, messages, star)` | Star/unstar messages |
-  | `sock.addOrEditContact(jid, contact)` | Add or edit a contact |
-  | `sock.removeContact(jid)` | Remove a contact |
-  | `sock.chatModify(mod, jid)` | Raw chat modification |
-
-  ---
-
-  ### Privacy & Settings
-  | Method | Description |
-  |--------|-------------|
-  | `sock.updateLastSeenPrivacy(value)` | Who sees your last seen (`all`/`contacts`/`contact_blacklist`/`none`) |
-  | `sock.updateOnlinePrivacy(value)` | Online status visibility |
-  | `sock.updateProfilePicturePrivacy(value)` | Profile photo visibility |
-  | `sock.updateStatusPrivacy(value)` | Status (about) text visibility |
-  | `sock.updateReadReceiptsPrivacy(value)` | Read receipts (blue ticks) |
-  | `sock.updateCallPrivacy(value)` | Who can call you |
-  | `sock.updateGroupsAddPrivacy(value)` | Who can add you to groups |
-  | `sock.updateGroupsJoinPrivacy(value)` | Alias for groups add privacy |
-  | `sock.updateAboutPrivacy(value)` | Bio/about visibility |
-  | `sock.updateMessagesPrivacy(value)` | Messages privacy |
-  | `sock.updateDefaultDisappearingMode(duration)` | Default disappearing mode (seconds) |
-  | `sock.updateDisableLinkPreviewsPrivacy(bool)` | Disable/enable link previews |
-  | `sock.updateStatusResharePrivacy(bool)` | Prevent others from resharing your status |
-  | `sock.silenceUnknownCallers()` | Silence calls from unknown numbers |
-  | `sock.allowUnknownCallers()` | Allow calls from everyone |
-  | `sock.fetchPrivacySettings()` | Fetch all current privacy settings |
-  | `sock.fetchDisappearingDuration(...jids)` | Fetch disappearing message settings for contacts |
-  | `sock.updateProfileStatus(text)` | Update bio/about text |
-  | `sock.updateProfileName(name)` | Update display name |
-  | `sock.updateProfilePicture(jid, buffer)` | Update profile picture |
-  | `sock.removeProfilePicture(jid)` | Remove profile picture |
-
-  ---
-
-  ### Group Commands
-  - Create, leave, join by invite link/code
-  - Add, remove, promote, demote participants
-  - Update subject, description, icon, settings
-  - Toggle ephemeral (disappearing messages)
-  - `sock.groupSettingUpdate(jid, setting)` — lock/unlock settings
-
-  #### Anti-Feature Helpers (Group Moderation)
-  ```js
-  const { isAntiLink, isAntiSticker, isAntiImage, isAntiVideo, isAntiAudio,
-          isAntiDocument, isAntiViewOnce, isAntiBug, isAntiFiles,
-          getMessageType, hasLink, extractLinks,
-          isSticker, isImage, isVideo, isAudio, isDocument,
-          isViewOnce, isReaction, isPoll, isGif, isForwarded,
-          LINK_REGEX } = require('davexbaileys');
-
-  sock.ev.on('messages.upsert', async ({ messages }) => {
-      const msg = messages[0];
-      if (msg.key.fromMe || !msg.key.remoteJid.endsWith('@g.us')) return;
-
-      if (isAntiLink(msg))    { /* delete message, warn user */ }
-      if (isAntiSticker(msg)) { /* no stickers allowed */ }
-      if (isAntiImage(msg))   { /* no images */ }
-      if (isAntiVideo(msg))   { /* no videos */ }
-      if (isAntiAudio(msg))   { /* no voice notes */ }
-      if (isAntiDocument(msg)){ /* no documents */ }
-      if (isAntiViewOnce(msg)){ /* no view-once messages */ }
-      if (isAntiBug(msg))     { /* potential crash message */ }
-      if (isAntiFiles(msg))   { /* no files of any kind */ }
-
-      console.log('Message type:', getMessageType(msg));
-  });
-  ```
-
-  #### Anti-Group-Mention (detect group JIDs in messages/statuses)
-  ```js
-  const { isAntiGroupMention, getGroupMentions } = require('davexbaileys');
-
-  // true if any @g.us JID is mentioned in the message
-  if (isAntiGroupMention(msg)) {
-      const groups = getGroupMentions(msg); // array of group JIDs mentioned
-      await sock.sendMessage(msg.key.remoteJid, { text: '❌ Group mentions are not allowed!' });
-  }
-  ```
-
-  ---
-
-  ### Newsletter (Channel) Commands
-  | Method | Description |
-  |--------|-------------|
-  | `sock.newsletterCreate(name, desc)` | Create a channel |
-  | `sock.newsletterFollow(jid)` | Follow a channel |
-  | `sock.newsletterUnfollow(jid)` | Unfollow |
-  | `sock.newsletterMute(jid)` | Mute a channel |
-  | `sock.newsletterUnmute(jid)` | Unmute |
-  | `sock.newsletterMetadata(type, key)` | Get channel metadata |
-  | `sock.newsletterSubscribers(jid)` | Get subscribers |
-  | `sock.newsletterReactMessage(jid, serverId, emoji)` | React to a post |
-  | `sock.newsletterFetchMessages(jid, count, since)` | Fetch posts |
-  | `sock.newsletterUpdateName(jid, name)` | Update channel name |
-  | `sock.newsletterUpdateDescription(jid, desc)` | Update description |
-  | `sock.newsletterUpdatePicture(jid, buffer)` | Update channel photo |
-  | `sock.newsletterRemovePicture(jid)` | Remove channel photo |
-  | `sock.newsletterDelete(jid)` | Delete channel |
-  | `sock.newsletterChangeOwner(jid, newOwnerJid)` | Transfer ownership |
-  | `sock.subscribeNewsletterUpdates(jid)` | Subscribe to live updates |
-
-  **Events:**
-  ```js
-  sock.ev.on('newsletter.reaction', ({ id, server_id, reaction }) => {});
-  sock.ev.on('newsletter.view',     ({ id, server_id, count }) => {});
-  sock.ev.on('newsletter-participants.update', update => {});
-  sock.ev.on('newsletter-settings.update',    update => {});
-  ```
-
-  > Auto-react: davexbaileys automatically reacts 👍 to new posts from the Dave Tech channel.
-
-  ---
-
-  ### WhatsApp Business
-  - `sock.getCatalog({ jid, limit, cursor })`
-  - `sock.getCollections(jid, limit)`
-  - `sock.getOrderDetails(orderId, tokenBase64)`
-  - `sock.getBusinessProfile(jid)`
-  - `sock.addOrEditQuickReply(quickReply)` — business quick replies
-  - `sock.removeQuickReply(timestamp)`
-
-  ---
-
-  ### Link Preview
-  ```js
-  // Enable rich link previews:
-  const sock = makeWASocket({ generateHighQualityLinkPreview: true, ... });
-
-  // Disable link previews in your account settings:
-  await sock.updateDisableLinkPreviewsPrivacy(true);
-
-  // Utility helper (basic preview object):
-  const { generateLinkPreview } = require('davexbaileys');
-  const preview = generateLinkPreview('https://example.com', 'Example', 'Description');
-  ```
-
-  ---
+  📦 Full docs & API reference → **[npmjs.com/package/davexbaileys](https://www.npmjs.com/package/davexbaileys)**
 
   ## Author
 
-  **Dave Tech**  
-  GitHub: [Davex-254](https://github.com/Davex-254)  
-  Channel: [Dave Tech on WhatsApp](https://whatsapp.com/channel/0029Vb6wIVU9Bb5w69FQvt0W)
+  **Dave Tech** — [WhatsApp Channel](https://whatsapp.com/channel/0029Vb6wIVU9Bb5w69FQvt0W)
 
   ## License
 
-  MIT
+  [MIT](LICENSE) © Dave Tech
   

package/WAProto/GenerateStatics.sh

@@ -0,0 +1,2 @@
+yarn pbjs -t static-module -w commonjs -o ./WAProto/index.js ./WAProto/WAProto.proto;
+yarn pbts -o ./WAProto/index.d.ts ./WAProto/index.js;

package/lib/Defaults/baileys-version.json

@@ -1,3 +1,3 @@
 {
-    "version": [2, 3000, 1032141294]
+    "version": [2, 3000, 1035194821]
 }

package/lib/Defaults/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CACHE_TTLS = exports.INITIAL_PREKEY_COUNT = exports.MIN_PREKEY_COUNT = exports.MEDIA_KEYS = exports.MEDIA_HKDF_KEY_MAPPING = exports.MEDIA_PATH_MAP = exports.DEFAULT_CONNECTION_CONFIG = exports.PROCESSABLE_HISTORY_TYPES = exports.WA_CERT_DETAILS = exports.URL_REGEX = exports.NOISE_WA_HEADER = exports.KEY_BUNDLE_TYPE = exports.DICT_VERSION = exports.NOISE_MODE = exports.WA_DEFAULT_EPHEMERAL = exports.PHONE_CONNECTION_CB = exports.DEF_TAG_PREFIX = exports.DEF_CALLBACK_PREFIX = exports.DEFAULT_ORIGIN = exports.UNAUTHORIZED_CODES = void 0;
+exports.DEFAULT_CACHE_TTLS = exports.MIN_UPLOAD_INTERVAL = exports.UPLOAD_TIMEOUT = exports.INITIAL_PREKEY_COUNT = exports.MIN_PREKEY_COUNT = exports.MEDIA_KEYS = exports.MEDIA_HKDF_KEY_MAPPING = exports.MEDIA_PATH_MAP = exports.DEFAULT_CONNECTION_CONFIG = exports.PROCESSABLE_HISTORY_TYPES = exports.WA_CERT_DETAILS = exports.URL_REGEX = exports.NOISE_WA_HEADER = exports.KEY_BUNDLE_TYPE = exports.DICT_VERSION = exports.NOISE_MODE = exports.WA_DEFAULT_EPHEMERAL = exports.WA_ADV_HOSTED_DEVICE_SIG_PREFIX = exports.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = exports.WA_ADV_DEVICE_SIG_PREFIX = exports.WA_ADV_ACCOUNT_SIG_PREFIX = exports.PHONE_CONNECTION_CB = exports.DEF_TAG_PREFIX = exports.DEF_CALLBACK_PREFIX = exports.CALL_AUDIO_PREFIX = exports.CALL_VIDEO_PREFIX = exports.DEFAULT_ORIGIN = exports.UNAUTHORIZED_CODES = void 0;
 const WAProto_1 = require("../../WAProto");
 const libsignal_1 = require("../Signal/libsignal");
 const Utils_1 = require("../Utils");
@@ -11,9 +11,15 @@ const logger_1 = __importDefault(require("../Utils/logger"));
 const baileys_version_json_1 = require("./baileys-version.json");
 exports.UNAUTHORIZED_CODES = [401, 403, 419];
 exports.DEFAULT_ORIGIN = 'https://web.whatsapp.com';
+exports.CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
+exports.CALL_AUDIO_PREFIX = 'https://call.whatsapp.com/voice/';
 exports.DEF_CALLBACK_PREFIX = 'CB:';
 exports.DEF_TAG_PREFIX = 'TAG:';
 exports.PHONE_CONNECTION_CB = 'CB:Pong';
+exports.WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
+exports.WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
+exports.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5]);
+exports.WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
 exports.WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
 exports.NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
 exports.DICT_VERSION = 3;
@@ -29,11 +35,13 @@ exports.PROCESSABLE_HISTORY_TYPES = [
     WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.PUSH_NAME,
     WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.RECENT,
     WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.FULL,
-    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.ON_DEMAND
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.ON_DEMAND,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.NON_BLOCKING_DATA,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.INITIAL_STATUS_V3
 ];
 exports.DEFAULT_CONNECTION_CONFIG = {
     version: baileys_version_json_1.version,
-    browser: Utils_1.Browsers.ubuntu('Chrome'),
+    browser: Utils_1.Browsers.macOS('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
     connectTimeoutMs: 20000,
     keepAliveIntervalMs: 30000,
@@ -53,6 +61,7 @@ exports.DEFAULT_CONNECTION_CONFIG = {
     linkPreviewImageThumbnailWidth: 192,
     transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
     generateHighQualityLinkPreview: false,
+    enableAutoSessionRecreation: true,
     options: {},
     appStateMacVerification: {
         patch: false,
@@ -97,6 +106,8 @@ exports.MEDIA_HKDF_KEY_MAPPING = {
 exports.MEDIA_KEYS = Object.keys(exports.MEDIA_PATH_MAP);
 exports.MIN_PREKEY_COUNT = 5;
 exports.INITIAL_PREKEY_COUNT = 30;
+exports.UPLOAD_TIMEOUT = 30000;
+exports.MIN_UPLOAD_INTERVAL = 5000;
 exports.DEFAULT_CACHE_TTLS = {
     SIGNAL_STORE: 5 * 60, // 5 minutes
     MSG_RETRY: 60 * 60, // 1 hour

package/lib/Signal/libsignal.js

@@ -35,18 +35,30 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLibSignalRepository = makeLibSignalRepository;
 const libsignal = __importStar(require("libsignal"));
+const lru_cache_1 = require("lru-cache");
 const Utils_1 = require("../Utils");
 const WABinary_1 = require("../WABinary");
 const sender_key_name_1 = require("./Group/sender-key-name");
 const sender_key_record_1 = require("./Group/sender-key-record");
 const Group_1 = require("./Group");
-function makeLibSignalRepository(auth) {
-    const storage = signalStorage(auth);
+const lid_mapping_1 = require("./lid-mapping");
+
+function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+    const lidMapping = new lid_mapping_1.LIDMappingStore(auth.keys, logger, pnToLIDFunc);
+    const storage = signalStorage(auth, lidMapping);
+    const parsedKeys = auth.keys;
+    const migratedSessionCache = new lru_cache_1.LRUCache({
+        ttl: 3 * 24 * 60 * 60 * 1000,
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    });
     return {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
-            return cipher.decrypt(msg);
+            return parsedKeys.transaction(async () => {
+                return cipher.decrypt(msg);
+            }, group);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
             const builder = new Group_1.GroupSessionBuilder(storage);
@@ -56,60 +68,91 @@ function makeLibSignalRepository(auth) {
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
             const senderMsg = new Group_1.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 sender_key_record_1.SenderKeyRecord());
-            }
-            await builder.process(senderName, senderMsg);
+            return parsedKeys.transaction(async () => {
+                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+                if (!senderKey) {
+                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+                }
+                await builder.process(senderName, senderMsg);
+            }, item.groupId);
         },
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid);
             const session = new libsignal.SessionCipher(storage, addr);
-            let result;
-            switch (type) {
-                case 'pkmsg':
-                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
-                    break;
-                case 'msg':
-                    result = await session.decryptWhisperMessage(ciphertext);
-                    break;
-                default:
-                    throw new Error(`Unknown message type: ${type}`);
+            async function doDecrypt() {
+                let result;
+                switch (type) {
+                    case 'pkmsg':
+                        result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                        break;
+                    case 'msg':
+                        result = await session.decryptWhisperMessage(ciphertext);
+                        break;
+                    default:
+                        throw new Error(`Unknown message type: ${type}`);
+                }
+                return result;
             }
-            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);
-            const { type: sigType, body } = await cipher.encrypt(data);
-            const type = sigType === 3 ? 'pkmsg' : 'msg';
-            return { type, ciphertext: Buffer.from(body, 'binary') };
+            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 Group_1.GroupSessionBuilder(storage);
             const senderNameStr = senderName.toString();
-            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
-            if (!senderKey) {
-                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
-            }
-            const senderKeyDistributionMessage = await builder.create(senderName);
-            const session = new Group_1.GroupCipher(storage, senderName);
-            const ciphertext = await session.encrypt(data);
-            return {
-                ciphertext,
-                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
-            };
+            return parsedKeys.transaction(async () => {
+                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+                if (!senderKey) {
+                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+                }
+                const senderKeyDistributionMessage = await builder.create(senderName);
+                const session = new Group_1.GroupCipher(storage, senderName);
+                const ciphertext = await session.encrypt(data);
+                return {
+                    ciphertext,
+                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+                };
+            }, group);
         },
         async injectE2ESession({ jid, session }) {
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            await cipher.initOutgoing(session);
+            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' };
+            }
         }
     };
 }
+
 const jidToSignalProtocolAddress = (jid) => {
     const { user, device } = (0, WABinary_1.jidDecode)(jid);
     return new libsignal.ProtocolAddress(user, device || 0);
@@ -117,7 +160,8 @@ const jidToSignalProtocolAddress = (jid) => {
 const jidToSignalSenderKeyName = (group, user) => {
     return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
-function signalStorage({ creds, keys }) {
+
+function signalStorage({ creds, keys }, lidMapping) {
     return {
         loadSession: async (id) => {
             const { [id]: sess } = await keys.get('session', [id]);

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIDMappingStore = void 0;
+const lru_cache_1 = require("lru-cache");
+const WABinary_1 = require("../WABinary");
+
+class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new lru_cache_1.LRUCache({
+            ttl: 3 * 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 (!((0, WABinary_1.isLidUser)(lid) && (0, WABinary_1.isPnUser)(pn)) &&
+                !((0, WABinary_1.isPnUser)(lid) && (0, WABinary_1.isLidUser)(pn))) {
+                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                continue;
+            }
+            const lidDecoded = (0, WABinary_1.jidDecode)(lid);
+            const pnDecoded = (0, WABinary_1.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 (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) continue;
+            const decoded = (0, WABinary_1.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 = (0, WABinary_1.jidNormalizedUser)(pn);
+                    if ((0, WABinary_1.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 domainType = decoded.domainType;
+            const deviceSpecificLid = `${lidUser}${pnDevice ? `:${pnDevice}` : ''}@${domainType === 128 ? '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) {
+                await this.storeLIDPNMappings(result);
+                for (const pair of result) {
+                    const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn);
+                    const pnUser = pnDecoded?.user;
+                    if (!pnUser) continue;
+                    const lidUser = (0, WABinary_1.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}`);
+                        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 (!(0, WABinary_1.isLidUser)(lid)) return null;
+        const decoded = (0, WABinary_1.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 === 129 ? 'hosted' : 's.whatsapp.net'}`;
+        this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+        return pnJid;
+    }
+}
+exports.LIDMappingStore = LIDMappingStore;