keithbaileys 1.1.0 → 1.1.1

package/lib/Signal/libsignal.js

@@ -40,8 +40,43 @@ const WABinary_1 = require("../WABinary");
 const sender_key_name_1 = require("./Group/sender-key-name");
 const sender_key_record_1 = require("./Group/sender-key-record");
 const Group_1 = require("./Group");
-function makeLibSignalRepository(auth) {
-    const storage = signalStorage(auth);
+const lid_mapping_1 = require("./lid-mapping");
+/**
+ * Fix: previously every call built the signal protocol address straight from
+ * whatever JID form (PN or LID) happened to be on the message/stanza. WhatsApp
+ * sends the same contact as a PN JID sometimes and a LID JID other times, so
+ * the two forms silently ended up as two *different* Signal sessions for the
+ * same device -- once they drifted out of sync, decryption kept failing and
+ * WhatsApp shows the message as permanently "Waiting for this message".
+ *
+ * `resolveConsistentAddress` makes sure that whenever we already know a
+ * PN<->LID mapping for a contact, we always operate on ONE canonical address
+ * (preferring LID, matching current WhatsApp behavior) instead of flip-flopping.
+ */
+function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+    const log = logger || console;
+    const lidMapping = new lid_mapping_1.LIDMappingStore(auth.keys, log, pnToLIDFunc);
+    const storage = signalStorage(auth, lidMapping, log);
+    const resolveConsistentAddress = async (jid) => {
+        try {
+            if ((0, WABinary_1.isLidUser)(jid)) {
+                return jidToSignalProtocolAddress(jid);
+            }
+            if ((0, WABinary_1.isPnUser)(jid) || (0, WABinary_1.isHostedPnUser)(jid)) {
+                const lid = await lidMapping.getLIDForPN(jid);
+                if (lid) {
+                    // if we already have session state under the old PN address,
+                    // carry it over to the LID address so we don't lose the session
+                    await migrateSessionIfNeeded(auth.keys, jid, lid, log);
+                    return jidToSignalProtocolAddress(lid);
+                }
+            }
+        }
+        catch (err) {
+            log.warn?.({ err, jid }, 'LID resolution failed, falling back to original jid');
+        }
+        return jidToSignalProtocolAddress(jid);
+    };
     return {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
@@ -63,7 +98,7 @@ function makeLibSignalRepository(auth) {
             await builder.process(senderName, senderMsg);
         },
         async decryptMessage({ jid, type, ciphertext }) {
-            const addr = jidToSignalProtocolAddress(jid);
+            const addr = await resolveConsistentAddress(jid);
             const session = new libsignal.SessionCipher(storage, addr);
             let result;
             switch (type) {
@@ -79,7 +114,7 @@ function makeLibSignalRepository(auth) {
             return result;
         },
         async encryptMessage({ jid, data }) {
-            const addr = jidToSignalProtocolAddress(jid);
+            const addr = await resolveConsistentAddress(jid);
             const cipher = new libsignal.SessionCipher(storage, addr);
             const { type: sigType, body } = await cipher.encrypt(data);
             const type = sigType === 3 ? 'pkmsg' : 'msg';
@@ -102,14 +137,41 @@ function makeLibSignalRepository(auth) {
             };
         },
         async injectE2ESession({ jid, session }) {
-            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            const addr = await resolveConsistentAddress(jid);
+            const cipher = new libsignal.SessionBuilder(storage, addr);
             await cipher.initOutgoing(session);
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
-        }
+        },
+        lidMapping
     };
 }
+/**
+ * If a session already exists under the PN address but not yet under the
+ * newly-resolved LID address, copy it over so we don't force a brand new
+ * (and momentarily out-of-sync) session just because we learned the LID
+ * mapping after the fact.
+ */
+async function migrateSessionIfNeeded(keys, pnJid, lidJid, logger) {
+    try {
+        const pnAddr = jidToSignalProtocolAddress(pnJid).toString();
+        const lidAddr = jidToSignalProtocolAddress(lidJid).toString();
+        if (pnAddr === lidAddr)
+            return;
+        const { [lidAddr]: existingLidSession } = await keys.get('session', [lidAddr]);
+        if (existingLidSession)
+            return; // already migrated / already has its own session
+        const { [pnAddr]: pnSession } = await keys.get('session', [pnAddr]);
+        if (pnSession) {
+            await keys.set({ session: { [lidAddr]: pnSession } });
+            logger.debug?.({ pnAddr, lidAddr }, 'migrated signal session from PN address to LID address');
+        }
+    }
+    catch (err) {
+        logger.warn?.({ err }, 'session migration to LID address failed, continuing without it');
+    }
+}
 const jidToSignalProtocolAddress = (jid) => {
     const { user, device } = (0, WABinary_1.jidDecode)(jid);
     return new libsignal.ProtocolAddress(user, device || 0);

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIDMappingStore = void 0;
+const WABinary_1 = require("../WABinary");
+const MAPPING_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+/**
+ * A minimal TTL cache used instead of the `lru-cache` package so this file
+ * doesn't require adding a new dependency to keithbaileys.
+ */
+class SimpleTTLCache {
+    constructor(ttlMs) {
+        this.ttlMs = ttlMs;
+        this.map = new Map();
+    }
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() - entry.t > this.ttlMs) {
+            this.map.delete(key);
+            return undefined;
+        }
+        entry.t = Date.now(); // updateAgeOnGet
+        return entry.v;
+    }
+    set(key, value) {
+        this.map.set(key, { v: value, t: Date.now() });
+    }
+    delete(key) {
+        this.map.delete(key);
+    }
+}
+class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new SimpleTTLCache(MAPPING_TTL_MS);
+        this.inflightLIDLookups = new Map();
+        this.inflightPNLookups = new Map();
+        this.keys = keys;
+        this.pnToLIDFunc = pnToLIDFunc;
+        this.logger = logger || console;
+    }
+    async storeLIDPNMappings(pairs) {
+        if (!pairs || pairs.length === 0)
+            return;
+        const validatedPairs = [];
+        for (const { lid, pn } of pairs) {
+            if (!((0, WABinary_1.isLidUser)(lid) && (0, WABinary_1.isPnUser)(pn)) &&
+                !((0, WABinary_1.isPnUser)(lid) && (0, WABinary_1.isLidUser)(pn))) {
+                this.logger.warn?.(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                continue;
+            }
+            const lidDecoded = (0, WABinary_1.jidDecode)(lid);
+            const pnDecoded = (0, WABinary_1.jidDecode)(pn);
+            if (!lidDecoded || !pnDecoded)
+                continue;
+            validatedPairs.push({ pnUser: pnDecoded.user, lidUser: lidDecoded.user });
+        }
+        if (validatedPairs.length === 0)
+            return;
+        const cacheMissSet = new Set();
+        const existingMappings = new Map();
+        for (const { pnUser } of validatedPairs) {
+            const cached = this.mappingCache.get(`pn:${pnUser}`);
+            if (cached) {
+                existingMappings.set(pnUser, cached);
+            }
+            else {
+                cacheMissSet.add(pnUser);
+            }
+        }
+        if (cacheMissSet.size > 0) {
+            const cacheMisses = [...cacheMissSet];
+            const stored = await this.keys.get('lid-mapping', cacheMisses);
+            for (const pnUser of cacheMisses) {
+                const existingLidUser = stored[pnUser];
+                if (existingLidUser) {
+                    existingMappings.set(pnUser, existingLidUser);
+                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
+                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+                }
+            }
+        }
+        const pairMap = {};
+        for (const { pnUser, lidUser } of validatedPairs) {
+            const existingLidUser = existingMappings.get(pnUser);
+            if (existingLidUser === lidUser) {
+                continue;
+            }
+            pairMap[pnUser] = lidUser;
+        }
+        if (Object.keys(pairMap).length === 0)
+            return;
+        const batchData = {};
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            batchData[pnUser] = lidUser;
+            batchData[`${lidUser}_reverse`] = pnUser;
+            const oldLidUser = existingMappings.get(pnUser);
+            if (oldLidUser && oldLidUser !== lidUser) {
+                batchData[`${oldLidUser}_reverse`] = null;
+            }
+        }
+        if (this.keys.transaction) {
+            await this.keys.transaction(async () => {
+                await this.keys.set({ 'lid-mapping': batchData });
+            }, 'lid-mapping');
+        }
+        else {
+            await this.keys.set({ 'lid-mapping': batchData });
+        }
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            this.mappingCache.set(`pn:${pnUser}`, lidUser);
+            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+            const oldLidUser = existingMappings.get(pnUser);
+            if (oldLidUser && oldLidUser !== lidUser) {
+                this.mappingCache.delete(`lid:${oldLidUser}`);
+            }
+        }
+    }
+    async getLIDForPN(pn) {
+        var _a, _b;
+        return ((_b = (_a = (await this.getLIDsForPNs([pn]))) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.lid) || null;
+    }
+    async getLIDsForPNs(pns) {
+        if (!pns || pns.length === 0)
+            return null;
+        const sortedPns = [...new Set(pns)].sort();
+        const cacheKey = sortedPns.join(',');
+        const inflight = this.inflightLIDLookups.get(cacheKey);
+        if (inflight) {
+            return inflight;
+        }
+        const promise = this._getLIDsForPNsImpl(pns);
+        this.inflightLIDLookups.set(cacheKey, promise);
+        try {
+            return await promise;
+        }
+        finally {
+            this.inflightLIDLookups.delete(cacheKey);
+        }
+    }
+    async _getLIDsForPNsImpl(pns) {
+        const usyncFetch = {};
+        const successfulPairs = {};
+        for (const pn of pns) {
+            if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn))
+                continue;
+            const decoded = (0, WABinary_1.jidDecode)(pn);
+            if (!decoded)
+                continue;
+            const pnUser = decoded.user;
+            let lidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!lidUser) {
+                const stored = await this.keys.get('lid-mapping', [pnUser]);
+                lidUser = stored[pnUser];
+                if (lidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                }
+                else {
+                    const device = decoded.device || 0;
+                    let normalizedPn = (0, WABinary_1.jidNormalizedUser)(pn);
+                    if ((0, WABinary_1.isHostedPnUser)(normalizedPn)) {
+                        normalizedPn = `${pnUser}@s.whatsapp.net`;
+                    }
+                    if (!usyncFetch[normalizedPn]) {
+                        usyncFetch[normalizedPn] = [device];
+                    }
+                    else {
+                        usyncFetch[normalizedPn].push(device);
+                    }
+                    continue;
+                }
+            }
+            lidUser = lidUser.toString();
+            if (!lidUser) {
+                this.logger.warn?.(`Invalid or empty LID user for PN ${pn}`);
+                return null;
+            }
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+            const deviceSpecificLid = `${lidUser}${pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`;
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn };
+        }
+        if (Object.keys(usyncFetch).length > 0) {
+            const result = this.pnToLIDFunc ? await this.pnToLIDFunc(Object.keys(usyncFetch)) : null;
+            if (result && result.length > 0) {
+                await this.storeLIDPNMappings(result);
+                for (const pair of result) {
+                    const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn);
+                    const pnUser = pnDecoded === null || pnDecoded === void 0 ? void 0 : pnDecoded.user;
+                    if (!pnUser)
+                        continue;
+                    const lidDecoded = (0, WABinary_1.jidDecode)(pair.lid);
+                    const lidUser = lidDecoded === null || lidDecoded === void 0 ? void 0 : lidDecoded.user;
+                    if (!lidUser)
+                        continue;
+                    for (const device of (usyncFetch[pair.pn] || [])) {
+                        const deviceSpecificLid = `${lidUser}${device ? `:${device}` : ``}@${device === 99 ? 'hosted.lid' : 'lid'}`;
+                        const deviceSpecificPn = `${pnUser}${device ? `:${device}` : ``}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`;
+                        successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
+                    }
+                }
+            }
+            else {
+                return null;
+            }
+        }
+        return Object.values(successfulPairs);
+    }
+    /** Get PNs for LIDs - user level, with device numbers reattached */
+    async getPNsForLIDs(lids) {
+        const result = [];
+        const missingLids = [];
+        for (const lid of lids) {
+            if (!(0, WABinary_1.isLidUser)(lid)) {
+                continue;
+            }
+            const decoded = (0, WABinary_1.jidDecode)(lid);
+            if (!decoded) {
+                continue;
+            }
+            const lidUser = decoded.user;
+            const pnUser = this.mappingCache.get(`lid:${lidUser}`);
+            if (!pnUser || typeof pnUser !== 'string') {
+                missingLids.push(lidUser);
+            }
+            else {
+                const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+                const domain = decoded.domainType === WABinary_1.WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net';
+                const pnJid = `${pnUser}${lidDevice ? `:${lidDevice}` : ``}@${domain}`;
+                result.push({ lid, pn: pnJid });
+            }
+        }
+        if (missingLids.length > 0) {
+            const lookupKeys = missingLids.map(l => `${l}_reverse`);
+            const stored = await this.keys.get('lid-mapping', lookupKeys);
+            for (const lidUser of missingLids) {
+                const pnUser = stored[`${lidUser}_reverse`];
+                if (pnUser && typeof pnUser === 'string') {
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                    for (const lid of lids) {
+                        const decoded = (0, WABinary_1.jidDecode)(lid);
+                        if (decoded && decoded.user === lidUser) {
+                            const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+                            const domain = decoded.domainType === WABinary_1.WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net';
+                            const pnJid = `${pnUser}${lidDevice ? `:${lidDevice}` : ``}@${domain}`;
+                            result.push({ lid, pn: pnJid });
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    async getPNForLID(lid) {
+        var _a, _b;
+        const results = await this.getPNsForLIDs([lid]);
+        return ((_b = (_a = results) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.pn) || null;
+    }
+}
+exports.LIDMappingStore = LIDMappingStore;

package/lib/Socket/socket.js

@@ -12,6 +12,8 @@ const Utils_1 = require("../Utils");
 const WABinary_1 = require("../WABinary");
 const Client_1 = require("./Client");
 const mex_1 = require("./mex");
+const USyncQuery_1 = require("../WAUSync/USyncQuery");
+const USyncUser_1 = require("../WAUSync/USyncUser");
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
@@ -46,7 +48,37 @@ const makeSocket = (config) => {
     const { creds } = authState;
     // add transaction capability
     const keys = (0, Utils_1.addTransactionCapability)(authState.keys, logger, transactionOpts);
-    const signalRepository = makeSignalRepository({ creds, keys });
+    /**
+     * Resolves PN -> LID mappings via a USync query. This is a closure so it
+     * can safely reference `query`/`generateMessageTag` even though they are
+     * declared further down in this function: by the time this is actually
+     * *called* (during message send/receive), those are already initialized.
+     * Passed into the LID mapping store so signal sessions stop flip-flopping
+     * between PN and LID addresses for the same contact.
+     */
+    const pnFromLIDUSync = async (jids) => {
+        const usyncQuery = new USyncQuery_1.USyncQuery().withLIDProtocol().withContext('background');
+        for (const jid of jids) {
+            if ((0, WABinary_1.isLidUser)(jid)) {
+                continue;
+            }
+            usyncQuery.withUser(new USyncUser_1.USyncUser().withId(jid));
+        }
+        if (usyncQuery.users.length === 0) {
+            return [];
+        }
+        try {
+            const result = await executeUSyncQuery(usyncQuery);
+            if (result) {
+                return result.list.filter(a => !!a.lid).map(({ lid, id }) => ({ pn: id, lid }));
+            }
+        }
+        catch (err) {
+            logger?.debug?.({ err }, 'pnFromLIDUSync query failed');
+        }
+        return [];
+    };
+    const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync);
     let lastDateRecv;
     let epoch = 1;
     let keepAliveReq;
@@ -146,6 +178,53 @@ const makeSocket = (config) => {
         }
         return result;
     };
+    /** run a USync query (used internally for PN<->LID resolution, also exposed on the socket) */
+    const executeUSyncQuery = 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);
+    };
     /** connection handshake */
     const validateConnection = async () => {
         let helloMsg = {
@@ -615,6 +694,7 @@ const makeSocket = (config) => {
         },
         generateMessageTag,
         query,
+        executeUSyncQuery,
         waitForMessage,
         waitForSocketOpen,
         sendRawMessage,

package/lib/WABinary/jid-utils.js

@@ -64,3 +64,16 @@ const jidNormalizedUser = (jid) => {
     return (0, exports.jidEncode)(user, server === 'c.us' ? 's.whatsapp.net' : server);
 };
 exports.jidNormalizedUser = jidNormalizedUser;
+/** is the jid a normal phone-number user (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 user (business hosted accounts) */
+const isHostedPnUser = (jid) => jid === null || jid === void 0 ? void 0 : jid.endsWith('@hosted');
+exports.isHostedPnUser = isHostedPnUser;
+/** domain type constants used by the LID mapping store */
+exports.WAJIDDomains = {
+    PN: 0,
+    LID: 1,
+    HOSTED: 2,
+    HOSTED_LID: 3
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "keithbaileys",
-    "version": "1.1.0",
+    "version": "1.1.1",
     "description": "A lightweight, full-featured WhatsApp Web API library for Node.js",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
@@ -22,7 +22,7 @@
         "async-mutex": "^0.5.0",
         "axios": "^1.6.0",
         "fflate": "^0.8.2",
-        "libsignal": "latest",
+        "libsignal": "^6.0.0",
         "lodash": "^4.17.21",
         "music-metadata": "^7.12.3",
         "node-fetch": "^2.6.1",