davexbaileys 2.5.23 → 2.5.24

package/lib/Signal/libsignal.js

@@ -35,18 +35,30 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLibSignalRepository = makeLibSignalRepository;
 const libsignal = __importStar(require("libsignal"));
+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");
-function makeLibSignalRepository(auth) {
-    const storage = signalStorage(auth);
+const lid_mapping_1 = require("./lid-mapping");
+
+function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+    const lidMapping = new lid_mapping_1.LIDMappingStore(auth.keys, logger, pnToLIDFunc);
+    const storage = signalStorage(auth, lidMapping);
+    const parsedKeys = auth.keys;
+    const migratedSessionCache = new lru_cache_1.LRUCache({
+        ttl: 3 * 24 * 60 * 60 * 1000,
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    });
     return {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
-            return cipher.decrypt(msg);
+            return parsedKeys.transaction(async () => {
+                return cipher.decrypt(msg);
+            }, group);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
             const builder = new Group_1.GroupSessionBuilder(storage);
@@ -56,60 +68,91 @@ function makeLibSignalRepository(auth) {
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
             const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
             const senderNameStr = senderName.toString();
-            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
-            if (!senderKey) {
-                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
-            }
-            await builder.process(senderName, senderMsg);
+            return parsedKeys.transaction(async () => {
+                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+                if (!senderKey) {
+                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+                }
+                await builder.process(senderName, senderMsg);
+            }, 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}`);
+            async function doDecrypt() {
+                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 result;
+            return parsedKeys.transaction(async () => {
+                return await 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 parsedKeys.transaction(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 parsedKeys.transaction(async () => {
+                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+                if (!senderKey) {
+                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord());
+                }
+                const senderKeyDistributionMessage = await builder.create(senderName);
+                const session = new Group_1.GroupCipher(storage, senderName);
+                const ciphertext = await session.encrypt(data);
+                return {
+                    ciphertext,
+                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+                };
+            }, group);
         },
         async injectE2ESession({ jid, session }) {
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            await cipher.initOutgoing(session);
+            return parsedKeys.transaction(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' };
+            }
         }
     };
 }
+
 const jidToSignalProtocolAddress = (jid) => {
     const { user, device } = (0, WABinary_1.jidDecode)(jid);
     return new libsignal.ProtocolAddress(user, device || 0);
@@ -117,7 +160,8 @@ const jidToSignalProtocolAddress = (jid) => {
 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]);

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIDMappingStore = void 0;
+const lru_cache_1 = require("lru-cache");
+const WABinary_1 = require("../WABinary");
+
+class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new lru_cache_1.LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1000,
+            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 (!((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) 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 (!(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 {
+                    this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
+                    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}: lidUser = "${lidUser}"`);
+                return null;
+            }
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+            const domainType = decoded.domainType;
+            const deviceSpecificLid = `${lidUser}${pnDevice ? `:${pnDevice}` : ''}@${domainType === 128 ? '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 = (0, WABinary_1.jidDecode)(pair.pn);
+                    const pnUser = pnDecoded?.user;
+                    if (!pnUser) continue;
+                    const lidUser = (0, WABinary_1.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}`);
+                        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 (!(0, WABinary_1.isLidUser)(lid)) return null;
+        const decoded = (0, WABinary_1.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 === 129 ? 'hosted' : 's.whatsapp.net'}`;
+        this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+        return pnJid;
+    }
+}
+exports.LIDMappingStore = LIDMappingStore;

package/lib/Socket/socket.js

@@ -45,7 +45,101 @@ const makeSocket = (config) => {
     const { creds } = authState;
     // add transaction capability
     const keys = (0, Utils_1.addTransactionCapability)(authState.keys, logger, transactionOpts);
-    const signalRepository = makeSignalRepository({ creds, keys });
+    // Validate current key-bundle on server; on failure, trigger pre-key upload and rethrow
+    const digestKeyBundle = async () => {
+        const res = await query({
+            tag: 'iq',
+            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: 'get', xmlns: 'encrypt' },
+            content: [{ tag: 'digest', attrs: {} }]
+        });
+        const digestNode = (0, WABinary_1.getBinaryNodeChild)(res, 'digest');
+        if (!digestNode) {
+            await uploadPreKeys();
+            throw new Error('encrypt/get digest returned no digest node');
+        }
+    };
+    // Rotate our signed pre-key on server
+    const rotateSignedPreKey = async () => {
+        const newId = (creds.signedPreKey.keyId || 0) + 1;
+        const skey = await (0, Utils_1.signedKeyPair)(creds.signedIdentityKey, newId);
+        await query({
+            tag: 'iq',
+            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: 'set', xmlns: 'encrypt' },
+            content: [
+                {
+                    tag: 'rotate',
+                    attrs: {},
+                    content: [(0, Utils_1.xmppSignedPreKey)(skey)]
+                }
+            ]
+        });
+        ev.emit('creds.update', { signedPreKey: skey });
+    };
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (!usyncQuery.protocols || 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 => {
+            return {
+                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);
+    };
+    const pnFromLIDUSync = async (jids) => {
+        try {
+            const WAUSync_1 = require('../WAUSync');
+            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;
+                }
+                else {
+                    usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid));
+                }
+            }
+            if (usyncQuery.users.length === 0) return [];
+            const results = await executeUSyncQuery(usyncQuery);
+            if (results) {
+                return results.list.filter(a => !!a.lid).map(({ lid, id }) => ({ pn: id, lid }));
+            }
+        }
+        catch (e) {
+            logger?.debug({ err: e?.message }, 'pnFromLIDUSync failed');
+        }
+        return [];
+    };
+    const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync);
     let lastDateRecv;
     let epoch = 1;
     let keepAliveReq;
@@ -600,6 +694,9 @@ const makeSocket = (config) => {
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,
         requestPairingCode,
+        digestKeyBundle,
+        rotateSignedPreKey,
+        executeUSyncQuery,
         /** Waits for the connection to WA to reach a state */
         waitForConnectionUpdate: (0, Utils_1.bindWaitForConnectionUpdate)(ev),
         sendWAMBuffer

package/lib/Types/Bussines.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Utils/generics.js

@@ -9,7 +9,7 @@ exports.isWABusinessPlatform = exports.getCodeFromWSError = exports.getCallStatu
           isLatest: true
       };
   };
-exports.fetchLatestWaWebVersion = exports.fetchLatestBaileysVersion = exports.bindWaitForConnectionUpdate = exports.generateMessageID = exports.generateMessageIDV2 = exports.delayCancellable = exports.delay = exports.debouncedTimeout = exports.unixTimestampSeconds = exports.toNumber = exports.encodeBigEndian = exports.generateRegistrationId = exports.encodeWAMessage = exports.unpadRandomMax16 = exports.writeRandomPadMax16 = exports.getKeyAuthor = exports.BufferJSON = exports.getPlatformId = exports.Browsers = void 0;
+exports.fetchLatestWaWebVersion = exports.fetchLatestBaileysVersion = exports.bindWaitForConnectionUpdate = exports.generateMessageID = exports.generateMessageIDV2 = exports.delayCancellable = exports.delay = exports.debouncedTimeout = exports.unixTimestampSeconds = exports.toNumber = exports.encodeBigEndian = exports.generateRegistrationId = exports.generateParticipantHashV2 = exports.encodeWAMessage = exports.unpadRandomMax16 = exports.writeRandomPadMax16 = exports.getKeyAuthor = exports.BufferJSON = exports.getPlatformId = exports.Browsers = void 0;
 exports.promiseTimeout = promiseTimeout;
 exports.bindWaitForEvent = bindWaitForEvent;
 exports.trimUndefined = trimUndefined;
@@ -55,10 +55,22 @@ exports.BufferJSON = {
     },
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     reviver: (_, value) => {
+        if (typeof value === 'object' && value !== null && value.type === 'Buffer' && typeof value.data === 'string') {
+            return Buffer.from(value.data, 'base64');
+        }
         if (typeof value === 'object' && !!value && (value.buffer === true || value.type === 'Buffer')) {
             const val = value.data || value.value;
             return typeof val === 'string' ? Buffer.from(val, 'base64') : Buffer.from(val || []);
         }
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            const keys = Object.keys(value);
+            if (keys.length > 0 && keys.every(k => !isNaN(parseInt(k, 10)))) {
+                const values = Object.values(value);
+                if (values.every(v => typeof v === 'number')) {
+                    return Buffer.from(values);
+                }
+            }
+        }
         return value;
     }
 };
@@ -85,6 +97,12 @@ const unpadRandomMax16 = (e) => {
     return new Uint8Array(t.buffer, t.byteOffset, t.length - r);
 };
 exports.unpadRandomMax16 = unpadRandomMax16;
+const generateParticipantHashV2 = (participants) => {
+    const sorted = [...participants].sort();
+    const hash = (0, crypto_1.createHash)('sha256').update(Buffer.from(sorted.join(''))).digest('base64');
+    return '2:' + hash.slice(0, 6);
+};
+exports.generateParticipantHashV2 = generateParticipantHashV2;
 const encodeWAMessage = (message) => (0, exports.writeRandomPadMax16)(WAProto_1.proto.Message.encode(message).finish());
 exports.encodeWAMessage = encodeWAMessage;
 const generateRegistrationId = () => {

package/lib/WABinary/jid-utils.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jidNormalizedUser = exports.isJidBot = exports.isJidNewsletter = exports.isJidStatusBroadcast = exports.isJidGroup = exports.isJidBroadcast = exports.isLidUser = exports.isJidUser = exports.isJidMetaIa = exports.areJidsSameUser = exports.jidDecode = exports.jidEncode = exports.META_AI_JID = exports.STORIES_JID = exports.PSA_WID = exports.SERVER_JID = exports.OFFICIAL_BIZ_JID = exports.S_WHATSAPP_NET = void 0;
+exports.jidNormalizedUser = exports.isJidBot = exports.isJidNewsletter = exports.isJidStatusBroadcast = exports.isJidGroup = exports.isJidBroadcast = exports.isHostedLidUser = exports.isHostedPnUser = exports.isPnUser = exports.isLidUser = exports.isJidUser = exports.isJidMetaIa = exports.areJidsSameUser = exports.jidDecode = exports.jidEncode = exports.WAJIDDomains = exports.META_AI_JID = exports.STORIES_JID = exports.PSA_WID = exports.SERVER_JID = exports.OFFICIAL_BIZ_JID = exports.S_WHATSAPP_NET = void 0;
+var WAJIDDomains;
+(function (WAJIDDomains) {
+    WAJIDDomains[WAJIDDomains["WHATSAPP"] = 0] = "WHATSAPP";
+    WAJIDDomains[WAJIDDomains["LID"] = 1] = "LID";
+    WAJIDDomains[WAJIDDomains["HOSTED"] = 128] = "HOSTED";
+    WAJIDDomains[WAJIDDomains["HOSTED_LID"] = 129] = "HOSTED_LID";
+})(WAJIDDomains = exports.WAJIDDomains || (exports.WAJIDDomains = {}));
 exports.S_WHATSAPP_NET = '@s.whatsapp.net';
 exports.OFFICIAL_BIZ_JID = '16505361212@c.us';
 exports.SERVER_JID = 'server@c.us';
@@ -20,10 +27,24 @@ const jidDecode = (jid) => {
     const userCombined = jid.slice(0, sepIdx);
     const [userAgent, device] = userCombined.split(':');
     const user = userAgent.split('_')[0];
+    let domainType;
+    switch (server) {
+        case 'lid':
+            domainType = WAJIDDomains.LID;
+            break;
+        case 'hosted':
+            domainType = WAJIDDomains.HOSTED;
+            break;
+        case 'hosted.lid':
+            domainType = WAJIDDomains.HOSTED_LID;
+            break;
+        default:
+            domainType = WAJIDDomains.WHATSAPP;
+    }
     return {
         server: server,
         user,
-        domainType: server === 'lid' ? 1 : 0,
+        domainType,
         device: device ? +device : undefined
     };
 };
@@ -37,7 +58,16 @@ exports.isJidMetaIa = isJidMetaIa;
 /** is the jid a user */
 const isJidUser = (jid) => jid === null || jid === void 0 ? void 0 : jid.endsWith('@s.whatsapp.net');
 exports.isJidUser = isJidUser;
-/** is the jid a group */
+/** is the jid a PN (phone number) user */
+const isPnUser = (jid) => jid === null || jid === void 0 ? void 0 : jid.endsWith('@s.whatsapp.net');
+exports.isPnUser = isPnUser;
+/** is the jid a hosted PN user */
+const isHostedPnUser = (jid) => jid === null || jid === void 0 ? void 0 : jid.endsWith('@hosted');
+exports.isHostedPnUser = isHostedPnUser;
+/** is the jid a hosted LID user */
+const isHostedLidUser = (jid) => jid === null || jid === void 0 ? void 0 : jid.endsWith('@hosted.lid');
+exports.isHostedLidUser = isHostedLidUser;
+/** is the jid a LID user */
 const isLidUser = (jid) => jid === null || jid === void 0 ? void 0 : jid.endsWith('@lid');
 exports.isLidUser = isLidUser;
 /** is the jid a broadcast */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "davexbaileys",
-    "version": "2.5.23",
+    "version": "2.5.24",
     "description": "A lightweight, full-featured WhatsApp Web API library for Node.js — maintained by Dave Tech",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",