@crysnovax/baileys 2.6.7 → 2.6.9

package/lib/Signal/lid-mapping.js

@@ -1,5 +1,5 @@
 import { LRUCache } from 'lru-cache';
-import { isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from '../WABinary/index.js';
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from '../WABinary/index.js';
 export class LIDMappingStore {
     constructor(keys, logger, pnToLIDFunc) {
         this.mappingCache = new LRUCache({
@@ -226,13 +226,17 @@ export class LIDMappingStore {
                 return false;
             }
             const lidDevice = decoded.device !== undefined ? decoded.device : 0;
-            const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`;
+            const deviceSuffix = lidDevice ? `:${lidDevice}` : '';
+            const pnServer = decoded.domainType === WAJIDDomains.HOSTED_LID || decoded.server === 'hosted.lid'
+                ? 'hosted'
+                : 's.whatsapp.net';
+            const pnJid = `${pnUser}${deviceSuffix}@${pnServer}`;
             this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
             successfulPairs[lid] = { lid, pn: pnJid };
             return true;
         };
         for (const lid of lids) {
-            if (!isLidUser(lid))
+            if (!isLidUser(lid) && !isHostedLidUser(lid))
                 continue;
             const decoded = jidDecode(lid);
             if (!decoded)
@@ -273,4 +277,4 @@ export class LIDMappingStore {
     close() {
         this.mappingCache.clear();
     }
-}
+}

package/lib/Socket/business.js

@@ -1,3 +1,4 @@
+import { unlink } from 'node:fs/promises';
 import { getRawMediaUploadData } from '../Utils/index.js';
 import { parseCatalogNode, parseCollectionsNode, parseOrderDetailsNode, parseProductNode, toProductNode, uploadingNecessaryImagesOfProduct } from '../Utils/business.js';
 import { jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
@@ -6,28 +7,42 @@ import { makeMessagesRecvSocket } from './messages-recv.js';
 export const makeBusinessSocket = (config) => {
     const sock = makeMessagesRecvSocket(config);
     const { authState, query, waUploadToServer } = sock;
-    const updateBussinesProfile = async (args) => {
+    const updateBusinessProfile = async (args = {}) => {
         const node = [];
         const simpleFields = ['address', 'email', 'description'];
         node.push(...simpleFields
-            .filter(key => args[key] !== undefined && args[key] !== null)
-            .map(key => ({
-            tag: key,
-            attrs: {},
-            content: args[key]
-        })));
+            .filter(key => args[key] !== undefined)
+            .map(key => {
+            if (args[key] !== null && typeof args[key] !== 'string') {
+                throw new TypeError(`${key} must be a string or null`);
+            }
+            return {
+                tag: key,
+                attrs: {},
+                content: args[key] ?? ''
+            };
+        }));
         if (args.websites !== undefined) {
-            node.push(...args.websites.map(website => ({
+            if (!Array.isArray(args.websites) || args.websites.some(website => typeof website !== 'string')) {
+                throw new TypeError('websites must be an array of strings');
+            }
+            node.push(...(args.websites.length ? args.websites : ['']).map(website => ({
                 tag: 'website',
                 attrs: {},
                 content: website
             })));
         }
         if (args.hours !== undefined) {
+            if (!args.hours || typeof args.hours.timezone !== 'string' || !Array.isArray(args.hours.days)) {
+                throw new TypeError('hours must contain a timezone string and days array');
+            }
             node.push({
                 tag: 'business_hours',
                 attrs: { timezone: args.hours.timezone },
                 content: args.hours.days.map(dayConfig => {
+                    if (!dayConfig || typeof dayConfig.day !== 'string' || typeof dayConfig.mode !== 'string') {
+                        throw new TypeError('each business-hours day requires string day and mode values');
+                    }
                     const base = {
                         tag: 'business_hours_config',
                         attrs: {
@@ -36,12 +51,16 @@ export const makeBusinessSocket = (config) => {
                         }
                     };
                     if (dayConfig.mode === 'specific_hours') {
+                        const { openTimeInMinutes, closeTimeInMinutes } = dayConfig;
+                        if (!Number.isInteger(openTimeInMinutes) || !Number.isInteger(closeTimeInMinutes)) {
+                            throw new TypeError('specific_hours requires integer openTimeInMinutes and closeTimeInMinutes');
+                        }
                         return {
                             ...base,
                             attrs: {
                                 ...base.attrs,
-                                open_time: dayConfig.openTimeInMinutes,
-                                close_time: dayConfig.closeTimeInMinutes
+                                open_time: String(openTimeInMinutes),
+                                close_time: String(closeTimeInMinutes)
                             }
                         };
                     }
@@ -70,36 +89,45 @@ export const makeBusinessSocket = (config) => {
         return result;
     };
     const updateCoverPhoto = async (photo) => {
-        const { fileSha256, filePath } = await getRawMediaUploadData(photo, 'biz-cover-photo');
-        const fileSha256B64 = fileSha256.toString('base64');
-        const { meta_hmac, fbid, ts } = await waUploadToServer(filePath, {
-            fileEncSha256B64: fileSha256B64,
-            mediaType: 'biz-cover-photo'
-        });
-        await query({
-            tag: 'iq',
-            attrs: {
-                to: S_WHATSAPP_NET,
-                type: 'set',
-                xmlns: 'w:biz'
-            },
-            content: [
-                {
-                    tag: 'business_profile',
-                    attrs: {
-                        v: '3',
-                        mutation_type: 'delta'
-                    },
-                    content: [
-                        {
-                            tag: 'cover_photo',
-                            attrs: { id: String(fbid), op: 'update', token: meta_hmac, ts: String(ts) }
-                        }
-                    ]
-                }
-            ]
-        });
-        return fbid;
+        const { fileSha256, filePath } = await getRawMediaUploadData(photo, 'biz-cover-photo', config.logger);
+        try {
+            const fileSha256B64 = fileSha256.toString('base64');
+            const upload = await waUploadToServer(filePath, {
+                fileEncSha256B64: fileSha256B64,
+                mediaType: 'biz-cover-photo'
+            });
+            const { meta_hmac, fbid, ts } = upload || {};
+            if (fbid === undefined || fbid === null || !meta_hmac || ts === undefined || ts === null) {
+                throw new Error('Business cover photo upload returned incomplete metadata');
+            }
+            await query({
+                tag: 'iq',
+                attrs: {
+                    to: S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'w:biz'
+                },
+                content: [
+                    {
+                        tag: 'business_profile',
+                        attrs: {
+                            v: '3',
+                            mutation_type: 'delta'
+                        },
+                        content: [
+                            {
+                                tag: 'cover_photo',
+                                attrs: { id: String(fbid), op: 'update', token: String(meta_hmac), ts: String(ts) }
+                            }
+                        ]
+                    }
+                ]
+            });
+            return fbid;
+        }
+        finally {
+            await unlink(filePath).catch(() => undefined);
+        }
     };
     const removeCoverPhoto = async (id) => {
         return await query({
@@ -371,8 +399,8 @@ export const makeBusinessSocket = (config) => {
         productCreate,
         productDelete,
         productUpdate,
-        updateBussinesProfile,
-        updateBusinessProfile: updateBussinesProfile,
+        updateBussinesProfile: updateBusinessProfile,
+        updateBusinessProfile,
         updateCoverPhoto,
         removeCoverPhoto
     };

package/lib/Socket/chats.js

@@ -197,11 +197,13 @@ export const makeChatsSocket = (config) => {
         };
         if (isPnUser(normalizedJid) || isHostedPnUser(normalizedJid)) {
             userId.phoneNumber = normalizedJid;
-            userId.lid = jidNormalizedUser((await signalRepository.lidMapping.getLIDsForPNs([normalizedJid]))?.[0]?.lid);
+            const resolvedLid = (await signalRepository.lidMapping.getLIDsForPNs([normalizedJid]))?.[0]?.lid;
+            userId.lid = resolvedLid ? jidNormalizedUser(resolvedLid) : undefined;
         }
         else if (isLidUser(normalizedJid) || isHostedLidUser(normalizedJid)) {
             userId.lid = normalizedJid;
-            userId.phoneNumber = jidNormalizedUser((await signalRepository.lidMapping.getPNsForLIDs([normalizedJid]))?.[0]?.pn);
+            const resolvedPhoneNumber = (await signalRepository.lidMapping.getPNsForLIDs([normalizedJid]))?.[0]?.pn;
+            userId.phoneNumber = resolvedPhoneNumber ? jidNormalizedUser(resolvedPhoneNumber) : undefined;
         }
         else {
             throw new Boom('Invalid id input to find user ids', { statusCode: 400 });
@@ -275,6 +277,9 @@ export const makeChatsSocket = (config) => {
     };
     /** update the profile status for yourself */
     const updateProfileStatus = async (status) => {
+        if (typeof status !== 'string') {
+            throw new TypeError('Profile status must be a string');
+        }
         await query({
             tag: 'iq',
             attrs: {
@@ -292,6 +297,9 @@ export const makeChatsSocket = (config) => {
         });
     };
     const updateProfileName = async (name) => {
+        if (typeof name !== 'string') {
+            throw new TypeError('Profile name must be a string');
+        }
         await chatModify({ pushNameSetting: name }, '');
     };
     const fetchBlocklist = async () => {

package/lib/Socket/groups.js

@@ -2,11 +2,55 @@ import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { WAMessageAddressingMode, WAMessageStubType } from '../Types/index.js';
 import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/index.js';
-import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isLidUser, isPnUser, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isLidUser, isPnUser, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { makeChatsSocket } from './chats.js';
+
+export const buildReportNode = (jid, messageKeys = []) => ({
+    tag: 'spam_list',
+    attrs: {},
+    content: [{
+        tag: 'spam',
+        attrs: { jid },
+        content: messageKeys.map(key => {
+            if (!key?.id) {
+                throw new Boom('Every reported message key must include an id', { statusCode: 400 });
+            }
+            return {
+                tag: 'message',
+                attrs: {
+                    id: key.id,
+                    ...(key.fromMe !== undefined ? { from_me: key.fromMe ? 'true' : 'false' } : {}),
+                    ...(key.participant ? { participant: jidNormalizedUser(key.participant) } : {})
+                }
+            };
+        })
+    }]
+});
+
+export const buildGroupStatusRevokeMessage = (jid, key) => ({
+    groupStatusMessageV2: {
+        message: {
+            protocolMessage: {
+                key: {
+                    remoteJid: jid,
+                    fromMe: key.fromMe ?? true,
+                    id: key.id,
+                    ...(key.participant ? { participant: jidNormalizedUser(key.participant) } : {})
+                },
+                type: proto.Message.ProtocolMessage.Type.REVOKE
+            }
+        }
+    }
+});
+
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
-    const { authState, ev, query, upsertMessage } = sock;
+    const { authState, ev, query, relayMessage, updateBlockStatus, upsertMessage } = sock;
+    const reportJid = async (jid, messageKeys = []) => query({
+        tag: 'iq',
+        attrs: { type: 'set', xmlns: 'spam', to: S_WHATSAPP_NET },
+        content: [buildReportNode(jid, messageKeys)]
+    });
     const groupQuery = async (jid, type, content) => query({
         tag: 'iq',
         attrs: {
@@ -268,11 +312,45 @@ export const makeGroupsSocket = (config) => {
             ]);
         },
         groupFetchAllParticipating,
-        // crysnovax@GroupStatus --- Delete a group status by its message key.
-        // Pass the key object from the groupStatusMessageV2 you want to remove.
-        // Usage: await sock.deleteGroupStatus(jid, message.key)
+        /** Report a contact to WhatsApp, then block it after the report succeeds. */
+        reportContact: async (jid, messageKeys = []) => {
+            const normalizedJid = jidNormalizedUser(jid);
+            if (!isPnUser(normalizedJid) && !isLidUser(normalizedJid)) {
+                throw new Boom('reportContact requires a valid contact JID', { statusCode: 400 });
+            }
+            const reportResult = await reportJid(normalizedJid, messageKeys);
+            await updateBlockStatus(normalizedJid, 'block');
+            return reportResult;
+        },
+        /** Report a group to WhatsApp, then leave it after the report succeeds. */
+        reportGroup: async (jid, messageKeys = []) => {
+            if (!isJidGroup(jid)) {
+                throw new Boom('reportGroup requires a valid group JID', { statusCode: 400 });
+            }
+            const reportResult = await reportJid(jid, messageKeys);
+            await groupQuery('@g.us', 'set', [{
+                tag: 'leave',
+                attrs: {},
+                content: [{ tag: 'group', attrs: { id: jid } }]
+            }]);
+            return reportResult;
+        },
+        /** Revoke a previously sent group status using its original message key. */
         deleteGroupStatus: async (jid, key) => {
-            await sock.sendMessage(jid, { delete: key });
+            if (!isJidGroup(jid)) {
+                throw new Boom('deleteGroupStatus requires a valid group JID', { statusCode: 400 });
+            }
+            if (!key?.id) {
+                throw new Boom('deleteGroupStatus requires a message key with an id', { statusCode: 400 });
+            }
+            if (key.remoteJid && key.remoteJid !== jid) {
+                throw new Boom('The group status key does not belong to the target group', { statusCode: 400 });
+            }
+            return relayMessage(
+                jid,
+                buildGroupStatusRevokeMessage(jid, key),
+                { messageId: generateMessageIDV2(authState.creds.me?.id) }
+            );
         }
     };
 };