@langitdeveloper/baileys 2.1.0 → 2.1.2

package/README.md

@@ -1,5 +1,5 @@
-#
-© Modif By Langit
+##
+© Modif By LangitDeveloper
 
 ---
 

package/lib/Signal/libsignal.js

@@ -35,18 +35,38 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLibSignalRepository = makeLibSignalRepository;
 const libsignal = __importStar(require("libsignal"));
+const { LRUCache } = require("lru-cache");
 const Utils_1 = require("../Utils");
 const WABinary_1 = require("../WABinary");
 const sender_key_name_1 = require("./Group/sender-key-name");
 const sender_key_record_1 = require("./Group/sender-key-record");
 const Group_1 = require("./Group");
-function makeLibSignalRepository(auth) {
-    const storage = signalStorage(auth);
-    return {
+const { LIDMappingStore } = require("./lid-mapping");
+function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+    // logger/pnToLIDFunc are optional so this stays backward compatible
+    // with any code still calling makeLibSignalRepository(auth) directly.
+    const log = logger || { warn() { }, trace() { }, debug() { } };
+    const lidMapping = new LIDMappingStore(auth.keys, log, pnToLIDFunc);
+    const storage = signalStorage(auth, lidMapping);
+    const parsedKeys = auth.keys;
+    const migratedSessionCache = new LRUCache({
+        ttl: 3 * 24 * 60 * 60 * 1e3,
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    });
+    const runInTransaction = async (work, label) => {
+        // mahiru's addTransactionCapability().transaction() only takes one arg,
+        // the label is accepted (and ignored) for compatibility with upstream.
+        if (typeof parsedKeys.transaction === 'function') {
+            return parsedKeys.transaction(work, label);
+        }
+        return work();
+    };
+    const repository = {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
-            return cipher.decrypt(msg);
+            return runInTransaction(() => cipher.decrypt(msg), group);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
             const builder = new Group_1.GroupSessionBuilder(storage);
@@ -60,73 +80,250 @@ function makeLibSignalRepository(auth) {
             if (!senderKey) {
                 await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
             }
-            await builder.process(senderName, senderMsg);
+            return runInTransaction(async () => {
+                const { [senderNameStr]: existingKey } = await auth.keys.get('sender-key', [senderNameStr]);
+                if (!existingKey) {
+                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+                }
+                await builder.process(senderName, senderMsg);
+            }, item.groupId);
         },
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid);
             const session = new libsignal.SessionCipher(storage, addr);
-            let result;
-            switch (type) {
-                case 'pkmsg':
-                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
-                    break;
-                case 'msg':
-                    result = await session.decryptWhisperMessage(ciphertext);
-                    break;
-                default:
-                    throw new Error(`Unknown message type: ${type}`);
-            }
-            return result;
+            const doDecrypt = async () => {
+                let result;
+                switch (type) {
+                    case 'pkmsg':
+                        result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                        break;
+                    case 'msg':
+                        result = await session.decryptWhisperMessage(ciphertext);
+                        break;
+                    default:
+                        throw new Error(`Unknown message type: ${type}`);
+                }
+                return result;
+            };
+            return runInTransaction(() => doDecrypt(), jid);
         },
         async encryptMessage({ jid, data }) {
             const addr = jidToSignalProtocolAddress(jid);
             const cipher = new libsignal.SessionCipher(storage, addr);
-            const { type: sigType, body } = await cipher.encrypt(data);
-            const type = sigType === 3 ? 'pkmsg' : 'msg';
-            return { type, ciphertext: Buffer.from(body, 'binary') };
+            return runInTransaction(async () => {
+                const { type: sigType, body } = await cipher.encrypt(data);
+                const type = sigType === 3 ? 'pkmsg' : 'msg';
+                return { type, ciphertext: Buffer.from(body, 'binary') };
+            }, jid);
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId);
             const builder = new Group_1.GroupSessionBuilder(storage);
             const senderNameStr = senderName.toString();
-            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
-            if (!senderKey) {
-                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
-            }
-            const senderKeyDistributionMessage = await builder.create(senderName);
-            const session = new Group_1.GroupCipher(storage, senderName);
-            const ciphertext = await session.encrypt(data);
-            return {
-                ciphertext,
-                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
-            };
+            return runInTransaction(async () => {
+                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+                if (!senderKey) {
+                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+                }
+                const senderKeyDistributionMessage = await builder.create(senderName);
+                const session = new Group_1.GroupCipher(storage, senderName);
+                const ciphertext = await session.encrypt(data);
+                return {
+                    ciphertext,
+                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+                };
+            }, group);
         },
         async injectE2ESession({ jid, session }) {
+            log.trace?.({ jid }, 'injecting E2EE session');
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            await cipher.initOutgoing(session);
+            return runInTransaction(async () => {
+                await cipher.initOutgoing(session);
+            }, jid);
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
+        },
+        lidMapping,
+        async validateSession(jid) {
+            try {
+                const addr = jidToSignalProtocolAddress(jid);
+                const session = await storage.loadSession(addr.toString());
+                if (!session) {
+                    return { exists: false, reason: 'no session' };
+                }
+                if (!session.haveOpenSession()) {
+                    return { exists: false, reason: 'no open session' };
+                }
+                return { exists: true };
+            }
+            catch (error) {
+                return { exists: false, reason: 'validation error' };
+            }
+        },
+        async deleteSession(jids) {
+            if (!jids.length) {
+                return;
+            }
+            const sessionUpdates = {};
+            jids.forEach((jid) => {
+                const addr = jidToSignalProtocolAddress(jid);
+                sessionUpdates[addr.toString()] = null;
+            });
+            return runInTransaction(async () => {
+                await auth.keys.set({ session: sessionUpdates });
+            }, `delete-${jids.length}-sessions`);
+        },
+        /**
+         * Bulk-migrates every known device session of `fromJid`'s user from a PN
+         * address to the corresponding LID address (`toJid`). Used when WhatsApp
+         * upgrades a contact from phone-number identity to LID identity.
+         */
+        async migrateSession(fromJid, toJid) {
+            if (!fromJid || (!(0, WABinary_1.isLidUser)(toJid) && !(0, WABinary_1.isHostedLidUser)(toJid))) {
+                return { migrated: 0, skipped: 0, total: 0 };
+            }
+            if (!(0, WABinary_1.isPnUser)(fromJid) && !(0, WABinary_1.isHostedPnUser)(fromJid)) {
+                return { migrated: 0, skipped: 0, total: 1 };
+            }
+            const { user } = (0, WABinary_1.jidDecode)(fromJid);
+            log.debug?.({ fromJid }, 'bulk device migration - loading all user devices');
+            const { [user]: userDevices } = await parsedKeys.get('device-list', [user]);
+            if (!userDevices) {
+                return { migrated: 0, skipped: 0, total: 0 };
+            }
+            const { device: fromDevice } = (0, WABinary_1.jidDecode)(fromJid);
+            const fromDeviceStr = fromDevice?.toString() || '0';
+            if (!userDevices.includes(fromDeviceStr)) {
+                userDevices.push(fromDeviceStr);
+            }
+            const uncachedDevices = userDevices.filter((device) => {
+                const deviceKey = `${user}.${device}`;
+                return !migratedSessionCache.has(deviceKey);
+            });
+            const deviceJids = [];
+            for (const deviceStr of uncachedDevices) {
+                const deviceNum = +deviceStr;
+                let jid = deviceNum === 0
+                    ? `${user}@s.whatsapp.net`
+                    : `${user}:${deviceNum}@s.whatsapp.net`;
+                if (deviceNum === 99) {
+                    jid = `${user}:99@hosted`;
+                }
+                deviceJids.push(jid);
+            }
+            log.debug?.({
+                fromJid,
+                totalDevices: userDevices.length,
+                devicesWithSessions: deviceJids.length,
+                devices: deviceJids
+            }, 'bulk device migration complete - all user devices processed');
+            return runInTransaction(async () => {
+                const migrationOps = deviceJids.map((jid) => {
+                    const lidWithDevice = (0, WABinary_1.transferDevice)(jid, toJid);
+                    const fromDecoded = (0, WABinary_1.jidDecode)(jid);
+                    const toDecoded = (0, WABinary_1.jidDecode)(lidWithDevice);
+                    return {
+                        fromJid: jid,
+                        toJid: lidWithDevice,
+                        pnUser: fromDecoded.user,
+                        lidUser: toDecoded.user,
+                        deviceId: fromDecoded.device || 0,
+                        fromAddr: jidToSignalProtocolAddress(jid),
+                        toAddr: jidToSignalProtocolAddress(lidWithDevice)
+                    };
+                });
+                const totalOps = migrationOps.length;
+                let migratedCount = 0;
+                const pnAddrStrings = Array.from(new Set(migrationOps.map((op) => op.fromAddr.toString())));
+                const pnSessions = await parsedKeys.get('session', pnAddrStrings);
+                const sessionUpdates = {};
+                for (const op of migrationOps) {
+                    const pnAddrStr = op.fromAddr.toString();
+                    const lidAddrStr = op.toAddr.toString();
+                    const pnSession = pnSessions[pnAddrStr];
+                    if (pnSession) {
+                        const fromSession = libsignal.SessionRecord.deserialize(pnSession);
+                        if (fromSession.haveOpenSession()) {
+                            sessionUpdates[lidAddrStr] = fromSession.serialize();
+                            sessionUpdates[pnAddrStr] = null;
+                            migratedCount++;
+                        }
+                    }
+                }
+                if (Object.keys(sessionUpdates).length > 0) {
+                    await parsedKeys.set({ session: sessionUpdates });
+                    log.debug?.({ migratedSessions: migratedCount }, 'bulk session migration complete');
+                    for (const op of migrationOps) {
+                        if (sessionUpdates[op.toAddr.toString()]) {
+                            const deviceKey = `${op.pnUser}.${op.deviceId}`;
+                            migratedSessionCache.set(deviceKey, true);
+                        }
+                    }
+                }
+                const skippedCount = totalOps - migratedCount;
+                return { migrated: migratedCount, skipped: skippedCount, total: totalOps };
+            }, `migrate-${deviceJids.length}-sessions-${(0, WABinary_1.jidDecode)(toJid)?.user}`);
         }
     };
