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

package/lib/Signal/libsignal.js

@@ -35,15 +35,24 @@ 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 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;
-    return {
+    const repository = {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
@@ -92,7 +101,31 @@ function makeLibSignalRepository(auth) {
             });
         },
         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 () => {
@@ -127,23 +160,128 @@ function makeLibSignalRepository(auth) {
         },
         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) => {

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>;

package/lib/Socket/messages-send.js

@@ -10,6 +10,7 @@ const WAProto_1 = require("../../WAProto");
 const Defaults_1 = require("../Defaults");
 const Utils_1 = require("../Utils");
 const link_preview_1 = require("../Utils/link-preview");
+const make_mutex_1 = require("../Utils/make-mutex");
 const WABinary_1 = require("../WABinary");
 const WAUSync_1 = require("../WAUSync");
 const groups_1 = require("./groups");
@@ -23,6 +24,8 @@ const makeMessagesSocket = (config) => {
             stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
             useClones: false
         });
+    // Prevent race conditions in Signal session encryption by user
+    const encryptionMutex = (0, make_mutex_1.makeKeyedMutex)();
     let mediaConn;
     const refreshMediaConn = async (forceGet = false) => {
         const media = await mediaConn;
@@ -111,22 +114,70 @@ const makeMessagesSocket = (config) => {
         const readType = privacySettings.readreceipts === 'all' ? 'read' : 'read-self';
         await sendReceipts(keys, readType);
     };
+    /**
+     * Deduplicate JIDs when both LID and PN versions exist for same user
+     * Prefers LID over PN to maintain single encryption layer
+     */
+    const deduplicateLidPnJids = (jids) => {
+        var _a, _b;
+        const lidUsers = new Set();
+        const filteredJids = [];
+        // Collect all LID users
+        for (const jid of jids) {
+            if (jid.includes('@lid')) {
+                const user = (_a = (0, WABinary_1.jidDecode)(jid)) === null || _a === void 0 ? void 0 : _a.user;
+                if (user)
+                    lidUsers.add(user);
+            }
+        }
+        // Filter out PN versions when LID exists
+        for (const jid of jids) {
+            if (jid.includes('@s.whatsapp.net')) {
+                const user = (_b = (0, WABinary_1.jidDecode)(jid)) === null || _b === void 0 ? void 0 : _b.user;
+                if (user && lidUsers.has(user)) {
+                    logger.debug({ jid }, 'Skipping PN - LID version exists');
+                    continue;
+                }
+            }
+            filteredJids.push(jid);
+        }
+        return filteredJids;
+    };
     /** Fetch all the devices we've to send a message to */
     const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
-        var _a;
+        var _a, _b;
         const deviceResults = [];
         if (!useCache) {
             logger.debug('not using cache for devices');
         }
         const toFetch = [];
-        jids = Array.from(new Set(jids));
+        // Deduplicate and normalize JIDs
+        jids = deduplicateLidPnJids(Array.from(new Set(jids)));
         for (let jid of jids) {
-            const user = (_a = (0, WABinary_1.jidDecode)(jid)) === null || _a === void 0 ? void 0 : _a.user;
+            const decoded = (0, WABinary_1.jidDecode)(jid);
+            const user = decoded === null || decoded === void 0 ? void 0 : decoded.user;
+            const device = decoded === null || decoded === void 0 ? void 0 : decoded.device;
+            const isExplicitDevice = typeof device === 'number' && device >= 0;
+            // Handle explicit device JIDs directly
+            if (isExplicitDevice && user) {
+                deviceResults.push({
+                    user,
+                    device,
+                    wireJid: jid // Preserve exact JID format for wire protocol
+                });
+                continue;
+            }
+            // For user JIDs, normalize and prepare for device enumeration
             jid = (0, WABinary_1.jidNormalizedUser)(jid);
             if (useCache) {
                 const devices = userDevicesCache.get(user);
                 if (devices) {
-                    deviceResults.push(...devices);
+                    const isLidJid = jid.includes('@lid');
+                    const devicesWithWire = devices.map(d => ({
+                        ...d,
+                        wireJid: isLidJid ? (0, WABinary_1.jidEncode)(d.user, 'lid', d.device) : (0, WABinary_1.jidEncode)(d.user, 's.whatsapp.net', d.device)
+                    }));
+                    deviceResults.push(...devicesWithWire);
                     logger.trace({ user }, 'using cache for devices');
                 }
                 else {
@@ -140,6 +191,14 @@ const makeMessagesSocket = (config) => {
         if (!toFetch.length) {
             return deviceResults;
         }
+        const requestedLidUsers = new Set();
+        for (const jid of toFetch) {
+            if (jid.includes('@lid')) {
+                const user = (_a = (0, WABinary_1.jidDecode)(jid)) === null || _a === void 0 ? void 0 : _a.user;
+                if (user)
+                    requestedLidUsers.add(user);
+            }
+        }
         const query = new WAUSync_1.USyncQuery().withContext('message').withDeviceProtocol();
         for (const jid of toFetch) {
             query.withUser(new WAUSync_1.USyncUser().withId(jid));
@@ -150,8 +209,27 @@ const makeMessagesSocket = (config) => {
             const deviceMap = {};
             for (const item of extracted) {
                 deviceMap[item.user] = deviceMap[item.user] || [];
-                deviceMap[item.user].push(item);
-                deviceResults.push(item);
+                (_b = deviceMap[item.user]) === null || _b === void 0 ? void 0 : _b.push(item);
+            }
+            // Process each user's devices as a group for bulk LID migration
+            for (const [user, userDevices] of Object.entries(deviceMap)) {
+                const isLidUser = requestedLidUsers.has(user);
+                // Process all devices for this user
+                for (const item of userDevices) {
+                    const finalWireJid = isLidUser
+                        ? (0, WABinary_1.jidEncode)(user, 'lid', item.device)
+                        : (0, WABinary_1.jidEncode)(item.user, 's.whatsapp.net', item.device);
+                    deviceResults.push({
+                        ...item,
+                        wireJid: finalWireJid
+                    });
+                    logger.debug({
+                        user: item.user,
+                        device: item.device,
+                        finalWireJid,
+                        usedLid: isLidUser
+                    }, 'Processed device with LID priority');
+                }
             }
             for (const key in deviceMap) {
                 userDevicesCache.set(key, deviceMap[key]);
@@ -159,24 +237,180 @@ const makeMessagesSocket = (config) => {
         }
         return deviceResults;
     };
+    // Helper to check if JID has migrated LID session
+    const checkForMigratedLidSession = async (jid) => {
+        if (!jid.includes('@s.whatsapp.net'))
+            return false;
+        const lidMapping = signalRepository.getLIDMappingStore();
+        const lidForPN = await lidMapping.getLIDForPN(jid);
+        if (!(lidForPN === null || lidForPN === void 0 ? void 0 : lidForPN.includes('@lid')))
+            return false;
+        const lidSignalId = signalRepository.jidToSignalProtocolAddress(lidForPN);
+        const lidSessions = await authState.keys.get('session', [lidSignalId]);
+        return !!lidSessions[lidSignalId];
+    };
     const assertSessions = async (jids, force) => {
+        var _a;
         let didFetchNewSession = false;
-        let jidsRequiringFetch = [];
+        const jidsRequiringFetch = [];
+        // Apply same deduplication as in getUSyncDevices
+        jids = deduplicateLidPnJids(jids);
         if (force) {
-            jidsRequiringFetch = jids;
+            // Check which sessions are missing (with LID migration check)
+            const addrs = jids.map(jid => signalRepository.jidToSignalProtocolAddress(jid));
+            const sessions = await authState.keys.get('session', addrs);
+            // Helper to check session for a JID
+            const checkJidSession = async (jid) => {
+                const signalId = signalRepository.jidToSignalProtocolAddress(jid);
+                let hasSession = !!sessions[signalId];
+                // Check for migrated LID session if PN session missing
+                if (!hasSession) {
+                    hasSession = await checkForMigratedLidSession(jid);
+                    if (hasSession) {
+                        logger.debug({ jid }, 'Found migrated LID session during force assert, skipping PN fetch');
+                    }
+                }
+                // Add to fetch list if no session exists
+                if (!hasSession) {
+                    if (jid.includes('@lid')) {
+                        logger.debug({ jid }, 'No LID session found, will create new LID session');
+                    }
+                    jidsRequiringFetch.push(jid);
+                }
+            };
+            // Process all JIDs
+            for (const jid of jids) {
+                await checkJidSession(jid);
+            }
         }
         else {
+            const lidMapping = signalRepository.getLIDMappingStore();
             const addrs = jids.map(jid => signalRepository.jidToSignalProtocolAddress(jid));
             const sessions = await authState.keys.get('session', addrs);
+            // Group JIDs by user for bulk migration
+            const userGroups = new Map();
             for (const jid of jids) {
-                const signalId = signalRepository.jidToSignalProtocolAddress(jid);
-                if (!sessions[signalId]) {
-                    jidsRequiringFetch.push(jid);
+                const user = (0, WABinary_1.jidNormalizedUser)(jid);
+                if (!userGroups.has(user)) {
+                    userGroups.set(user, []);
+                }
+                userGroups.get(user).push(jid);
+            }
+            // Helper to check LID mapping for a user
+            const checkUserLidMapping = async (user, userJids) => {
+                if (!userJids.some(jid => jid.includes('@s.whatsapp.net'))) {
+                    return { shouldMigrate: false, lidForPN: undefined };
+                }
+                try {
+                    const mapping = await lidMapping.getLIDForPN(user);
+                    if (mapping === null || mapping === void 0 ? void 0 : mapping.includes('@lid')) {
+                        logger.debug({ user, lidForPN: mapping, deviceCount: userJids.length }, 'User has LID mapping - preparing bulk migration');
+                        return { shouldMigrate: true, lidForPN: mapping };
+                    }
+                }
+                catch (error) {
+                    logger.debug({ user, error }, 'Failed to check LID mapping for user');
+                }
+                return { shouldMigrate: false, lidForPN: undefined };
+            };
+            // Helper to migrate a single device
+            const migrateDeviceToLid = async (jid, lidForPN) => {
+                if (!jid.includes('@s.whatsapp.net'))
+                    return;
+                try {
+                    const jidDecoded = (0, WABinary_1.jidDecode)(jid);
+                    const deviceId = (jidDecoded === null || jidDecoded === void 0 ? void 0 : jidDecoded.device) || 0;
+                    const lidDecoded = (0, WABinary_1.jidDecode)(lidForPN);
+                    const lidWithDevice = (0, WABinary_1.jidEncode)(lidDecoded === null || lidDecoded === void 0 ? void 0 : lidDecoded.user, 'lid', deviceId);
+                    await signalRepository.migrateSession(jid, lidWithDevice);
+                    logger.debug({ fromJid: jid, toJid: lidWithDevice }, 'Migrated device session to LID');
+                    // Delete PN session after successful migration
+                    try {
+                        await signalRepository.deleteSession(jid);
+                        logger.debug({ deletedPNSession: jid }, 'Deleted PN session after migration');
+                    }
+                    catch (deleteError) {
+                        logger.warn({ jid, error: deleteError }, 'Failed to delete PN session');
+                    }
+                }
+                catch (migrationError) {
+                    logger.warn({ jid, error: migrationError }, 'Failed to migrate device session');
+                }
+            };
+            // Process each user group for potential bulk LID migration
+            for (const [user, userJids] of userGroups) {
+                const mappingResult = await checkUserLidMapping(user, userJids);
+                const shouldMigrateUser = mappingResult.shouldMigrate;
+                const lidForPN = mappingResult.lidForPN;
+                // Migrate all devices for this user if LID mapping exists
+                if (shouldMigrateUser && lidForPN) {
+                    // Migrate each device individually
+                    for (const jid of userJids) {
+                        await migrateDeviceToLid(jid, lidForPN);
+                    }
+                    logger.info({
+                        user,
+                        lidMapping: lidForPN,
+                        deviceCount: userJids.length
+                    }, 'Completed migration attempt for user devices');
+                }
+                // Helper to check session for migrated user
+                const checkMigratedSession = async (jid) => {
+                    const signalId = signalRepository.jidToSignalProtocolAddress(jid);
+                    let hasSession = !!sessions[signalId];
+                    let jidToFetch = jid;
+                    // Check if we should use migrated LID session instead
+                    if (shouldMigrateUser && lidForPN && jid.includes('@s.whatsapp.net')) {
+                        const originalDecoded = (0, WABinary_1.jidDecode)(jid);
+                        const deviceId = (originalDecoded === null || originalDecoded === void 0 ? void 0 : originalDecoded.device) || 0;
+                        const lidDecoded = (0, WABinary_1.jidDecode)(lidForPN);
+                        const lidWithDevice = (0, WABinary_1.jidEncode)(lidDecoded === null || lidDecoded === void 0 ? void 0 : lidDecoded.user, 'lid', deviceId);
+                        // Check if LID session exists
+                        const lidSignalId = signalRepository.jidToSignalProtocolAddress(lidWithDevice);
+                        const lidSessions = await authState.keys.get('session', [lidSignalId]);
+                        hasSession = !!lidSessions[lidSignalId];
+                        jidToFetch = lidWithDevice;
+                        if (hasSession) {
+                            logger.debug({ originalJid: jid, lidJid: lidWithDevice }, '✅ Found bulk-migrated LID session');
+                        }
+                    }
+                    // Add to fetch list if no session exists
+                    if (!hasSession) {
+                        jidsRequiringFetch.push(jidToFetch);
+                        logger.debug({ jid: jidToFetch, originalJid: jid !== jidToFetch ? jid : undefined }, 'Adding to session fetch list');
+                    }
+                };
+                // Now check which sessions need to be fetched for this user
+                for (const jid of userJids) {
+                    await checkMigratedSession(jid);
                 }
             }
         }
         if (jidsRequiringFetch.length) {
             logger.debug({ jidsRequiringFetch }, 'fetching sessions');
+            // DEBUG: Check if there are PN versions of LID users being fetched
+            const lidUsersBeingFetched = new Set();
+            const pnUsersBeingFetched = new Set();
+            for (const jid of jidsRequiringFetch) {
+                const user = (_a = (0, WABinary_1.jidDecode)(jid)) === null || _a === void 0 ? void 0 : _a.user;
+                if (user) {
+                    if (jid.includes('@lid')) {
+                        lidUsersBeingFetched.add(user);
+                    }
+                    else if (jid.includes('@s.whatsapp.net')) {
+                        pnUsersBeingFetched.add(user);
+                    }
+                }
+            }
+            // Find overlaps
+            const overlapping = Array.from(pnUsersBeingFetched).filter(user => lidUsersBeingFetched.has(user));
+            if (overlapping.length > 0) {
+                logger.warn({
+                    overlapping,
+                    lidUsersBeingFetched: Array.from(lidUsersBeingFetched),
+                    pnUsersBeingFetched: Array.from(pnUsersBeingFetched)
+                }, 'Fetching both LID and PN sessions for same users');
+            }
             const result = await query({
                 tag: 'iq',
                 attrs: {
@@ -222,44 +456,135 @@ const makeMessagesSocket = (config) => {
         });
         return msgId;
     };
-    const createParticipantNodes = async (jids, message, extraAttrs) => {
+    const createParticipantNodes = async (jids, message, extraAttrs, dsmMessage) => {
+        var _a, _b;
         let patched = await patchMessageBeforeSending(message, jids);
         if (!Array.isArray(patched)) {
             patched = jids ? jids.map(jid => ({ recipientJid: jid, ...patched })) : [patched];
         }
         let shouldIncludeDeviceIdentity = false;
-        const nodes = await Promise.all(patched.map(async (patchedMessageWithJid) => {
-            const { recipientJid: jid, ...patchedMessage } = patchedMessageWithJid;
-            if (!jid) {
-                return {};
-            }
-            const bytes = (0, Utils_1.encodeWAMessage)(patchedMessage);
-            const { type, ciphertext } = await signalRepository.encryptMessage({ jid, data: bytes });
-            if (type === 'pkmsg') {
-                shouldIncludeDeviceIdentity = true;
-            }
-            const node = {
-                tag: 'to',
-                attrs: { jid },
-                content: [
-                    {
-                        tag: 'enc',
-                        attrs: {
-                            v: '2',
-                            type,
-                            ...(extraAttrs || {})
-                        },
-                        content: ciphertext
+        const meId = authState.creds.me.id;
+        const meLid = (_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.lid;
+        const meLidUser = meLid ? (_b = (0, WABinary_1.jidDecode)(meLid)) === null || _b === void 0 ? void 0 : _b.user : null;
+        const devicesByUser = new Map();
+        for (const patchedMessageWithJid of patched) {
+            const { recipientJid: wireJid, ...patchedMessage } = patchedMessageWithJid;
+            if (!wireJid)
+                continue;
+            // Extract user from JID for grouping
+            const decoded = (0, WABinary_1.jidDecode)(wireJid);
+            const user = decoded === null || decoded === void 0 ? void 0 : decoded.user;
+            if (!user)
+                continue;
+            if (!devicesByUser.has(user)) {
+                devicesByUser.set(user, []);
+            }
+            devicesByUser.get(user).push({ recipientJid: wireJid, patchedMessage });
+        }
+        // Process each user's devices sequentially, but different users in parallel
+        const userEncryptionPromises = Array.from(devicesByUser.entries()).map(([user, userDevices]) => encryptionMutex.mutex(user, async () => {
+            var _a;
+            logger.debug({ user, deviceCount: userDevices.length }, 'Acquiring encryption lock for user devices');
+            const userNodes = [];
+            // Helper to get encryption JID with LID migration
+            const getEncryptionJid = async (wireJid) => {
+                if (!wireJid.includes('@s.whatsapp.net'))
+                    return wireJid;
+                try {
+                    const lidMapping = signalRepository.getLIDMappingStore();
+                    const lidForPN = await lidMapping.getLIDForPN(wireJid);
+                    if (!(lidForPN === null || lidForPN === void 0 ? void 0 : lidForPN.includes('@lid')))
+                        return wireJid;
+                    // Preserve device ID from original wire JID
+                    const wireDecoded = (0, WABinary_1.jidDecode)(wireJid);
+                    const deviceId = (wireDecoded === null || wireDecoded === void 0 ? void 0 : wireDecoded.device) || 0;
+                    const lidDecoded = (0, WABinary_1.jidDecode)(lidForPN);
+                    const lidWithDevice = (0, WABinary_1.jidEncode)(lidDecoded === null || lidDecoded === void 0 ? void 0 : lidDecoded.user, 'lid', deviceId);
+                    // Migrate session to LID for unified encryption layer
+                    try {
+                        await signalRepository.migrateSession(wireJid, lidWithDevice);
+                        const recipientUser = (0, WABinary_1.jidNormalizedUser)(wireJid);
+                        const ownPnUser = (0, WABinary_1.jidNormalizedUser)(meId);
+                        const isOwnDevice = recipientUser === ownPnUser;
+                        logger.info({ wireJid, lidWithDevice, isOwnDevice }, 'Migrated to LID encryption');
+                        // Delete PN session after successful migration
+                        try {
+                            await signalRepository.deleteSession(wireJid);
+                            logger.debug({ deletedPNSession: wireJid }, 'Deleted PN session');
+                        }
+                        catch (deleteError) {
+                            logger.warn({ wireJid, error: deleteError }, 'Failed to delete PN session');
+                        }
+                        return lidWithDevice;
                     }
-                ]
+                    catch (migrationError) {
+                        logger.warn({ wireJid, error: migrationError }, 'Failed to migrate session');
+                        return wireJid;
+                    }
+                }
+                catch (error) {
+                    logger.debug({ wireJid, error }, 'Failed to check LID mapping');
+                    return wireJid;
+                }
             };
-            return node;
+            // Encrypt to this user's devices sequentially to prevent session corruption
+            for (const { recipientJid: wireJid, patchedMessage } of userDevices) {
+                // DSM logic: Use DSM for own other devices (following whatsmeow implementation)
+                let messageToEncrypt = patchedMessage;
+                if (dsmMessage) {
+                    const { user: targetUser } = (0, WABinary_1.jidDecode)(wireJid);
+                    const { user: ownPnUser } = (0, WABinary_1.jidDecode)(meId);
+                    const ownLidUser = meLidUser;
+                    // Check if this is our device (same user, different device)
+                    const isOwnUser = targetUser === ownPnUser || (ownLidUser && targetUser === ownLidUser);
+                    // Exclude exact sender device (whatsmeow: if jid == ownJID || jid == ownLID { continue })
+                    const isExactSenderDevice = wireJid === meId || (((_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.lid) && wireJid === authState.creds.me.lid);
+                    if (isOwnUser && !isExactSenderDevice) {
+                        messageToEncrypt = dsmMessage;
+                        logger.debug({ wireJid, targetUser }, 'Using DSM for own device');
+                    }
+                }
+                const bytes = (0, Utils_1.encodeWAMessage)(messageToEncrypt);
+                // Get encryption JID with LID migration
+                const encryptionJid = await getEncryptionJid(wireJid);
+                // ENCRYPT: Use the determined encryption identity (prefers migrated LID)
+                const { type, ciphertext } = await signalRepository.encryptMessage({
+                    jid: encryptionJid, // Unified encryption layer (LID when available)
+                    data: bytes
+                });
+                if (type === 'pkmsg') {
+                    shouldIncludeDeviceIdentity = true;
+                }
+                const node = {
+                    tag: 'to',
+                    attrs: { jid: wireJid }, // Always use original wire identity in envelope
+                    content: [
+                        {
+                            tag: 'enc',
+                            attrs: {
+                                v: '2',
+                                type,
+                                ...(extraAttrs || {})
+                            },
+                            content: ciphertext
+                        }
+                    ]
+                };
+                userNodes.push(node);
+            }
+            logger.debug({ user, nodesCreated: userNodes.length }, 'Releasing encryption lock for user devices');
+            return userNodes;
         }));
+        // Wait for all users to complete (users are processed in parallel)
+        const userNodesArrays = await Promise.all(userEncryptionPromises);
+        const nodes = userNodesArrays.flat();
         return { nodes, shouldIncludeDeviceIdentity };
     };
     const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList }) => {
-        var _a;
+        var _a, _b;
         const meId = authState.creds.me.id;
+        const meLid = (_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.lid;
+        // ADDRESSING CONSISTENCY: Keep envelope addressing as user provided, handle LID migration in encryption
         let shouldIncludeDeviceIdentity = false;
         const { user, server } = (0, WABinary_1.jidDecode)(jid);
         const statusJid = 'status@broadcast';
@@ -267,11 +592,22 @@ const makeMessagesSocket = (config) => {
         const isStatus = jid === statusJid;
         const isLid = server === 'lid';
         const isNewsletter = server === 'newsletter';
-        msgId = msgId || (0, Utils_1.generateMessageIDV2)((_a = sock.user) === null || _a === void 0 ? void 0 : _a.id);
+        // Keep user's original JID choice for envelope addressing
+        const finalJid = jid;
+        // ADDRESSING CONSISTENCY: Match own identity to conversation context
+        let ownId = meId;
+        if (isLid && meLid) {
+            ownId = meLid;
+            logger.debug({ to: jid, ownId }, 'Using LID identity for @lid conversation');
+        }
+        else {
+            logger.debug({ to: jid, ownId }, 'Using PN identity for @s.whatsapp.net conversation');
+        }
+        msgId = msgId || (0, Utils_1.generateMessageIDV2)((_b = sock.user) === null || _b === void 0 ? void 0 : _b.id);
         useUserDevicesCache = useUserDevicesCache !== false;
         useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus;
         const participants = [];
-        const destinationJid = !isStatus ? (0, WABinary_1.jidEncode)(user, isLid ? 'lid' : isGroup ? 'g.us' : 's.whatsapp.net') : statusJid;
+        const destinationJid = !isStatus ? finalJid : statusJid;
         const binaryNodeContent = [];
         const devices = [];
         const meMsg = {
@@ -290,7 +626,11 @@ const makeMessagesSocket = (config) => {
                 additionalAttributes = { ...additionalAttributes, device_fanout: 'false' };
             }
             const { user, device } = (0, WABinary_1.jidDecode)(participant.jid);
-            devices.push({ user, device });
+            devices.push({
+                user,
+                device,
+                wireJid: participant.jid // Use the participant JID as wire JID
+            });
         }
         await authState.keys.transaction(async () => {
             var _a, _b, _c, _d, _e;
@@ -350,9 +690,10 @@ const makeMessagesSocket = (config) => {
                         participantsList.push(...statusJidList);
                     }
                     if (!isStatus) {
+                        const groupAddressingMode = (groupData === null || groupData === void 0 ? void 0 : groupData.addressingMode) || (isLid ? 'lid' : 'pn');
                         additionalAttributes = {
                             ...additionalAttributes,
-                            addressing_mode: (groupData === null || groupData === void 0 ? void 0 : groupData.addressingMode) || 'pn'
+                            addressing_mode: groupAddressingMode
                         };
                     }
                     const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false);
@@ -363,19 +704,24 @@ const makeMessagesSocket = (config) => {
                     throw new boom_1.Boom('Per-jid patching is not supported in groups');
                 }
                 const bytes = (0, Utils_1.encodeWAMessage)(patched);
+                // This should match the group's addressing mode and conversation context
+                const groupAddressingMode = (groupData === null || groupData === void 0 ? void 0 : groupData.addressingMode) || (isLid ? 'lid' : 'pn');
+                const groupSenderIdentity = groupAddressingMode === 'lid' && meLid ? meLid : meId;
                 const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({
                     group: destinationJid,
                     data: bytes,
-                    meId
+                    meId: groupSenderIdentity
                 });
                 const senderKeyJids = [];
                 // ensure a connection is established with every device
-                for (const { user, device } of devices) {
-                    const jid = (0, WABinary_1.jidEncode)(user, (groupData === null || groupData === void 0 ? void 0 : groupData.addressingMode) === 'lid' ? 'lid' : 's.whatsapp.net', device);
-                    if (!senderKeyMap[jid] || !!participant) {
-                        senderKeyJids.push(jid);
+                for (const device of devices) {
+                    // This preserves the LID migration results from getUSyncDevices
+                    const deviceJid = device.wireJid;
+                    const hasKey = !!senderKeyMap[deviceJid];
+                    if (!hasKey || !!participant) {
+                        senderKeyJids.push(deviceJid);
                         // store that this person has had the sender keys sent to them
-                        senderKeyMap[jid] = true;
+                        senderKeyMap[deviceJid] = true;
                     }
                 }
                 // if there are some participants with whom the session has not been established
@@ -401,23 +747,54 @@ const makeMessagesSocket = (config) => {
                 await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } });
             }
             else {
-                const { user: meUser } = (0, WABinary_1.jidDecode)(meId);
+                const { user: ownUser } = (0, WABinary_1.jidDecode)(ownId);
                 if (!participant) {
-                    devices.push({ user });
-                    if (user !== meUser) {
-                        devices.push({ user: meUser });
+                    const targetUserServer = isLid ? 'lid' : 's.whatsapp.net';
+                    devices.push({
+                        user,
+                        device: 0,
+                        wireJid: (0, WABinary_1.jidEncode)(user, targetUserServer, 0)
+                    });
+                    // Own user matches conversation addressing mode
+                    if (user !== ownUser) {
+                        const ownUserServer = isLid ? 'lid' : 's.whatsapp.net';
+                        const ownUserForAddressing = isLid && meLid ? (0, WABinary_1.jidDecode)(meLid).user : (0, WABinary_1.jidDecode)(meId).user;
+                        devices.push({
+                            user: ownUserForAddressing,
+                            device: 0,
+                            wireJid: (0, WABinary_1.jidEncode)(ownUserForAddressing, ownUserServer, 0)
+                        });
                     }
                     if ((additionalAttributes === null || additionalAttributes === void 0 ? void 0 : additionalAttributes['category']) !== 'peer') {
-                        const additionalDevices = await getUSyncDevices([meId, jid], !!useUserDevicesCache, true);
-                        devices.push(...additionalDevices);
+                        // Clear placeholders and enumerate actual devices
+                        devices.length = 0;
+                        // Use conversation-appropriate sender identity
+                        const senderIdentity = isLid && meLid
+                            ? (0, WABinary_1.jidEncode)((_b = (0, WABinary_1.jidDecode)(meLid)) === null || _b === void 0 ? void 0 : _b.user, 'lid', undefined)
+                            : (0, WABinary_1.jidEncode)((_c = (0, WABinary_1.jidDecode)(meId)) === null || _c === void 0 ? void 0 : _c.user, 's.whatsapp.net', undefined);
+                        // Enumerate devices for sender and target with consistent addressing
+                        const sessionDevices = await getUSyncDevices([senderIdentity, jid], false, false);
+                        devices.push(...sessionDevices);
+                        logger.debug({
+                            deviceCount: devices.length,
+                            devices: devices.map(d => { var _a; return `${d.user}:${d.device}@${(_a = (0, WABinary_1.jidDecode)(d.wireJid)) === null || _a === void 0 ? void 0 : _a.server}`; })
+                        }, 'Device enumeration complete with unified addressing');
                     }
                 }
                 const allJids = [];
                 const meJids = [];
                 const otherJids = [];
-                for (const { user, device } of devices) {
-                    const isMe = user === meUser;
-                    const jid = (0, WABinary_1.jidEncode)(isMe && isLid ? ((_c = (_b = authState.creds) === null || _b === void 0 ? void 0 : _b.me) === null || _c === void 0 ? void 0 : _c.lid.split(':')[0]) || user : user, isLid ? 'lid' : 's.whatsapp.net', device);
+                const { user: mePnUser } = (0, WABinary_1.jidDecode)(meId);
+                const { user: meLidUser } = meLid ? (0, WABinary_1.jidDecode)(meLid) : { user: null };
+                for (const { user, wireJid } of devices) {
+                    const isExactSenderDevice = wireJid === meId || (meLid && wireJid === meLid);
+                    if (isExactSenderDevice) {
+                        logger.debug({ wireJid, meId, meLid }, 'Skipping exact sender device (whatsmeow pattern)');
+                        continue;
+                    }
+                    // Check if this is our device (could match either PN or LID user)
+                    const isMe = user === mePnUser || (meLidUser && user === meLidUser);
+                    const jid = wireJid;
                     if (isMe) {
                         meJids.push(jid);
                     }
@@ -426,10 +803,11 @@ const makeMessagesSocket = (config) => {
                     }
                     allJids.push(jid);
                 }
-                await assertSessions(allJids, false);
+                await assertSessions([...otherJids, ...meJids], false);
                 const [{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 }, { nodes: otherNodes, shouldIncludeDeviceIdentity: s2 }] = await Promise.all([
-                    createParticipantNodes(meJids, meMsg, extraAttrs),
-                    createParticipantNodes(otherJids, message, extraAttrs)
+                    // For own devices: use DSM if available (1:1 chats only)
+                    createParticipantNodes(meJids, meMsg || message, extraAttrs),
+                    createParticipantNodes(otherJids, message, extraAttrs, meMsg)
                 ]);
                 participants.push(...meNodes);
                 participants.push(...otherNodes);
@@ -454,6 +832,7 @@ const makeMessagesSocket = (config) => {
                 tag: 'message',
                 attrs: {
                     id: msgId,
+                    to: destinationJid,
                     type: getMessageType(message),
                     ...(additionalAttributes || {})
                 },

package/lib/Socket/socket.js

@@ -504,12 +504,29 @@ const makeSocket = (config) => {
     });
     // login complete
     ws.on('CB:success', async (node) => {
+        var _a;
         await uploadPreKeysToServerIfRequired();
         await sendPassiveIq('active');
         logger.info('opened connection to WA');
         clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
         ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
         ev.emit('connection.update', { connection: 'open' });
+        if (node.attrs.lid && ((_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id)) {
+            const myLID = node.attrs.lid;
+            process.nextTick(async () => {
+                try {
+                    const myPN = authState.creds.me.id;
+                    // Store our own LID-PN mapping
+                    await signalRepository.storeLIDPNMapping(myLID, myPN);
+                    // Create LID session for ourselves (whatsmeow pattern)
+                    await signalRepository.migrateSession(myPN, myLID);
+                    logger.info({ myPN, myLID }, 'Own LID session created successfully');
+                }
+                catch (error) {
+                    logger.error({ error, lid: myLID }, 'Failed to create own LID session');
+                }
+            });
+        }
     });
     ws.on('CB:stream:error', (node) => {
         logger.error({ node }, 'stream errored out');

package/lib/Types/Auth.d.ts

@@ -69,6 +69,7 @@ export type SignalDataTypeMap = {
     };
     'app-state-sync-key': proto.Message.IAppStateSyncKeyData;
     'app-state-sync-version': LTHashState;
+    'lid-mapping': string;
 };
 export type SignalDataSet = {
     [T in keyof SignalDataTypeMap]?: {

package/lib/Types/Signal.d.ts

@@ -1,4 +1,5 @@
 import { proto } from '../../WAProto';
+import type { LIDMappingStore } from '../Signal/lid-mapping';
 type DecryptGroupSignalOpts = {
     group: string;
     authorJid: string;
@@ -17,6 +18,11 @@ type EncryptMessageOpts = {
     jid: string;
     data: Uint8Array;
 };
+type EncryptMessageWithWireOpts = {
+    encryptionJid: string;
+    wireJid: string;
+    data: Uint8Array;
+};
 type EncryptGroupMessageOpts = {
     group: string;
     data: Uint8Array;
@@ -47,11 +53,25 @@ export type SignalRepository = {
         type: 'pkmsg' | 'msg';
         ciphertext: Uint8Array;
     }>;
+    encryptMessageWithWire(opts: EncryptMessageWithWireOpts): Promise<{
+        type: 'pkmsg' | 'msg';
+        ciphertext: Uint8Array;
+        wireJid: string;
+    }>;
     encryptGroupMessage(opts: EncryptGroupMessageOpts): Promise<{
         senderKeyDistributionMessage: Uint8Array;
         ciphertext: Uint8Array;
     }>;
     injectE2ESession(opts: E2ESessionOpts): Promise<void>;
     jidToSignalProtocolAddress(jid: string): string;
+    storeLIDPNMapping(lid: string, pn: string): Promise<void>;
+    getLIDMappingStore(): LIDMappingStore;
+    migrateSession(fromJid: string, toJid: string): Promise<void>;
+    validateSession(jid: string): Promise<{
+        exists: boolean;
+        reason?: string;
+    }>;
+    deleteSession(jid: string): Promise<void>;
+    destroy(): void;
 };
 export {};

package/lib/Utils/decode-wa-message.d.ts

@@ -18,6 +18,11 @@ export declare const NACK_REASONS: {
     UnsupportedLIDGroup: number;
     DBOperationFailed: number;
 };
+export declare const extractAddressingContext: (stanza: BinaryNode) => {
+    addressingMode: string;
+    senderAlt: string;
+    recipientAlt: string;
+};
 /**
  * Decode the received node as a message.
  * @note this will only parse the message, not decrypt it

package/lib/Utils/decode-wa-message.js

@@ -1,11 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decryptMessageNode = exports.NACK_REASONS = exports.MISSING_KEYS_ERROR_TEXT = exports.NO_MESSAGE_FOUND_ERROR_TEXT = void 0;
+exports.decryptMessageNode = exports.extractAddressingContext = exports.NACK_REASONS = exports.MISSING_KEYS_ERROR_TEXT = exports.NO_MESSAGE_FOUND_ERROR_TEXT = void 0;
 exports.decodeMessageNode = decodeMessageNode;
 const boom_1 = require("@hapi/boom");
 const WAProto_1 = require("../../WAProto");
 const WABinary_1 = require("../WABinary");
 const generics_1 = require("./generics");
+const getDecryptionJid = async (sender, repository) => {
+    if (!sender.includes('@s.whatsapp.net')) {
+        return sender;
+    }
+    const lidMapping = repository.getLIDMappingStore();
+    const normalizedSender = (0, WABinary_1.jidNormalizedUser)(sender);
+    const lidForPN = await lidMapping.getLIDForPN(normalizedSender);
+    if (lidForPN === null || lidForPN === void 0 ? void 0 : lidForPN.includes('@lid')) {
+        const senderDecoded = (0, WABinary_1.jidDecode)(sender);
+        const deviceId = (senderDecoded === null || senderDecoded === void 0 ? void 0 : senderDecoded.device) || 0;
+        return (0, WABinary_1.jidEncode)((0, WABinary_1.jidDecode)(lidForPN).user, 'lid', deviceId);
+    }
+    return sender;
+};
+const storeMappingFromEnvelope = async (stanza, sender, decryptionJid, repository, logger) => {
+    const { senderAlt } = (0, exports.extractAddressingContext)(stanza);
+    if (senderAlt && (0, WABinary_1.isLidUser)(senderAlt) && (0, WABinary_1.isJidUser)(sender) && decryptionJid === sender) {
+        try {
+            await repository.storeLIDPNMapping(senderAlt, sender);
+            logger.debug({ sender, senderAlt }, 'Stored LID mapping from envelope');
+        }
+        catch (error) {
+            logger.warn({ sender, senderAlt, error }, 'Failed to store LID mapping');
+        }
+    }
+};
 exports.NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node';
 exports.MISSING_KEYS_ERROR_TEXT = 'Key used already or never filled';
 exports.NACK_REASONS = {
@@ -23,6 +49,27 @@ exports.NACK_REASONS = {
     UnsupportedLIDGroup: 551,
     DBOperationFailed: 552
 };
+const extractAddressingContext = (stanza) => {
+    const addressingMode = stanza.attrs.addressing_mode || 'pn';
+    let senderAlt;
+    let recipientAlt;
+    if (addressingMode === 'lid') {
+        // Message is LID-addressed: sender is LID, extract corresponding PN
+        senderAlt = stanza.attrs.participant_pn || stanza.attrs.sender_pn;
+        recipientAlt = stanza.attrs.recipient_pn;
+    }
+    else {
+        // Message is PN-addressed: sender is PN, extract corresponding LID
+        senderAlt = stanza.attrs.participant_lid || stanza.attrs.sender_lid;
+        recipientAlt = stanza.attrs.recipient_lid;
+    }
+    return {
+        addressingMode,
+        senderAlt,
+        recipientAlt
+    };
+};
+exports.extractAddressingContext = extractAddressingContext;
 /**
  * Decode the received node as a message.
  * @note this will only parse the message, not decrypt it
@@ -150,11 +197,13 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                             case 'pkmsg':
                             case 'msg':
                                 const user = (0, WABinary_1.isJidUser)(sender) ? sender : author;
+                                const decryptionJid = await getDecryptionJid(user, repository);
                                 msgBuffer = await repository.decryptMessage({
-                                    jid: user,
+                                    jid: decryptionJid,
                                     type: e2eType,
                                     ciphertext: content
                                 });
+                                await storeMappingFromEnvelope(stanza, user, decryptionJid, repository, logger);
                                 break;
                             case 'plaintext':
                                 msgBuffer = content;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@periskope/baileys",
-  "version": "6.7.18-17-3",
+  "version": "6.7.18-17-4",
   "description": "WhatsApp API",
   "keywords": [
     "periskope",
@@ -66,6 +66,7 @@
     "jimp": "^1.6.0",
     "json": "^11.0.0",
     "link-preview-js": "^3.0.0",
+    "lru-cache": "^10.4.3",
     "open": "^8.4.2",
     "prettier": "^3.5.3",
     "protobufjs-cli": "^1.1.3",