@periskope/baileys 6.7.18-17-2 → 6.7.18-17-4

package/lib/Signal/Group/group_cipher.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupCipher = void 0;
+/* @ts-ignore */
 const crypto_1 = require("libsignal/src/crypto");
 const sender_key_message_1 = require("./sender-key-message");
 class GroupCipher {
@@ -30,13 +31,9 @@ class GroupCipher {
             throw new Error('No SenderKeyRecord found for decryption');
         }
         const senderKeyMessage = new sender_key_message_1.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
-        let senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
-        // Fallback: try to get the latest sender key state if specific keyId not found
+        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
         if (!senderKeyState) {
-            senderKeyState = record.getSenderKeyState();
-            if (!senderKeyState) {
-                throw new Error('No session found to decrypt message');
-            }
+            throw new Error('No session found to decrypt message');
         }
         senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
         const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());

package/lib/Signal/libsignal.d.ts

@@ -1,3 +1,3 @@
-import { SignalAuthState } from '../Types';
-import { SignalRepository } from '../Types/Signal';
+import type { SignalAuthState } from '../Types';
+import type { SignalRepository } from '../Types/Signal';
 export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;

package/lib/Signal/libsignal.js

@@ -35,19 +35,29 @@ 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);
-    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 parsedKeys = auth.keys;
+    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 auth.keys.transaction(async () => {
+            return parsedKeys.transaction(async () => {
                 return cipher.decrypt(msg);
             });
         },
@@ -59,7 +69,11 @@ 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();
-            return auth.keys.transaction(async () => {
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            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());
@@ -70,8 +84,8 @@ function makeLibSignalRepository(auth) {
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid);
             const session = new libsignal.SessionCipher(storage, addr);
-            // Use transaction to ensure atomicityAdd commentMore actions
-            return auth.keys.transaction(async () => {
+            // Use transaction to ensure atomicity
+            return parsedKeys.transaction(async () => {
                 let result;
                 switch (type) {
                     case 'pkmsg':
@@ -80,15 +94,41 @@ function makeLibSignalRepository(auth) {
                     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 atomicityAdd commentMore actions
-            return auth.keys.transaction(async () => {
+            // 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') };
@@ -98,8 +138,7 @@ function makeLibSignalRepository(auth) {
             const senderName = jidToSignalSenderKeyName(group, meId);
             const builder = new Group_1.GroupSessionBuilder(storage);
             const senderNameStr = senderName.toString();
-            // Use transaction to ensure atomicity
-            return auth.keys.transaction(async () => {
+            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());
@@ -115,31 +154,136 @@ function makeLibSignalRepository(auth) {
         },
         async injectE2ESession({ jid, session }) {
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            // Use transaction to ensure atomicity
-            return auth.keys.transaction(async () => {
+            return parsedKeys.transaction(async () => {
                 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,17 @@
+import type { SignalKeyStoreWithTransaction } from '../Types';
+export declare class LIDMappingStore {
+    private readonly keys;
+    constructor(keys: SignalKeyStoreWithTransaction);
+    /**
+     * 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,89 @@
+"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) {
+        this.keys = keys;
+    }
+    /**
+     * 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]);
+        const lidUser = stored[pnUser];
+        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`]);
+        const pnUser = stored[`${lidUser}_reverse`];
+        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 () => {

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

@@ -16,11 +16,13 @@ export declare const makeMessagesSocket: (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<JidWithDevice[]>;
+    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<(JidWithDevice & {
+        wireJid: string;
+    })[]>;
     updateMediaMessage: (message: proto.IWebMessageInfo) => Promise<proto.IWebMessageInfo>;
     sendMessage: (jid: string, content: AnyMessageContent, options?: MiscMessageGenerationOptions) => Promise<proto.WebMessageInfo | undefined>;
     newsletterCreate: (name: string, description?: string) => Promise<import("../Types").NewsletterMetadata>;