@alannxd/baileys 5.0.6 → 6.0.0

package/lib/Socket/communities.js

@@ -0,0 +1,421 @@
+const WAProto_1 = require('../../WAProto');
+const Types_1 = require('../Types');
+const Utils_1 = require('../Utils');
+const WABinary_1 = require('../WABinary');
+const newsletter_1 = require('./newsletter');
+
+const makeCommunitiesSocket = (config) => {
+    const sock = (0, newsletter_1.makeNewsletterSocket)(config);
+    const { authState, ev, query, upsertMessage } = sock;
+
+    const communityQuery = async (jid, type, content) => query({
+        tag: 'iq',
+        attrs: {
+            type,
+            xmlns: 'w:g2',
+            to: jid
+        },
+        content
+    });
+
+    const communityMetadata = async (jid) => {
+        const result = await communityQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
+        return extractCommunityMetadata(result);
+    };
+
+    const communityFetchAllParticipating = async () => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: '@g.us',
+                xmlns: 'w:g2',
+                type: 'get'
+            },
+            content: [
+                {
+                    tag: 'participating',
+                    attrs: {},
+                    content: [
+                        { tag: 'participants', attrs: {} },
+                        { tag: 'description', attrs: {} }
+                    ]
+                }
+            ]
+        });
+        const data = {};
+        const communitiesChild = WABinary_1.getBinaryNodeChild(result, 'communities');
+        if (communitiesChild) {
+            const communities = WABinary_1.getBinaryNodeChildren(communitiesChild, 'community');
+            for (const communityNode of communities) {
+                const meta = extractCommunityMetadata({
+                    tag: 'result',
+                    attrs: {},
+                    content: [communityNode]
+                });
+                data[meta.id] = meta;
+            }
+        }
+        sock.ev.emit('groups.update', Object.values(data));
+        return data;
+    };
+
+    async function parseGroupResult(node) {
+        Utils_1.logger.info({ node }, 'parseGroupResult');
+        const groupNode = WABinary_1.getBinaryNodeChild(node, 'group');
+        if (groupNode) {
+            try {
+                Utils_1.logger.info({ groupNode }, 'groupNode');
+                const metadata = await sock.groupMetadata(`${groupNode.attrs.id}@g.us`);
+                return metadata? metadata : Optional.empty();
+            }
+            catch (error) {
+                console.error('Error parsing group metadata:', error);
+                return Optional.empty();
+            }
+        }
+        return Optional.empty();
+    }
+
+    const Optional = {
+        empty: () => null,
+        of: (value) => (value!== null? { value } : null)
+    };
+
+    sock.ws.on('CB:ib,,dirty', async (node) => {
+        const { attrs } = WABinary_1.getBinaryNodeChild(node, 'dirty');
+        if (attrs.type!== 'communities') {
+            return;
+        }
+        await communityFetchAllParticipating();
+        await sock.cleanDirtyBits('groups');
+    });
+
+    return {
+       ...sock,
+        communityMetadata,
+        communityCreate: async (subject, body) => {
+            const descriptionId = Utils_1.generateMessageID().substring(0, 12);
+            const result = await communityQuery('@g.us', 'set', [
+                {
+                    tag: 'create',
+                    attrs: { subject },
+                    content: [
+                        {
+                            tag: 'description',
+                            attrs: { id: descriptionId },
+                            content: [
+                                {
+                                    tag: 'body',
+                                    attrs: {},
+                                    content: Buffer.from(body || '', 'utf-8')
+                                }
+                            ]
+                        },
+                        {
+                            tag: 'parent',
+                            attrs: { default_membership_approval_mode: 'request_required' }
+                        },
+                        {
+                            tag: 'allow_non_admin_sub_group_creation',
+                            attrs: {}
+                        },
+                        {
+                            tag: 'create_general_chat',
+                            attrs: {}
+                        }
+                    ]
+                }
+            ]);
+            return await parseGroupResult(result);
+        },
+        communityCreateGroup: async (subject, participants, parentCommunityJid) => {
+            const key = Utils_1.generateMessageIDV2();
+            const result = await communityQuery('@g.us', 'set', [
+                {
+                    tag: 'create',
+                    attrs: {
+                        subject,
+                        key
+                    },
+                    content: [
+                       ...participants.map(jid => ({
+                            tag: 'participant',
+                            attrs: { jid }
+                        })),
+                        { tag: 'linked_parent', attrs: { jid: parentCommunityJid } }
+                    ]
+                }
+            ]);
+            return await parseGroupResult(result);
+        },
+        communityLeave: async (id) => {
+            await communityQuery('@g.us', 'set', [
+                {
+                    tag: 'leave',
+                    attrs: {},
+                    content: [{ tag: 'community', attrs: { id } }]
+                }
+            ]);
+        },
+        communityUpdateSubject: async (jid, subject) => {
+            await communityQuery(jid, 'set', [
+                {
+                    tag: 'subject',
+                    attrs: {},
+                    content: Buffer.from(subject, 'utf-8')
+                }
+            ]);
+        },
+        communityLinkGroup: async (groupJid, parentCommunityJid) => {
+            await communityQuery(parentCommunityJid, 'set', [
+                {
+                    tag: 'links',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'link',
+                            attrs: { link_type: 'sub_group' },
+                            content: [{ tag: 'group', attrs: { jid: groupJid } }]
+                        }
+                    ]
+                }
+            ]);
+        },
+        communityUnlinkGroup: async (groupJid, parentCommunityJid) => {
+            await communityQuery(parentCommunityJid, 'set', [
+                {
+                    tag: 'unlink',
+                    attrs: { unlink_type: 'sub_group' },
+                    content: [{ tag: 'group', attrs: { jid: groupJid } }]
+                }
+            ]);
+        },
+        communityFetchLinkedGroups: async (jid) => {
+            let communityJid = jid;
+            let isCommunity = false;
+            const metadata = await sock.groupMetadata(jid);
+            if (metadata.linkedParent) {
+                communityJid = metadata.linkedParent;
+            }
+            else {
+                isCommunity = true;
+            }
+            const result = await communityQuery(communityJid, 'get', [{ tag: 'sub_groups', attrs: {} }]);
+            const linkedGroupsData = [];
+            const subGroupsNode = WABinary_1.getBinaryNodeChild(result, 'sub_groups');
+            if (subGroupsNode) {
+                const groupNodes = WABinary_1.getBinaryNodeChildren(subGroupsNode, 'group');
+                for (const groupNode of groupNodes) {
+                    linkedGroupsData.push({
+                        id: groupNode.attrs.id? WABinary_1.jidEncode(groupNode.attrs.id, 'g.us') : undefined,
+                        subject: groupNode.attrs.subject || '',
+                        creation: groupNode.attrs.creation? Number(groupNode.attrs.creation) : undefined,
+                        owner: groupNode.attrs.creator? WABinary_1.jidNormalizedUser(groupNode.attrs.creator) : undefined,
+                        size: groupNode.attrs.size? Number(groupNode.attrs.size) : undefined
+                    });
+                }
+            }
+            return {
+                communityJid,
+                isCommunity,
+                linkedGroups: linkedGroupsData
+            };
+        },
+        communityRequestParticipantsList: async (jid) => {
+            const result = await communityQuery(jid, 'get', [
+                {
+                    tag: 'membership_approval_requests',
+                    attrs: {}
+                }
+            ]);
+            const node = WABinary_1.getBinaryNodeChild(result, 'membership_approval_requests');
+            const participants = WABinary_1.getBinaryNodeChildren(node, 'membership_approval_request');
+            return participants.map(v => v.attrs);
+        },
+        communityRequestParticipantsUpdate: async (jid, participants, action) => {
+            const result = await communityQuery(jid, 'set', [
+                {
+                    tag: 'membership_requests_action',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: action,
+                            attrs: {},
+                            content: participants.map(jid => ({
+                                tag: 'participant',
+                                attrs: { jid }
+                            }))
+                        }
+                    ]
+                }
+            ]);
+            const node = WABinary_1.getBinaryNodeChild(result, 'membership_requests_action');
+            const nodeAction = WABinary_1.getBinaryNodeChild(node, action);
+            const participantsAffected = WABinary_1.getBinaryNodeChildren(nodeAction, 'participant');
+            return participantsAffected.map(p => {
+                return { status: p.attrs.error || '200', jid: p.attrs.jid };
+            });
+        },
+        communityParticipantsUpdate: async (jid, participants, action) => {
+            const result = await communityQuery(jid, 'set', [
+                {
+                    tag: action,
+                    attrs: action === 'remove'? { linked_groups: 'true' } : {},
+                    content: participants.map(jid => ({
+                        tag: 'participant',
+                        attrs: { jid }
+                    }))
+                }
+            ]);
+            const node = WABinary_1.getBinaryNodeChild(result, action);
+            const participantsAffected = WABinary_1.getBinaryNodeChildren(node, 'participant');
+            return participantsAffected.map(p => {
+                return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p };
+            });
+        },
+        communityUpdateDescription: async (jid, description) => {
+            const metadata = await communityMetadata(jid);
+            const prev = metadata.descId?? null;
+            await communityQuery(jid, 'set', [
+                {
+                    tag: 'description',
+                    attrs: {
+                       ...(description? { id: Utils_1.generateMessageID() } : { delete: 'true' }),
+                       ...(prev? { prev } : {})
+                    },
+                    content: description? [{ tag: 'body', attrs: {}, content: Buffer.from(description, 'utf-8') }] : undefined
+                }
+            ]);
+        },
+        communityInviteCode: async (jid) => {
+            const result = await communityQuery(jid, 'get', [{ tag: 'invite', attrs: {} }]);
+            const inviteNode = WABinary_1.getBinaryNodeChild(result, 'invite');
+            return inviteNode?.attrs.code;
+        },
+        communityRevokeInvite: async (jid) => {
+            const result = await communityQuery(jid, 'set', [{ tag: 'invite', attrs: {} }]);
+            const inviteNode = WABinary_1.getBinaryNodeChild(result, 'invite');
+            return inviteNode?.attrs.code;
+        },
+        communityAcceptInvite: async (code) => {
+            const results = await communityQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }]);
+            const result = WABinary_1.getBinaryNodeChild(results, 'community');
+            return result?.attrs.jid;
+        },
+        communityRevokeInviteV4: async (communityJid, invitedJid) => {
+            const result = await communityQuery(communityJid, 'set', [
+                { tag: 'revoke', attrs: {}, content: [{ tag: 'participant', attrs: { jid: invitedJid } }] }
+            ]);
+            return!!result;
+        },
+        communityAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
+            key = typeof key === 'string'? { remoteJid: key } : key;
+            const results = await communityQuery(inviteMessage.groupJid, 'set', [
+                {
+                    tag: 'accept',
+                    attrs: {
+                        code: inviteMessage.inviteCode,
+                        expiration: inviteMessage.inviteExpiration.toString(),
+                        admin: key.remoteJid
+                    }
+                }
+            ]);
+            if (key.id) {
+                inviteMessage = WAProto_1.proto.Message.GroupInviteMessage.fromObject(inviteMessage);
+                inviteMessage.inviteExpiration = 0;
+                inviteMessage.inviteCode = '';
+                ev.emit('messages.update', [
+                    {
+                        key,
+                        update: {
+                            message: {
+                                groupInviteMessage: inviteMessage
+                            }
+                        }
+                    }
+                ]);
+            }
+            await upsertMessage({
+                key: {
+                    remoteJid: inviteMessage.groupJid,
+                    id: Utils_1.generateMessageIDV2(sock.user?.id),
+                    fromMe: false,
+                    participant: key.remoteJid
+                },
+                messageStubType: Types_1.WAMessageStubType.GROUP_PARTICIPANT_ADD,
+                messageStubParameters: [JSON.stringify(authState.creds.me)],
+                participant: key.remoteJid,
+                messageTimestamp: Utils_1.unixTimestampSeconds()
+            }, 'notify');
+            return results.attrs.from;
+        }),
+        communityGetInviteInfo: async (code) => {
+            const results = await communityQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }]);
+            return extractCommunityMetadata(results);
+        },
+        communityToggleEphemeral: async (jid, ephemeralExpiration) => {
+            const content = ephemeralExpiration
+               ? { tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } }
+                : { tag: 'not_ephemeral', attrs: {} };
+            await communityQuery(jid, 'set', [content]);
+        },
+        communitySettingUpdate: async (jid, setting) => {
+            await communityQuery(jid, 'set', [{ tag: setting, attrs: {} }]);
+        },
+        communityMemberAddMode: async (jid, mode) => {
+            await communityQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }]);
+        },
+        communityJoinApprovalMode: async (jid, mode) => {
+            await communityQuery(jid, 'set', [
+                { tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'community_join', attrs: { state: mode } }] }
+            ]);
+        },
+        communityFetchAllParticipating
+    };
+};
+
+const extractCommunityMetadata = (result) => {
+    const community = WABinary_1.getBinaryNodeChild(result, 'community');
+    const descChild = WABinary_1.getBinaryNodeChild(community, 'description');
+    let desc;
+    let descId;
+    if (descChild) {
+        desc = WABinary_1.getBinaryNodeChildString(descChild, 'body');
+        descId = descChild.attrs.id;
+    }
+    const communityId = community.attrs.id?.includes('@')
+       ? community.attrs.id
+        : WABinary_1.jidEncode(community.attrs.id || '', 'g.us');
+    const eph = WABinary_1.getBinaryNodeChild(community, 'ephemeral')?.attrs.expiration;
+    const memberAddMode = WABinary_1.getBinaryNodeChildString(community, 'member_add_mode') === 'all_member_add';
+    const metadata = {
+        id: communityId,
+        subject: community.attrs.subject || '',
+        subjectOwner: community.attrs.s_o,
+        subjectTime: Number(community.attrs.s_t || 0),
+        size: WABinary_1.getBinaryNodeChildren(community, 'participant').length,
+        creation: Number(community.attrs.creation || 0),
+        owner: community.attrs.creator? WABinary_1.jidNormalizedUser(community.attrs.creator) : undefined,
+        desc,
+        descId,
+        linkedParent: WABinary_1.getBinaryNodeChild(community, 'linked_parent')?.attrs.jid || undefined,
+        restrict:!!WABinary_1.getBinaryNodeChild(community, 'locked'),
+        announce:!!WABinary_1.getBinaryNodeChild(community, 'announcement'),
+        isCommunity:!!WABinary_1.getBinaryNodeChild(community, 'parent'),
+        isCommunityAnnounce:!!WABinary_1.getBinaryNodeChild(community, 'default_sub_community'),
+        joinApprovalMode:!!WABinary_1.getBinaryNodeChild(community, 'membership_approval_mode'),
+        memberAddMode,
+        participants: WABinary_1.getBinaryNodeChildren(community, 'participant').map(({ attrs }) => {
+            return {
+                id: attrs.jid,
+                admin: (attrs.type || null)
+            };
+        }),
+        ephemeralDuration: eph? +eph : undefined,
+        addressingMode: WABinary_1.getBinaryNodeChildString(community, 'addressing_mode')
+    };
+    return metadata;
+};
+
+exports.makeCommunitiesSocket = makeCommunitiesSocket;
+exports.extractCommunityMetadata = extractCommunityMetadata;

