@periskope/baileys 6.7.18-17-3 → 6.7.18-17-6

package/lib/Signal/Group/group_cipher.d.ts

@@ -8,6 +8,7 @@ export declare class GroupCipher {
     private readonly senderKeyStore;
     private readonly senderKeyName;
     constructor(senderKeyStore: SenderKeyStore, senderKeyName: SenderKeyName);
+    private queueJob;
     encrypt(paddedPlaintext: Uint8Array | string): Promise<Uint8Array>;
     decrypt(senderKeyMessageBytes: Uint8Array): Promise<Uint8Array>;
     private getSenderKey;

package/lib/Signal/Group/group_cipher.js

@@ -1,45 +1,55 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupCipher = void 0;
-/* @ts-ignore */
 const crypto_1 = require("libsignal/src/crypto");
+const queue_job_1 = __importDefault(require("./queue-job"));
 const sender_key_message_1 = require("./sender-key-message");
 class GroupCipher {
     constructor(senderKeyStore, senderKeyName) {
         this.senderKeyStore = senderKeyStore;
         this.senderKeyName = senderKeyName;
     }
+    queueJob(awaitable) {
+        return (0, queue_job_1.default)(this.senderKeyName.toString(), awaitable);
+    }
     async encrypt(paddedPlaintext) {
-        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
-        if (!record) {
-            throw new Error('No SenderKeyRecord found for encryption');
-        }
-        const senderKeyState = record.getSenderKeyState();
-        if (!senderKeyState) {
-            throw new Error('No session to encrypt message');
-        }
-        const iteration = senderKeyState.getSenderChainKey().getIteration();
-        const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
-        const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
-        const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
-        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
-        return senderKeyMessage.serialize();
+        return await this.queueJob(async () => {
+            const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+            if (!record) {
+                throw new Error('No SenderKeyRecord found for encryption');
+            }
+            const senderKeyState = record.getSenderKeyState();
+            if (!senderKeyState) {
+                throw new Error('No session to encrypt message');
+            }
+            const iteration = senderKeyState.getSenderChainKey().getIteration();
+            const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
+            const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
+            const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
+            await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+            return senderKeyMessage.serialize();
+        });
     }
     async decrypt(senderKeyMessageBytes) {
-        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
-        if (!record) {
-            throw new Error('No SenderKeyRecord found for decryption');
-        }
-        const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
-        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
-        if (!senderKeyState) {
-            throw new Error('No session found to decrypt message');
-        }
-        senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
-        const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
-        const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
-        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
-        return plaintext;
+        return await this.queueJob(async () => {
+            const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+            if (!record) {
+                throw new Error('No SenderKeyRecord found for decryption');
+            }
+            const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+            const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+            if (!senderKeyState) {
+                throw new Error('No session found to decrypt message');
+            }
+            senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+            const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+            const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
+            await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+            return plaintext;
+        });
     }
     getSenderKey(senderKeyState, iteration) {
         let senderChainKey = senderKeyState.getSenderChainKey();

package/lib/Signal/Group/queue-job.d.ts

@@ -1,2 +1 @@
 export default function queueJob<T>(bucket: string | number, awaitable: () => Promise<T>): Promise<T>;
-//# sourceMappingURL=queue-job.d.ts.map

package/lib/Signal/Group/queue-job.js

@@ -1,7 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queueJob;
 const _queueAsyncBuckets = new Map();
 const _gcLimit = 10000;
 async function _asyncQueueExecutor(queue, cleanup) {
     let offt = 0;
+    // eslint-disable-next-line no-constant-condition
     while (true) {
         const limit = Math.min(queue.length, _gcLimit);
         for (let i = offt; i < limit; i++) {
@@ -28,7 +32,7 @@ async function _asyncQueueExecutor(queue, cleanup) {
     }
     cleanup();
 }
-export default function queueJob(bucket, awaitable) {
+function queueJob(bucket, awaitable) {
     // Skip name assignment since it's readonly in strict mode
     if (typeof bucket !== 'string') {
         console.warn('Unhandled bucket type (for naming):', typeof bucket, bucket);
@@ -51,4 +55,3 @@ export default function queueJob(bucket, awaitable) {
     }
     return job;
 }
-//# sourceMappingURL=queue-job.js.map

package/lib/Signal/libsignal.js

@@ -35,22 +35,27 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLibSignalRepository = makeLibSignalRepository;
 const libsignal = __importStar(require("libsignal"));
+/* @ts-ignore */
+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");
+const lid_mapping_1 = require("./lid-mapping");
 function makeLibSignalRepository(auth) {
-    const storage = signalStorage(auth);
-    const parsedKeys = auth.keys;
-    return {
+    const lidMapping = new lid_mapping_1.LIDMappingStore(auth.keys);
+    const storage = signalStorage(auth, lidMapping);
+    // Simple operation-level deduplication (5 minutes)
+    const recentMigrations = new lru_cache_1.LRUCache({
+        max: 500,
+        ttl: 5 * 60 * 1000
+    });
+    const repository = {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
-            // Use transaction to ensure atomicity
-            return parsedKeys.transaction(async () => {
-                return cipher.decrypt(msg);
-            });
+            return cipher.decrypt(msg);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
             const builder = new Group_1.GroupSessionBuilder(storage);
@@ -64,88 +69,200 @@ function makeLibSignalRepository(auth) {
             if (!senderKey) {
                 await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
             }
-            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);
-            });
+            await builder.process(senderName, senderMsg);
         },
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid);
             const session = new libsignal.SessionCipher(storage, addr);
-            // Use transaction to ensure atomicity
-            return parsedKeys.transaction(async () => {
-                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;
-            });
+            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;
         },
         async encryptMessage({ jid, data }) {
-            const addr = jidToSignalProtocolAddress(jid);
+            // LID SINGLE SOURCE OF TRUTH: Always prefer LID when available
+            let encryptionJid = jid;
+            // Check for LID mapping and use it if session exists
+            if (jid.includes('@s.whatsapp.net')) {
+                const lidForPN = await lidMapping.getLIDForPN(jid);
+                if (lidForPN === null || lidForPN === void 0 ? void 0 : lidForPN.includes('@lid')) {
+                    const lidAddr = jidToSignalProtocolAddress(lidForPN);
+                    const { [lidAddr.toString()]: lidSession } = await auth.keys.get('session', [lidAddr.toString()]);
+                    if (lidSession) {
+                        // LID session exists, use it
+                        encryptionJid = lidForPN;
+                    }
+                    else {
+                        // Try to migrate if PN session exists
+                        const pnAddr = jidToSignalProtocolAddress(jid);
+                        const { [pnAddr.toString()]: pnSession } = await auth.keys.get('session', [pnAddr.toString()]);
+                        if (pnSession) {
+                            // Migrate PN to LID
+                            await repository.migrateSession(jid, lidForPN);
+                            encryptionJid = lidForPN;
+                        }
+                    }
+                }
+            }
+            const addr = jidToSignalProtocolAddress(encryptionJid);
             const cipher = new libsignal.SessionCipher(storage, addr);
-            // Use transaction to ensure atomicity
-            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') };
-            });
+            const { type: sigType, body } = await cipher.encrypt(data);
+            const type = sigType === 3 ? 'pkmsg' : 'msg';
+            return { type, ciphertext: Buffer.from(body, 'binary') };
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId);
             const builder = new Group_1.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 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()
-                };
-            });
+            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()
+            };
         },
         async injectE2ESession({ jid, session }) {
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            return parsedKeys.transaction(async () => {
-                await cipher.initOutgoing(session);
-            });
+            await cipher.initOutgoing(session);
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
+        },
+        async storeLIDPNMapping(lid, pn) {
+            await lidMapping.storeLIDPNMapping(lid, pn);
+        },
+        getLIDMappingStore() {
+            return 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(jid) {
+            const addr = jidToSignalProtocolAddress(jid);
+            return auth.keys.transaction(async () => {
+                await auth.keys.set({ session: { [addr.toString()]: null } });
+            });
+        },
+        async migrateSession(fromJid, toJid) {
+            // Only migrate PN → LID
+            if (!fromJid.includes('@s.whatsapp.net') || !toJid.includes('@lid')) {
+                return;
+            }
+            const fromDecoded = (0, WABinary_1.jidDecode)(fromJid);
+            const toDecoded = (0, WABinary_1.jidDecode)(toJid);
+            if (!fromDecoded || !toDecoded)
+                return;
+            const deviceId = fromDecoded.device || 0;
+            const migrationKey = `${fromDecoded.user}.${deviceId}→${toDecoded.user}.${deviceId}`;
+            // Check if recently migrated (5 min window)
+            if (recentMigrations.has(migrationKey)) {
+                return;
+            }
+            // Check if LID session already exists
+            const lidAddr = jidToSignalProtocolAddress(toJid);
+            const { [lidAddr.toString()]: lidExists } = await auth.keys.get('session', [lidAddr.toString()]);
+            if (lidExists) {
+                recentMigrations.set(migrationKey, true);
+                return;
+            }
+            return auth.keys.transaction(async () => {
+                // Store mapping
+                await lidMapping.storeLIDPNMapping(toJid, fromJid);
+                // Load and copy session
+                const fromAddr = jidToSignalProtocolAddress(fromJid);
+                const fromSession = await storage.loadSession(fromAddr.toString());
+                if (fromSession === null || fromSession === void 0 ? void 0 : fromSession.haveOpenSession()) {
+                    // Deep copy session to prevent reference issues
+                    const sessionBytes = fromSession.serialize();
+                    const copiedSession = libsignal.SessionRecord.deserialize(sessionBytes);
+                    // Store at LID address
+                    await storage.storeSession(lidAddr.toString(), copiedSession);
+                    // Delete PN session - maintain single encryption layer
+                    await auth.keys.set({ session: { [fromAddr.toString()]: null } });
+                }
+                recentMigrations.set(migrationKey, true);
+            });
+        },
+        async encryptMessageWithWire({ encryptionJid, wireJid, data }) {
+            const result = await repository.encryptMessage({ jid: encryptionJid, data });
+            return { ...result, wireJid };
+        },
+        destroy() {
+            recentMigrations.clear();
         }
     };