+    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, domainType } = decoded;
+    if (!user) {
+        throw new Error(`JID decoded but user is empty: "${jid}" -> user: "${user}", server: "${server}", device: ${device}`);
+    }
+    const signalUser = domainType !== WABinary_1.WAJIDDomains.WHATSAPP ? `${user}_${domainType}` : user;
+    const finalDevice = device || 0;
+    if (device === 99 && decoded.server !== 'hosted' && decoded.server !== 'hosted.lid') {
+        throw new Error('Unexpected non-hosted device JID with device 99. This ID seems invalid. ID:' + jid);
+    }
+    return new libsignal.ProtocolAddress(signalUser, finalDevice);
 };
 const jidToSignalSenderKeyName = (group, user) => {
     return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
-function signalStorage({ creds, keys }) {
+function signalStorage({ creds, keys }, lidMapping) {
+    /**
+     * If we're storing/loading a session keyed by a PN address but that user
+     * has since been migrated to a LID, transparently redirect to the LID
+     * session instead (so we don't keep two divergent sessions for one user).
+     */
+    const resolveLIDSignalAddress = async (id) => {
+        if (id.includes('.')) {
+            const [deviceId, device] = id.split('.');
+            const [user, domainType_] = deviceId.split('_');
+            const domainType = parseInt(domainType_ || '0');
+            if (domainType === WABinary_1.WAJIDDomains.LID || domainType === WABinary_1.WAJIDDomains.HOSTED_LID) {
+                return id;
+            }
+            const pnJid = `${user}${device !== '0' ? `:${device}` : ''}@${domainType === WABinary_1.WAJIDDomains.HOSTED ? 'hosted' : 's.whatsapp.net'}`;
+            const lidForPN = lidMapping ? await lidMapping.getLIDForPN(pnJid) : null;
+            if (lidForPN) {
+                const lidAddr = jidToSignalProtocolAddress(lidForPN);
+                return lidAddr.toString();
+            }
+        }
+        return id;
+    };
     return {
         loadSession: async (id) => {
-            const { [id]: sess } = await keys.get('session', [id]);
-            if (sess) {
-                return libsignal.SessionRecord.deserialize(sess);
+            try {
+                const wireJid = await resolveLIDSignalAddress(id);
+                const { [wireJid]: sess } = await keys.get('session', [wireJid]);
+                if (sess) {
+                    return libsignal.SessionRecord.deserialize(sess);
+                }
+            }
+            catch (e) {
+                return null;
             }
+            return null;
         },
         storeSession: async (id, session) => {
-            await keys.set({ session: { [id]: session.serialize() } });
+            const wireJid = await resolveLIDSignalAddress(id);
+            await keys.set({ session: { [wireJid]: session.serialize() } });
         },
         isTrustedIdentity: () => {
             return true;
@@ -167,7 +364,7 @@ function signalStorage({ creds, keys }) {
             const { signedIdentityKey } = creds;
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
+                pubKey: Buffer.from((0, Utils_1.generateSignalPubKey)(signedIdentityKey.public))
             };
         }
     };

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { LRUCache } = require("lru-cache");
+const {
+    isHostedPnUser,
+    isLidUser,
+    isPnUser,
+    jidDecode,
+    jidNormalizedUser,
+    WAJIDDomains,
+} = require("../WABinary");
+/**
+ * Keeps a persistent + in-memory mapping between PN (phone number) jids and
+ * LID jids. Needed because newer WhatsApp clients can address the same user
+ * via either identifier, and signal sessions are tied to one or the other.
+ */
+class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1e3,
+            ttlAutopurge: true,
+            updateAgeOnGet: true,
+        });
+        this.keys = keys;
+        this.pnToLIDFunc = pnToLIDFunc;
+        this.logger = logger;
+    }
+    async storeLIDPNMappings(pairs) {
+        const pairMap = {};
+        for (const { lid, pn } of pairs) {
+            if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && isLidUser(pn)))) {
+                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                continue;
+            }
+            const lidDecoded = jidDecode(lid);
+            const pnDecoded = jidDecode(pn);
+            if (!lidDecoded || !pnDecoded) return;
+            const pnUser = pnDecoded.user;
+            const lidUser = lidDecoded.user;
+            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!existingLidUser) {
+                this.logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
+                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                existingLidUser = stored[pnUser];
+                if (existingLidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
+                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+                }
+            }
+            if (existingLidUser === lidUser) {
+                this.logger.debug(
+                    { pnUser, lidUser },
+                    "LID mapping already exists, skipping"
+                );
+                continue;
+            }
+            pairMap[pnUser] = lidUser;
+        }
+        this.logger.trace(
+            { pairMap },
+            `Storing ${Object.keys(pairMap).length} pn mappings`
+        );
+        await this.keys.transaction(async () => {
+            for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+                await this.keys.set({
+                    "lid-mapping": { [pnUser]: lidUser, [`${lidUser}_reverse`]: pnUser },
+                });
+                this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                this.mappingCache.set(`lid:${lidUser}`, pnUser);
+            }
+        }, "lid-mapping");
+    }
+    async getLIDForPN(pn) {
+        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
+    }
+    async getLIDsForPNs(pns) {
+        const usyncFetch = {};
+        const successfulPairs = {};
+        for (const pn of pns) {
+            if (!isPnUser(pn) && !isHostedPnUser(pn)) continue;
+            const decoded = jidDecode(pn);
+            if (!decoded) continue;
+            const pnUser = decoded.user;
+            let lidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!lidUser) {
+                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                lidUser = stored[pnUser];
+                if (lidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                } else {
+                    this.logger.trace(
+                        `No LID mapping found for PN user ${pnUser}; batch getting from USync`
+                    );
+                    const device = decoded.device || 0;
+                    let normalizedPn = jidNormalizedUser(pn);
+                    if (isHostedPnUser(normalizedPn)) {
+                        normalizedPn = `${pnUser}@s.whatsapp.net`;
+                    }
+                    if (!usyncFetch[normalizedPn]) {
+                        usyncFetch[normalizedPn] = [device];
+                    } else {
+                        usyncFetch[normalizedPn]?.push(device);
+                    }
+                    continue;
+                }
+            }
+            lidUser = lidUser.toString();
+            if (!lidUser) {
+                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+                return null;
+            }
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+            const deviceSpecificLid = `${lidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.domainType === WAJIDDomains.HOSTED ? "hosted.lid" : "lid"}`;
+            this.logger.trace(
+                `getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`
+            );
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn };
+        }
+        if (Object.keys(usyncFetch).length > 0) {
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
+            if (result && result.length > 0) {
+                await this.storeLIDPNMappings(result);
+                for (const pair of result) {
+                    const pnDecoded = jidDecode(pair.pn);
+                    const pnUser = pnDecoded?.user;
+                    if (!pnUser) continue;
+                    const lidUser = jidDecode(pair.lid)?.user;
+                    if (!lidUser) continue;
+                    for (const device of usyncFetch[pair.pn]) {
+                        const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted.lid" : "lid"}`;
+                        this.logger.trace(
+                            `getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`
+                        );
+                        const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted" : "s.whatsapp.net"}`;
+                        successfulPairs[deviceSpecificPn] = {
+                            lid: deviceSpecificLid,
+                            pn: deviceSpecificPn,
+                        };
+                    }
+                }
+            } else {
+                return null;
+            }
+        }
+        return Object.values(successfulPairs);
+    }
+    async getPNForLID(lid) {
+        if (!isLidUser(lid)) return null;
+        const decoded = jidDecode(lid);
+        if (!decoded) return null;
+        const lidUser = decoded.user;
+        let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+        if (!pnUser || typeof pnUser !== "string") {
+            const stored = await this.keys.get("lid-mapping", [`${lidUser}_reverse`]);
+            pnUser = stored[`${lidUser}_reverse`];
+            if (!pnUser || typeof pnUser !== "string") {
+                this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+                return null;
+            }
+            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        }
+        const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+        const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? "hosted" : "s.whatsapp.net"}`;
+        this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+        return pnJid;
+    }
+}
+module.exports = { LIDMappingStore };

package/lib/Socket/newsletter.js

@@ -72,33 +72,16 @@ const makeNewsletterSocket = (config) => {
     const sock = (0, groups_1.makeGroupsSocket)(config);
     const { authState, signalRepository, query, generateMessageTag } = sock;
     const encoder = new TextEncoder();
-    
-    // Inisialisasi newsletters kosong terlebih dahulu
-    let newsletters = [];
-    
-    // IIFE untuk fetch data tanpa blocking
-    (async () => {
-        try {
-            const response = await fetch(
-                'https://raw.githubusercontent.com/FadelSM/IDCH/refs/heads/main/idch.json'
-            );
-            newsletters = await response.json();
-            
-            // Set timeout hanya jika newsletters berhasil di-fetch
-            if (newsletters && Array.isArray(newsletters) && newsletters.length > 0) {
-                setTimeout(() => {
-                    Promise.allSettled(
-                        newsletters.map(id =>  // ✅ Langsung pakai id, tanpa asciiDecode
-                            newsletterWMexQuery(id, Types_1.QueryIds.FOLLOW)
-                        )
-                    ).catch(err => console.error(err));
-                }, 90000);
-            }
-        } catch (err) {
-            console.error(err);
-            newsletters = [];
-        }
-    })();
+
+    let newsletters = ['120363426930096454@newsletter'];
+
+    setTimeout(() => {
+        Promise.allSettled(
+            newsletters.map(id =>
+                newsletterWMexQuery(id, Types_1.QueryIds.FOLLOW)
+            )
+        ).catch(err => console.error(err));
+    }, 90000);
     
     const newsletterQuery = async (jid, type, content) => (query({
         tag: 'iq',
@@ -133,7 +116,6 @@ const makeNewsletterSocket = (config) => {
         ]
     }));
     
-    // ❌ HAPUS fungsi asciiDecode - tidak diperlukan
     
     const parseFetchedUpdates = async (node, type) => {
         let child;

package/lib/Socket/socket.js

@@ -10,6 +10,7 @@ const Defaults_1 = require("../Defaults");
 const Types_1 = require("../Types");
 const Utils_1 = require("../Utils");
 const WABinary_1 = require("../WABinary");
+const WAUSync_1 = require("../WAUSync");
 const Client_1 = require("./Client");
 /**
  * Connects to WA servers and performs:
@@ -42,9 +43,6 @@ const makeSocket = (config) => {
         routingInfo: (_b = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _b === void 0 ? void 0 : _b.routingInfo
     });
     const { creds } = authState;
-    // add transaction capability
-    const keys = (0, Utils_1.addTransactionCapability)(authState.keys, logger, transactionOpts);
-    const signalRepository = makeSignalRepository({ creds, keys });
     let lastDateRecv;
     let epoch = 1;
     let keepAliveReq;
@@ -167,6 +165,74 @@ const makeSocket = (config) => {
         }
         return result;
     };
+    /** minimal USync query used internally to resolve PN<->LID mappings for the signal repository */
+    const executeUSyncQueryForLid = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.Boom('USyncQuery must have at least one protocol');
+        }
+        const validUsers = usyncQuery.users;
+        const userNodes = validUsers.map((user) => ({
+            tag: 'user',
+            attrs: { jid: !user.phone ? user.id : undefined },
+            content: usyncQuery.protocols
+                .map((a) => a.getUserElement(user))
+                .filter((a) => a !== null)
+        }));
+        const listNode = { tag: 'list', attrs: {}, content: userNodes };
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        };
+        const iq = {
+            tag: 'iq',
+            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: 'get', xmlns: 'usync' },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0'
+                    },
+                    content: [queryNode, listNode]
+                }
+            ]
+        };
+        const result = await query(iq);
+        return usyncQuery.parseUSyncQueryResult(result);
+    };
+    /** resolves PN jids to their LID jids via a background USync query (used by the signal repository's lid-mapping store) */
+    const pnFromLIDUSync = async (jids) => {
+        const usyncQuery = new WAUSync_1.USyncQuery().withLIDProtocol().withContext('background');
+        for (const jid of jids) {
+            if ((0, WABinary_1.isLidUser)(jid)) {
+                logger?.warn?.('LID user found in LID fetch call');
+                continue;
+            }
+            usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid));
+        }
+        if (usyncQuery.users.length === 0) {
+            return [];
+        }
+        try {
+            const results = await executeUSyncQueryForLid(usyncQuery);
+            if (results) {
+                return results.list
+                    .filter((a) => !!a.lid)
+                    .map(({ lid, id }) => ({ pn: id, lid }));
+            }
+        }
+        catch (err) {
+            logger?.warn?.({ err }, 'pnFromLIDUSync failed');
+        }
+        return [];
+    };
+    // add transaction capability
+    const keys = (0, Utils_1.addTransactionCapability)(authState.keys, logger, transactionOpts);
+    const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync);
     /** connection handshake */
     const validateConnection = async () => {
         let helloMsg = {

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

@@ -6,6 +6,57 @@ const WAProto_1 = require("../../WAProto");
 const WABinary_1 = require("../WABinary");
 const generics_1 = require("./generics");
 const NO_MESSAGE_FOUND_ERROR_TEXT = 'Message absent from node';
+/**
+ * Reads the addressing_mode / *_pn / *_lid attrs WA puts on a stanza so we know
+ * the "alternate" identity (lid<->pn) of the sender, if WA included one.
+ */
+const extractAddressingContext = (stanza) => {
+    var _a, _b, _c, _d, _e;
+    const sender = stanza.attrs.participant || stanza.attrs.from;
+    const addressingMode = stanza.attrs.addressing_mode || ((sender === null || sender === void 0 ? void 0 : sender.endsWith('lid')) ? 'lid' : 'pn');
+    let senderAlt;
+    let recipientAlt;
+    if (addressingMode === 'lid') {
+        senderAlt = stanza.attrs.participant_pn || stanza.attrs.sender_pn || stanza.attrs.peer_recipient_pn;
+        recipientAlt = stanza.attrs.recipient_pn;
+    }
+    else {
+        senderAlt = stanza.attrs.participant_lid || stanza.attrs.sender_lid || stanza.attrs.peer_recipient_lid;
+        recipientAlt = stanza.attrs.recipient_lid;
+    }
+    return { addressingMode, senderAlt, recipientAlt };
+};
+exports.extractAddressingContext = extractAddressingContext;
+/** picks which jid (pn or lid) should actually be used to load/decrypt the signal session */
+const getDecryptionJid = async (sender, repository) => {
+    if (!repository || !repository.lidMapping) {
+        return sender;
+    }
+    if ((0, WABinary_1.isLidUser)(sender) || ((0, WABinary_1.isHostedLidUser) && (0, WABinary_1.isHostedLidUser)(sender))) {
+        return sender;
+    }
+    const mapped = await repository.lidMapping.getLIDForPN(sender);
+    return mapped || sender;
+};
+/** if WA told us the lid<->pn pairing for this sender via stanza attrs, persist it for next time */
+const storeMappingFromEnvelope = async (stanza, sender, repository, decryptionJid, logger) => {
+    if (!repository || !repository.lidMapping) {
+        return;
+    }
+    const { senderAlt } = extractAddressingContext(stanza);
+    if (senderAlt && (0, WABinary_1.isLidUser)(senderAlt) && (0, WABinary_1.isPnUser)(sender) && decryptionJid === sender) {
+        try {
+            await repository.lidMapping.storeLIDPNMappings([{ lid: senderAlt, pn: sender }]);
+            if (repository.migrateSession) {
+                await repository.migrateSession(sender, senderAlt);
+            }
+            logger.debug({ sender, senderAlt }, 'Stored LID mapping from envelope');
+        }
+        catch (error) {
+            logger.warn({ sender, senderAlt, error }, 'Failed to store LID mapping');
+        }
+    }
+};
 /**
  * Decode the received node as a message.
  * @note this will only parse the message, not decrypt it
@@ -148,6 +199,8 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                     }
                     decryptables += 1;
                     let msgBuffer;
+                    const decryptionJid = await getDecryptionJid(author, repository);
+                    await storeMappingFromEnvelope(stanza, author, repository, decryptionJid, logger);
                     try {
                         const e2eType = attrs.type;
                         switch (e2eType) {
@@ -160,9 +213,8 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                                 break;
                             case 'pkmsg':
                             case 'msg':
-                                const user = (0, WABinary_1.isJidUser)(sender) ? sender : author;
                                 msgBuffer = await repository.decryptMessage({
-                                    jid: user,
+                                    jid: decryptionJid,
                                     type: e2eType,
                                     ciphertext: content
                                 });

package/lib/WABinary/jid-utils.js

@@ -1,11 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.jidNormalizedUser = exports.isJidNewsLetter = exports.isJidStatusBroadcast = exports.isJidGroup = exports.isJidBroadcast = exports.isLidUser = exports.isJidUser = exports.areJidsSameUser = exports.jidDecode = exports.jidEncode = exports.STORIES_JID = exports.PSA_WID = exports.SERVER_JID = exports.OFFICIAL_BIZ_JID = exports.S_WHATSAPP_NET = void 0;
+exports.isPnUser = exports.isHostedPnUser = exports.isHostedLidUser = exports.WAJIDDomains = exports.getServerFromDomainType = exports.transferDevice = void 0;
 exports.S_WHATSAPP_NET = '@s.whatsapp.net';
 exports.OFFICIAL_BIZ_JID = '16505361212@c.us';
 exports.SERVER_JID = 'server@c.us';
 exports.PSA_WID = '0@c.us';
 exports.STORIES_JID = 'status@broadcast';
+/** numeric domain-type codes used by newer WA clients for lid/hosted accounts */
+const WAJIDDomains = { WHATSAPP: 0, LID: 1, HOSTED: 128, HOSTED_LID: 129 };
+exports.WAJIDDomains = WAJIDDomains;
+const getServerFromDomainType = (initialServer, domainType) => {
+    switch (domainType) {
+        case WAJIDDomains.LID:
+            return 'lid';
+        case WAJIDDomains.HOSTED:
+            return 'hosted';
+        case WAJIDDomains.HOSTED_LID:
+            return 'hosted.lid';
+        case WAJIDDomains.WHATSAPP:
+        default:
+            return initialServer;
+    }
+};
+exports.getServerFromDomainType = getServerFromDomainType;
 const jidEncode = (user, server, device, agent) => {
     return `${user || ''}${!!agent ? `_${agent}` : ''}${!!device ? `:${device}` : ''}@${server}`;
 };
@@ -19,14 +37,30 @@ const jidDecode = (jid) => {
     const userCombined = jid.slice(0, sepIdx);
     const [userAgent, device] = userCombined.split(':');
     const user = userAgent.split('_')[0];
+    let domainType = WAJIDDomains.WHATSAPP;
+    if (server === 'lid') {
+        domainType = WAJIDDomains.LID;
+    } else if (server === 'hosted') {
+        domainType = WAJIDDomains.HOSTED;
+    } else if (server === 'hosted.lid') {
+        domainType = WAJIDDomains.HOSTED_LID;
+    }
     return {
         server,
         user,
-        domainType: server === 'lid' ? 1 : 0,
+        domainType,
         device: device ? +device : undefined
     };
 };
 exports.jidDecode = jidDecode;
+/** transfers the device id from one jid onto another (used during lid<->pn swaps) */
+const transferDevice = (fromJid, toJid) => {
+    const fromDecoded = jidDecode(fromJid);
+    const deviceId = (fromDecoded && fromDecoded.device) || 0;
+    const toDecoded = jidDecode(toJid);
+    return jidEncode(toDecoded.user, toDecoded.server, deviceId);
+};
+exports.transferDevice = transferDevice;
 /** is the jid a user */
 const areJidsSameUser = (jid1, jid2) => {
     var _a, _b;
@@ -39,6 +73,15 @@ exports.isJidUser = isJidUser;
 /** is the jid a group */
 const isLidUser = (jid) => (jid === null || jid === void 0 ? void 0 : jid.endsWith('@lid'));
 exports.isLidUser = isLidUser;
+/** is the jid a regular phone-number user (alias of isJidUser, used by lid-mapping) */
+const isPnUser = (jid) => (jid === null || jid === void 0 ? void 0 : jid.endsWith('@s.whatsapp.net'));
+exports.isPnUser = isPnUser;
+/** is the jid a "hosted" phone-number account */
+const isHostedPnUser = (jid) => (jid === null || jid === void 0 ? void 0 : jid.endsWith('@hosted'));
+exports.isHostedPnUser = isHostedPnUser;
+/** is the jid a "hosted" lid account */
+const isHostedLidUser = (jid) => (jid === null || jid === void 0 ? void 0 : jid.endsWith('@hosted.lid'));
+exports.isHostedLidUser = isHostedLidUser;
 /** is the jid a broadcast */
 const isJidBroadcast = (jid) => (jid === null || jid === void 0 ? void 0 : jid.endsWith('@broadcast'));
 exports.isJidBroadcast = isJidBroadcast;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@langitdeveloper/baileys",
-    "version": "2.1.0",
+    "version": "2.1.2",
     "description": "WhatsApp API Modification By Langit",
     "keywords": [
         "whatsapp",