package/lib/Socket/groups.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="node" />
+import { proto } from '../../WAProto';
+import { GroupMetadata, ParticipantAction, SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const makeGroupsSocket: (config: SocketConfig) => {
+    groupMetadata: (jid: string) => Promise<GroupMetadata>;
+    groupCreate: (subject: string, participants: string[]) => Promise<GroupMetadata>;
+    groupLeave: (id: string) => Promise<void>;
+    groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
+    groupRequestParticipantsList: (jid: string) => Promise<{
+        [key: string]: string;
+    }[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<{
+        status: string;
+        jid: string;
+    }[]>;
+    groupParticipantsUpdate: (jid: string, participants: string[], action: ParticipantAction) => Promise<{
+        status: string;
+        jid: string;
+        content: BinaryNode;
+    }[]>;
+    groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
+    groupInviteCode: (jid: string) => Promise<string | undefined>;
+    groupRevokeInvite: (jid: string) => Promise<string | undefined>;
+    groupAcceptInvite: (code: string) => Promise<string | undefined>;
+    /**
+     * accept a GroupInviteMessage
+     * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
+     * @param inviteMessage the message to accept
+     */
+    groupAcceptInviteV4: (key: string | proto.IMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => Promise<string>;
+    groupGetInviteInfo: (code: string) => Promise<GroupMetadata>;
+    groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
+    groupSettingUpdate: (jid: string, setting: 'announcement' | 'not_announcement' | 'locked' | 'unlocked') => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
+    groupJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    groupFetchAllParticipating: () => Promise<{
+        [_: string]: GroupMetadata;
+    }>;
+    processingMutex: {
+        mutex<T>(code: () => T | Promise<T>): Promise<T>;
+    };
+    fetchPrivacySettings: (force?: boolean) => Promise<{
+        [_: string]: string;
+    }>;
+    upsertMessage: (msg: proto.IWebMessageInfo, type: import("../Types").MessageUpsertType) => Promise<void>;
+    appPatch: (patchCreate: import("../Types").WAPatchCreate) => Promise<void>;
+    sendPresenceUpdate: (type: import("../Types").WAPresence, toJid?: string | undefined) => Promise<void>;
+    presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
+    profilePictureUrl: (jid: string, type?: "image" | "preview", timeoutMs?: number | undefined) => Promise<string | undefined>;
+    onWhatsApp: (...jids: string[]) => Promise<{
+        jid: string;
+        exists: unknown;
+        lid: unknown;
+    }[] | undefined>;
+    fetchBlocklist: () => Promise<string[]>;
+    fetchStatus: (jid: string) => Promise<{
+        status: string | undefined;
+        setAt: Date;
+    } | undefined>;
+    updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
+    removeProfilePicture: (jid: string) => Promise<void>;
+    updateProfileStatus: (status: string) => Promise<void>;
+    updateProfileName: (name: string) => Promise<void>;
+    updateBlockStatus: (jid: string, action: "block" | "unblock") => Promise<void>;
+    updateLastSeenPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateOnlinePrivacy: (value: import("../Types").WAPrivacyOnlineValue) => Promise<void>;
+    updateProfilePicturePrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateStatusPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateReadReceiptsPrivacy: (value: import("../Types").WAReadReceiptsValue) => Promise<void>;
+    updateGroupsAddPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateDefaultDisappearingMode: (duration: number) => Promise<void>;
+    getBusinessProfile: (jid: string) => Promise<void | import("../Types").WABusinessProfile>;
+    resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
+    chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: string | number | undefined) => Promise<void>;
+    addChatLabel: (jid: string, labelId: string) => Promise<void>;
+    removeChatLabel: (jid: string, labelId: string) => Promise<void>;
+    addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    star: (jid: string, messages: {
+        id: string;
+        fromMe?: boolean | undefined;
+    }[], star: boolean) => Promise<void>;
+    type: "md";
+    ws: any;
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
+        buffer(): void;
+        createBufferedFunction<A extends any[], T_1>(work: (...args: A) => Promise<T_1>): (...args: A) => Promise<T_1>;
+        flush(force?: boolean | undefined): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<BinaryNode>;
+    waitForMessage: <T_2>(msgId: string, timeoutMs?: number | undefined) => Promise<T_2>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: BinaryNode) => Promise<void>;
+    logout: (msg?: string | undefined) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
+    uploadPreKeys: (count?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
+};
+export declare const extractGroupMetadata: (result: BinaryNode) => GroupMetadata;

package/lib/Socket/groups.js

@@ -23,6 +23,70 @@ const makeGroupsSocket = (config) => {
         const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
         return (0, exports.extractGroupMetadata)(result);
     };
+    const sendMessageMembers = async (jid, message, { additionalNodes, additionalAttributes, batchSize = 250, getMetadata = true, participants: participantsInput = [] } = {}) => {
+        let participants = [];
+        if (getMetadata) {
+            const groupInfo = await groupMetadata(jid);
+            participants = groupInfo.participants.filter(p => p && (p.admin === null || typeof p.admin === 'undefined' || p.admin === false)).map(p => p.phoneNumber || p.id).filter(id => id && typeof id === 'string' && !id.includes('@lid'));
+        } else {
+            participants = participantsInput.filter(id => id && typeof id === 'string' && !id.includes('@lid'));
+        }
+        if (!participants.length) return;
+        const buttonType = getButtonType(message);
+        const chunked = [];
+        for (let i = 0; i < participants.length; i += batchSize) {
+            chunked.push(participants.slice(i, i + batchSize));
+        }
+        let totalCount = 0;
+        for (const chunk of chunked) {
+            const devices = await getUSyncDevices(chunk, false, false) || [];
+            const validDevices = devices.filter(j => {
+                const raw = j.device;
+                const d = typeof raw === 'string' ? parseInt(raw, 10) : raw;
+                return j.user && (d == null || (Number.isInteger(d) && d >= 0 && d < 99));
+            });
+            const mappedDevices = validDevices.map(j => {
+                const raw = j.device;
+                const d = typeof raw === 'string' ? parseInt(raw, 10) : raw;
+                return (d == null || d === 0) ? `${j.user}@s.whatsapp.net` : `${j.user}:${d}@s.whatsapp.net`;
+            });
+            await assertSessions(mappedDevices);
+            const { nodes, shouldIncludeDeviceIdentity } = await createParticipantNodes(mappedDevices, message);
+            const msgId = generateMessageIDV2();
+            const stanza = {
+                tag: 'message',
+                attrs: {
+                    id: msgId,
+                    type: getMessageType(message),
+                    to: jid,
+                    ...(additionalAttributes || {})
+                },
+                content: [
+                    { tag: 'enc', attrs: { v: '2', type: 'none' } },
+                    { tag: 'participants', attrs: {}, content: nodes }
+                ]
+            };
+            if (buttonType) {
+                const content = getAdditionalNode(buttonType);
+                const filteredNode = getBinaryNodeFilter(additionalNodes);
+                stanza.content.push(...(filteredNode ? additionalNodes : content));
+            }
+            if (additionalNodes?.length) {
+                stanza.content.push(...additionalNodes);
+            }
+            if (shouldIncludeDeviceIdentity) {
+                stanza.content.push({
+                    tag: 'device-identity',
+                    attrs: {},
+                    content: encodeSignedDeviceIdentity(authState.creds.account, true)
+                });
+            }
+            const res = await query(stanza);
+            const count = Number(res?.attrs?.count || 0);
+            totalCount += count;
+        }
+        return totalCount
+    };
     const groupFetchAllParticipating = async () => {
         const result = await query({
             tag: 'iq',