+    return repository;
 }
 const jidToSignalProtocolAddress = (jid) => {
-    const { user, device } = (0, WABinary_1.jidDecode)(jid);
-    return new libsignal.ProtocolAddress(user, device || 0);
+    const decoded = (0, WABinary_1.jidDecode)(jid);
+    const { user, device, server } = decoded;
+    // LID addresses get _1 suffix for Signal protocol
+    const signalUser = server === 'lid' ? `${user}_1` : user;
+    const finalDevice = device || 0;
+    return new libsignal.ProtocolAddress(signalUser, finalDevice);
 };
 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]);
-            if (sess) {
-                return libsignal.SessionRecord.deserialize(sess);
+            try {
+                // LID SINGLE SOURCE OF TRUTH: Auto-redirect PN to LID if mapping exists
+                let actualId = id;
+                if (id.includes('.') && !id.includes('_1')) {
+                    // This is a PN signal address format (e.g., "1234567890.0")
+                    // Convert back to JID to check for LID mapping
+                    const parts = id.split('.');
+                    const device = parts[1] || '0';
+                    const pnJid = device === '0' ? `${parts[0]}@s.whatsapp.net` : `${parts[0]}:${device}@s.whatsapp.net`;
+                    const lidForPN = await lidMapping.getLIDForPN(pnJid);
+                    if (lidForPN === null || lidForPN === void 0 ? void 0 : lidForPN.includes('@lid')) {
+                        const lidAddr = jidToSignalProtocolAddress(lidForPN);
+                        const lidId = lidAddr.toString();
+                        // Check if LID session exists
+                        const { [lidId]: lidSession } = await keys.get('session', [lidId]);
+                        if (lidSession) {
+                            actualId = lidId;
+                        }
+                    }
+                }
+                const { [actualId]: sess } = await keys.get('session', [actualId]);
+                if (sess) {
+                    return libsignal.SessionRecord.deserialize(sess);
+                }
+            }
+            catch (e) {
+                return null;
             }
+            return null;
         },
-        // TODO: Replace with libsignal.SessionRecord when type exports are added to libsignal
         storeSession: async (id, session) => {
             await keys.set({ session: { [id]: session.serialize() } });
         },

package/lib/Signal/lid-mapping.d.ts

@@ -0,0 +1,19 @@
+import type { SignalKeyStoreWithTransaction } from '../Types';
+export declare class LIDMappingStore {
+    private readonly keys;
+    private getLIDFromPN?;
+    private getPNFromLID?;
+    constructor(keys: SignalKeyStoreWithTransaction, getLIDFromPN?: (pn: string) => Promise<string | null>, getPNFromLID?: (lid: string) => Promise<string | null>);
+    /**
+     * Store LID-PN mapping - USER LEVEL
+     */
+    storeLIDPNMapping(lid: string, pn: string): Promise<void>;
+    /**
+     * Get LID for PN - Returns device-specific LID based on user mapping
+     */
+    getLIDForPN(pn: string): Promise<string | null>;
+    /**
+     * Get PN for LID - USER LEVEL with device construction
+     */
+    getPNForLID(lid: string): Promise<string | null>;
+}

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIDMappingStore = void 0;
+const logger_1 = __importDefault(require("../Utils/logger"));
+const WABinary_1 = require("../WABinary");
+class LIDMappingStore {
+    constructor(keys, getLIDFromPN, getPNFromLID) {
+        this.keys = keys;
+        this.getLIDFromPN = getLIDFromPN;
+        this.getPNFromLID = getPNFromLID;
+    }
+    /**
+     * Store LID-PN mapping - USER LEVEL
+     */
+    async storeLIDPNMapping(lid, pn) {
+        // Validate inputs
+        if (!(((0, WABinary_1.isLidUser)(lid) && (0, WABinary_1.isJidUser)(pn)) || ((0, WABinary_1.isJidUser)(lid) && (0, WABinary_1.isLidUser)(pn)))) {
+            logger_1.default.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+            return;
+        }
+        const [lidJid, pnJid] = (0, WABinary_1.isLidUser)(lid) ? [lid, pn] : [pn, lid];
+        const lidDecoded = (0, WABinary_1.jidDecode)(lidJid);
+        const pnDecoded = (0, WABinary_1.jidDecode)(pnJid);
+        if (!lidDecoded || !pnDecoded)
+            return;
+        const pnUser = pnDecoded.user;
+        const lidUser = lidDecoded.user;
+        logger_1.default.trace(`Storing USER LID mapping: PN ${pnUser} → LID ${lidUser}`);
+        await this.keys.transaction(async () => {
+            await this.keys.set({
+                'lid-mapping': {
+                    [pnUser]: lidUser, // "554396160286" -> "102765716062358"
+                    [`${lidUser}_reverse`]: pnUser // "102765716062358_reverse" -> "554396160286"
+                }
+            });
+        });
+        logger_1.default.trace(`USER LID mapping stored: PN ${pnUser} → LID ${lidUser}`);
+    }
+    /**
+     * Get LID for PN - Returns device-specific LID based on user mapping
+     */
+    async getLIDForPN(pn) {
+        if (!(0, WABinary_1.isJidUser)(pn))
+            return null;
+        const decoded = (0, WABinary_1.jidDecode)(pn);
+        if (!decoded)
+            return null;
+        // Look up user-level mapping (whatsmeow approach)
+        const pnUser = decoded.user;
+        const stored = await this.keys.get('lid-mapping', [pnUser]);
+        let lidUser = stored[pnUser];
+        if (!lidUser) {
+            if (this.getLIDFromPN) {
+                const lid = await this.getLIDFromPN(`${pnUser}@s.whatsapp.net`);
+                if (lid) {
+                    const decodedLid = (0, WABinary_1.jidDecode)(lid);
+                    if (decodedLid) {
+                        lidUser = decodedLid.user;
+                        await this.storeLIDPNMapping(`${lidUser}@lid`, `${pnUser}@s.whatsapp.net`);
+                    }
+                }
+            }
+        }
+        if (!lidUser) {
+            logger_1.default.trace(`No LID mapping found for PN user ${pnUser}`);
+            return null;
+        }
+        if (typeof lidUser !== 'string')
+            return null;
+        // Push the PN device ID to the LID to maintain device separation
+        const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+        const deviceSpecificLid = `${lidUser}:${pnDevice}@lid`;
+        logger_1.default.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
+        return deviceSpecificLid;
+    }
+    /**
+     * Get PN for LID - USER LEVEL with device construction
+     */
+    async getPNForLID(lid) {
+        if (!(0, WABinary_1.isLidUser)(lid))
+            return null;
+        const decoded = (0, WABinary_1.jidDecode)(lid);
+        if (!decoded)
+            return null;
+        // Look up reverse user mapping
+        const lidUser = decoded.user;
+        const stored = await this.keys.get('lid-mapping', [`${lidUser}_reverse`]);
+        let pnUser = stored[`${lidUser}_reverse`];
+        if (!pnUser) {
+            if (this.getPNFromLID) {
+                const pn = await this.getPNFromLID(`${lidUser}@lid`);
+                if (pn) {
+                    const decodedJid = (0, WABinary_1.jidDecode)(pn);
+                    if (decodedJid) {
+                        pnUser = decodedJid.user;
+                        await this.storeLIDPNMapping(`${lidUser}@lid`, `${pnUser}@s.whatsapp.net`);
+                    }
+                }
+            }
+        }
+        if (!pnUser || typeof pnUser !== 'string') {
+            logger_1.default.trace(`No reverse mapping found for LID user: ${lidUser}`);
+            return null;
+        }
+        // Construct device-specific PN JID
+        const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+        const pnJid = `${pnUser}:${lidDevice}@s.whatsapp.net`;
+        logger_1.default.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+        return pnJid;
+    }
+}
+exports.LIDMappingStore = LIDMappingStore;

package/lib/Socket/business.d.ts

@@ -32,11 +32,13 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
         [_: string]: string;
     }>;
     sendPeerDataOperationMessage: (pdoMessage: import("../Types").WAProto.Message.IPeerDataOperationRequestMessage) => Promise<string>;
-    createParticipantNodes: (jids: string[], message: import("../Types").WAProto.IMessage, extraAttrs?: BinaryNode["attrs"]) => Promise<{
+    createParticipantNodes: (jids: string[], message: import("../Types").WAProto.IMessage, extraAttrs?: BinaryNode["attrs"], dsmMessage?: import("../Types").WAProto.IMessage) => Promise<{
         nodes: BinaryNode[];
         shouldIncludeDeviceIdentity: boolean;
     }>;
-    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("../WABinary").JidWithDevice[]>;
+    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<(import("../WABinary").JidWithDevice & {
+        wireJid: string;
+    })[]>;
     updateMediaMessage: (message: import("../Types").WAProto.IWebMessageInfo) => Promise<import("../Types").WAProto.IWebMessageInfo>;
     sendMessage: (jid: string, content: import("../Types").AnyMessageContent, options?: import("../Types").MiscMessageGenerationOptions) => Promise<import("../Types").WAProto.WebMessageInfo | undefined>;
     newsletterCreate: (name: string, description?: string) => Promise<import("../Types").NewsletterMetadata>;

package/lib/Socket/index.d.ts

@@ -31,11 +31,13 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
         [_: string]: string;
     }>;
     sendPeerDataOperationMessage: (pdoMessage: import("../Types").WAProto.Message.IPeerDataOperationRequestMessage) => Promise<string>;
-    createParticipantNodes: (jids: string[], message: import("../Types").WAProto.IMessage, extraAttrs?: import("..").BinaryNode["attrs"]) => Promise<{
+    createParticipantNodes: (jids: string[], message: import("../Types").WAProto.IMessage, extraAttrs?: import("..").BinaryNode["attrs"], dsmMessage?: import("../Types").WAProto.IMessage) => Promise<{
         nodes: import("..").BinaryNode[];
         shouldIncludeDeviceIdentity: boolean;
     }>;
-    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("..").JidWithDevice[]>;
+    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<(import("..").JidWithDevice & {
+        wireJid: string;
+    })[]>;
     updateMediaMessage: (message: import("../Types").WAProto.IWebMessageInfo) => Promise<import("../Types").WAProto.IWebMessageInfo>;
     sendMessage: (jid: string, content: import("../Types").AnyMessageContent, options?: import("../Types").MiscMessageGenerationOptions) => Promise<import("../Types").WAProto.WebMessageInfo | undefined>;
     newsletterCreate: (name: string, description?: string) => Promise<import("../Types").NewsletterMetadata>;

package/lib/Socket/messages-recv.d.ts

@@ -21,11 +21,13 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
         [_: string]: string;
     }>;
     sendPeerDataOperationMessage: (pdoMessage: proto.Message.IPeerDataOperationRequestMessage) => Promise<string>;
-    createParticipantNodes: (jids: string[], message: proto.IMessage, extraAttrs?: BinaryNode["attrs"]) => Promise<{
+    createParticipantNodes: (jids: string[], message: proto.IMessage, extraAttrs?: BinaryNode["attrs"], dsmMessage?: proto.IMessage) => Promise<{
         nodes: BinaryNode[];
         shouldIncludeDeviceIdentity: boolean;
     }>;
-    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("../WABinary").JidWithDevice[]>;
+    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<(import("../WABinary").JidWithDevice & {
+        wireJid: string;
+    })[]>;
     updateMediaMessage: (message: proto.IWebMessageInfo) => Promise<proto.IWebMessageInfo>;
     sendMessage: (jid: string, content: import("../Types").AnyMessageContent, options?: import("../Types").MiscMessageGenerationOptions) => Promise<proto.WebMessageInfo | undefined>;
     newsletterCreate: (name: string, description?: string) => Promise<import("../Types").NewsletterMetadata>;

package/lib/Socket/messages-recv.js

@@ -661,7 +661,7 @@ const makeMessagesRecvSocket = (config) => {
         }
     };
     const handleMessage = async (node) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f, _g;
         if (shouldIgnoreJid(node.attrs.from) && node.attrs.from !== '@s.whatsapp.net') {
             logger.debug({ key: node.attrs.key }, 'ignored message');
             await sendMessageAck(node);
@@ -697,6 +697,36 @@ const makeMessagesRecvSocket = (config) => {
             node.attrs.sender_pn) {
             ev.emit('chats.phoneNumberShare', { lid: node.attrs.from, jid: node.attrs.sender_pn });
         }
+        if ((_f = (_e = (_d = msg.message) === null || _d === void 0 ? void 0 : _d.protocolMessage) === null || _e === void 0 ? void 0 : _e.lidMigrationMappingSyncMessage) === null || _f === void 0 ? void 0 : _f.encodedMappingPayload) {
+            try {
+                const payload = msg.message.protocolMessage.lidMigrationMappingSyncMessage.encodedMappingPayload;
+                const decoded = WAProto_1.proto.LIDMigrationMappingSyncPayload.decode(payload);
+                logger.debug({
+                    mappingCount: ((_g = decoded.pnToLidMappings) === null || _g === void 0 ? void 0 : _g.length) || 0,
+                    timestamp: decoded.chatDbMigrationTimestamp
+                }, 'Received LID migration sync message from server');
+                const lidMapping = signalRepository.getLIDMappingStore();
+                if (decoded.pnToLidMappings && decoded.pnToLidMappings.length > 0) {
+                    for (const mapping of decoded.pnToLidMappings) {
+                        const pn = `${mapping.pn}@s.whatsapp.net`;
+                        // Use latestLid if available, otherwise assignedLid (proper LID refresh)
+                        const lidValue = mapping.latestLid || mapping.assignedLid;
+                        const lid = `${lidValue}@lid`;
+                        await lidMapping.storeLIDPNMapping(lid, pn);
+                        logger.debug({
+                            pn,
+                            lid,
+                            assignedLid: mapping.assignedLid,
+                            latestLid: mapping.latestLid,
+                            usedLatest: !!mapping.latestLid
+                        }, 'Stored server-provided PN-LID mapping');
+                    }
+                }
+            }
+            catch (error) {
+                logger.error({ error }, 'Failed to process LID migration sync message');
+            }
+        }
         try {
             await Promise.all([
                 processingMutex.mutex(async () => {