@codexverified/baileys 2.7.5

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,280 @@
+import { LRUCache } from 'lru-cache';
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from '../WABinary/index.js';
+export class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1000, // 7 days
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        });
+        this.inflightLIDLookups = new Map();
+        this.inflightPNLookups = new Map();
+        this.keys = keys;
+        this.pnToLIDFunc = pnToLIDFunc;
+        this.logger = logger;
+    }
+    async storeLIDPNMappings(pairs) {
+        if (pairs.length === 0)
+            return;
+        const validatedPairs = [];
+        for (const { lid, pn } of pairs) {
+            if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && isLidUser(pn)))) {
+                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                continue;
+            }
+            const lidDecoded = jidDecode(lid);
+            const pnDecoded = jidDecode(pn);
+            if (!lidDecoded || !pnDecoded)
+                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];
+            this.logger.trace(`Batch fetching ${cacheMisses.length} LID mappings from database`);
+            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) {
+                this.logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping');
+                continue;
+            }
+            pairMap[pnUser] = lidUser;
+        }
+        if (Object.keys(pairMap).length === 0)
+            return;
+        this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
+        const batchData = {};
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            batchData[pnUser] = lidUser;
+            batchData[`${lidUser}_reverse`] = pnUser;
+        }
+        await this.keys.transaction(async () => {
+            await this.keys.set({ 'lid-mapping': batchData });
+        }, 'lid-mapping');
+        // Update cache after successful DB write
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            this.mappingCache.set(`pn:${pnUser}`, lidUser);
+            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        }
+    }
+    async getLIDForPN(pn) {
+        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
+    }
+    async getLIDsForPNs(pns) {
+        if (pns.length === 0)
+            return null;
+        const sortedPns = [...new Set(pns)].sort();
+        const cacheKey = sortedPns.join(',');
+        const inflight = this.inflightLIDLookups.get(cacheKey);
+        if (inflight) {
+            this.logger.trace(`Coalescing getLIDsForPNs request for ${sortedPns.length} PNs`);
+            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 = {};
+        const pending = [];
+        const addResolvedPair = (pn, decoded, lidUser) => {
+            const normalizedLidUser = lidUser.toString();
+            if (!normalizedLidUser) {
+                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+                return false;
+            }
+            // Push the PN device ID to the LID to maintain device separation
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+            const deviceSpecificLid = `${normalizedLidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`;
+            this.logger.trace(`getLIDForPN: ${pn}  ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn };
+            return true;
+        };
+        for (const pn of pns) {
+            if (!isPnUser(pn) && !isHostedPnUser(pn))
+                continue;
+            const decoded = jidDecode(pn);
+            if (!decoded)
+                continue;
+            const pnUser = decoded.user;
+            const cached = this.mappingCache.get(`pn:${pnUser}`);
+            if (cached && typeof cached === 'string') {
+                if (!addResolvedPair(pn, decoded, cached)) {
+                    this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
+                    continue;
+                }
+                continue;
+            }
+            pending.push({ pn, pnUser, decoded });
+        }
+        if (pending.length) {
+            const pnUsers = [...new Set(pending.map(item => item.pnUser))];
+            const stored = await this.keys.get('lid-mapping', pnUsers);
+            for (const pnUser of pnUsers) {
+                const lidUser = stored[pnUser];
+                if (lidUser && typeof lidUser === 'string') {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                }
+            }
+            for (const { pn, pnUser, decoded } of pending) {
+                const cached = this.mappingCache.get(`pn:${pnUser}`);
+                if (cached && typeof cached === 'string') {
+                    if (!addResolvedPair(pn, decoded, cached)) {
+                        this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
+                        continue;
+                    }
+                }
+                else {
+                    this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
+                    const device = decoded.device || 0;
+                    let normalizedPn = jidNormalizedUser(pn);
+                    if (isHostedPnUser(normalizedPn)) {
+                        normalizedPn = `${pnUser}@s.whatsapp.net`;
+                    }
+                    if (!usyncFetch[normalizedPn]) {
+                        usyncFetch[normalizedPn] = [device];
+                    }
+                    else {
+                        usyncFetch[normalizedPn]?.push(device);
+                    }
+                }
+            }
+        }
+        if (Object.keys(usyncFetch).length > 0) {
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch)); // this function already adds LIDs to mapping
+            if (result && result.length > 0) {
+                await this.storeLIDPNMappings(result);
+                for (const pair of result) {
+                    const pnDecoded = jidDecode(pair.pn);
+                    const pnUser = pnDecoded?.user;
+                    if (!pnUser)
+                        continue;
+                    const lidUser = jidDecode(pair.lid)?.user;
+                    if (!lidUser)
+                        continue;
+                    for (const device of usyncFetch[pair.pn]) {
+                        const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted.lid' : 'lid'}`;
+                        this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn}  ${deviceSpecificLid} (user mapping with device ${device})`);
+                        const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`;
+                        successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
+                    }
+                }
+            }
+            else {
+                this.logger.warn('USync fetch yielded no results for pending PNs');
+            }
+        }
+        return Object.values(successfulPairs).length > 0 ? Object.values(successfulPairs) : null;
+    }
+    async getPNForLID(lid) {
+        return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null;
+    }
+    async getPNsForLIDs(lids) {
+        if (lids.length === 0)
+            return null;
+        const sortedLids = [...new Set(lids)].sort();
+        const cacheKey = sortedLids.join(',');
+        const inflight = this.inflightPNLookups.get(cacheKey);
+        if (inflight) {
+            this.logger.trace(`Coalescing getPNsForLIDs request for ${sortedLids.length} LIDs`);
+            return inflight;
+        }
+        const promise = this._getPNsForLIDsImpl(lids);
+        this.inflightPNLookups.set(cacheKey, promise);
+        try {
+            return await promise;
+        }
+        finally {
+            this.inflightPNLookups.delete(cacheKey);
+        }
+    }
+    async _getPNsForLIDsImpl(lids) {
+        const successfulPairs = {};
+        const pending = [];
+        const addResolvedPair = (lid, decoded, pnUser) => {
+            if (!pnUser || typeof pnUser !== 'string') {
+                return false;
+            }
+            const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+            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) && !isHostedLidUser(lid))
+                continue;
+            const decoded = jidDecode(lid);
+            if (!decoded)
+                continue;
+            const lidUser = decoded.user;
+            const cached = this.mappingCache.get(`lid:${lidUser}`);
+            if (cached && typeof cached === 'string') {
+                addResolvedPair(lid, decoded, cached);
+                continue;
+            }
+            pending.push({ lid, lidUser, decoded });
+        }
+        if (pending.length) {
+            const reverseKeys = [...new Set(pending.map(item => `${item.lidUser}_reverse`))];
+            const stored = await this.keys.get('lid-mapping', reverseKeys);
+            for (const { lid, lidUser, decoded } of pending) {
+                let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+                if (!pnUser || typeof pnUser !== 'string') {
+                    pnUser = stored[`${lidUser}_reverse`];
+                    if (pnUser && typeof pnUser === 'string') {
+                        this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                        this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    }
+                }
+                if (pnUser && typeof pnUser === 'string') {
+                    addResolvedPair(lid, decoded, pnUser);
+                }
+                else {
+                    this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+                }
+            }
+        }
+        return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null;
+    }
+    /**
+    * Close the cache and release resources
+    */
+    close() {
+        this.mappingCache.clear();
+    }
+}

package/lib/Socket/Client/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './websocket.js';

package/lib/Socket/Client/types.js

@@ -0,0 +1,10 @@
+import { EventEmitter } from 'events';
+import { URL } from 'url';
+export class AbstractSocketClient extends EventEmitter {
+    constructor(url, config) {
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
+    }
+}

package/lib/Socket/Client/websocket.js

@@ -0,0 +1,53 @@
+import WebSocket from 'ws';
+import { DEFAULT_ORIGIN } from '../../Defaults/index.js';
+import { AbstractSocketClient } from './types.js';
+export class WebSocketClient extends AbstractSocketClient {
+    constructor() {
+        super(...arguments);
+        this.socket = null;
+    }
+    get isOpen() {
+        return this.socket?.readyState === WebSocket.OPEN;
+    }
+    get isClosed() {
+        return this.socket === null || this.socket?.readyState === WebSocket.CLOSED;
+    }
+    get isClosing() {
+        return this.socket === null || this.socket?.readyState === WebSocket.CLOSING;
+    }
+    get isConnecting() {
+        return this.socket?.readyState === WebSocket.CONNECTING;
+    }
+    connect() {
+        if (this.socket) {
+            return;
+        }
+        this.socket = new WebSocket(this.url, {
+            origin: DEFAULT_ORIGIN,
+            headers: this.config.options?.headers,
+            handshakeTimeout: this.config.connectTimeoutMs,
+            timeout: this.config.connectTimeoutMs,
+            agent: this.config.agent
+        });
+        this.socket.setMaxListeners(0);
+        const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
+        for (const event of events) {
+            this.socket?.on(event, (...args) => this.emit(event, ...args));
+        }
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        const closePromise = new Promise(resolve => {
+            this.socket?.once('close', resolve);
+        });
+        this.socket.close();
+        await closePromise;
+        this.socket = null;
+    }
+    send(str, cb) {
+        this.socket?.send(str, cb);
+        return Boolean(this.socket);
+    }
+}

package/lib/Socket/aigroups.js

@@ -0,0 +1,315 @@
+import { WAMessageAddressingMode } from '../Types/index.js';
+import { generateMessageIDV2, normalizeMessageContent } from '../Utils/index.js';
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidMetaAI, isLidUser, isPnUser, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
+import { makeGroupsSocket } from './groups.js';
+
+/** Default Meta AI bot JID used inside AI groups. */
+export const META_AI_BOT_JID = '867051314767696@bot';
+
+// `@bot` JIDs carry their device as a trailing suffix (`bot:1`), which
+// jidNormalizedUser does not strip  normalize it before comparing.
+const stripDeviceSuffix = (jid) => String(jid || '').replace(/:\d+$/, '');
+const sameBotJid = (a, b) => {
+    if (!a || !b) {
+        return false;
+    }
+    return jidNormalizedUser(stripDeviceSuffix(a)) === jidNormalizedUser(stripDeviceSuffix(b));
+};
+
+// Pull the reply stanzaId out of a message: normalizeMessageContent returns the
+// type-keyed wrapper (`{ extendedTextMessage: { ... } }`), so unwrap one level.
+const extractReplyStanzaId = (message) => {
+    const content = message ? normalizeMessageContent(message) : undefined;
+    const inner = content && typeof content === 'object'
+        ? content[Object.keys(content)[0]]
+        : undefined;
+    return inner?.contextInfo?.stanzaId || content?.contextInfo?.stanzaId || message?.messageContextInfo?.stanzaId;
+};
+
+/**
+ * Pure matcher: is `message` a Meta AI bot response in `chatJid`?
+ *
+ * A message is treated as a bot response when ALL of these hold:
+ *   1. it is not from me, and its remoteJid is the chat we prompted in;
+ *   2. the sender is a known bot JID (`@bot` suffix or one of `botJids`); OR
+ *      its reply context (`contextInfo.stanzaId`) references the prompt we sent.
+ *
+ * The `botJids` fallback lets callers pass the bot's LID participant JID
+ * (resolved from group metadata) so LID-addressed AI groups match too.
+ */
+export const isMetaAIBotResponse = (message, chatJid, promptId, botJids = []) => {
+    if (!message || !message.key || message.key.fromMe) {
+        return false;
+    }
+    if (message.key.remoteJid !== chatJid) {
+        return false;
+    }
+    const sender = stripDeviceSuffix(message.key.participant || message.key.remoteJid);
+    if (isJidMetaAI(sender)) {
+        return true;
+    }
+    for (const botJid of botJids) {
+        if (sameBotJid(botJid, sender)) {
+            return true;
+        }
+    }
+    if (promptId && extractReplyStanzaId(message.message) === promptId) {
+        return true;
+    }
+    return false;
+};
+
+// Resolve the bot's real participant JID(s) inside an AI group so the response
+// matcher can recognize LID-addressed bot messages. Falls back to the canonical
+// `@bot` JID when metadata is unavailable.
+export const collectMetaAIBotParticipantJids = async (sock, jid, botUser) => {
+    const candidates = new Set([botUser]);
+    if (!isJidGroup(jid)) {
+        return candidates;
+    }
+    const botNumber = jidNormalizedUser(botUser).split('@')[0];
+    try {
+        const meta = await sock.groupMetadata(jid);
+        for (const participant of meta.participants || []) {
+            const pn = participant.phoneNumber
+                ? jidNormalizedUser(participant.phoneNumber).split('@')[0]
+                : undefined;
+            const idNumber = jidNormalizedUser(participant.id).split('@')[0];
+            if (pn === botNumber || idNumber === botNumber || isJidMetaAI(participant.id)) {
+                candidates.add(participant.id);
+            }
+        }
+    }
+    catch {
+        // metadata unavailable  the canonical @bot JID is already in the set
+    }
+    return candidates;
+};
+
+export const makeAIGroupsSocket = (config) => {
+    const sock = makeGroupsSocket(config);
+    const { ev, query } = sock;
+
+    /** Query helper for AI groups (w:gp2 namespace) */
+    const aiGroupQuery = async (jid, type, content) => query({
+        tag: 'iq',
+        attrs: {
+            type,
+            xmlns: 'w:g2',
+            to: jid
+        },
+        content
+    });
+
+    const aiGroupMetadata = async (jid) => {
+        const result = await aiGroupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
+        return extractAIGroupMetadata(result);
+    };
+
+    // Handle incoming w:gp2 notifications (create, promote, remove, add)
+    sock.ws.on('CB:notification,w:gp2', async (node) => {
+        const { attrs, content } = node;
+        if (!Array.isArray(content) || content.length === 0) return;
+
+        const inner = content[0];
+        const tag = inner.tag;
+        const groupId = typeof attrs.from === 'string'
+            ? attrs.from
+            : attrs.from?.$1?.user
+                ? jidEncode(attrs.from.$1.user, 'g.us')
+                : undefined;
+
+        if (!groupId) return;
+
+        if (tag === 'create') {
+            // New AI group created  emit groups.upsert
+            try {
+                const meta = await aiGroupMetadata(groupId);
+                ev.emit('groups.upsert', [meta]);
+            }
+            catch {
+                // metadata fetch may fail; emit minimal info
+                ev.emit('groups.upsert', [{ id: groupId }]);
+            }
+        }
+        else if (tag === 'promote' || tag === 'demote' || tag === 'remove' || tag === 'add') {
+            const participants = getBinaryNodeChildren(inner, 'participant')
+                .map(p => {
+                    const jid = p.attrs.jid;
+                    if (typeof jid === 'string') return jid;
+                    if (jid?.$1) {
+                        return jidEncode(jid.$1.user, jid.$1.server || 's.whatsapp.net');
+                    }
+                    return undefined;
+                })
+                .filter(Boolean);
+
+            ev.emit('group-participants.update', {
+                id: groupId,
+                participants,
+                action: tag
+            });
+        }
+        else if (tag === 'subject') {
+            ev.emit('groups.update', [{ id: groupId, subject: inner.attrs?.subject }]);
+        }
+
+        await sock.sendMessageAck(node);
+    });
+
+    return {
+        ...sock,
+        aiGroupMetadata,
+        aiGroupCreate: async (subject, participants = [], options = {}) => {
+            if (!Array.isArray(participants)) participants = [];
+            const key = generateMessageIDV2();
+            const {
+                ephemeralExpiration = 86400,
+                memberAddMode = 'all_member_add',
+                memberShareGroupHistoryMode = 'all_member_share',
+                memberLinkMode = 'all_member_link'
+            } = options;
+            const result = await aiGroupQuery('@g.us', 'set', [
+                {
+                    tag: 'create',
+                    attrs: {
+                        subject,
+                        key
+                    },
+                    content: participants.map(jid => ({
+                        tag: 'participant',
+                        attrs: { jid }
+                    }))
+                }
+            ]);
+            return extractAIGroupMetadata(result);
+        },
+        aiGroupAddBot: async (jid, botUser = '867051314767696') => {
+            const result = await aiGroupQuery(jid, 'set', [
+                {
+                    tag: 'add',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'participant',
+                            attrs: { jid: `${botUser}@bot` }
+                        }
+                    ]
+                }
+            ]);
+            const node = getBinaryNodeChild(result, 'add');
+            const participantsAffected = getBinaryNodeChildren(node, 'participant');
+            return participantsAffected.map(p => ({
+                status: p.attrs.error || '200',
+                jid: p.attrs.jid
+            }));
+        },
+        aiGroupLeave: async (id) => {
+            await aiGroupQuery('@g.us', 'set', [
+                {
+                    tag: 'leave',
+                    attrs: {},
+                    content: [{ tag: 'group', attrs: { id } }]
+                }
+            ]);
+        },
+        aiGroupParticipantsUpdate: async (jid, participants, action) => {
+            const result = await aiGroupQuery(jid, 'set', [
+                {
+                    tag: action,
+                    attrs: {},
+                    content: participants.map(jid => ({
+                        tag: 'participant',
+                        attrs: { jid }
+                    }))
+                }
+            ]);
+            const node = getBinaryNodeChild(result, action);
+            const participantsAffected = getBinaryNodeChildren(node, 'participant');
+            return participantsAffected.map(p => ({
+                status: p.attrs.error || '200',
+                jid: p.attrs.jid,
+                content: p
+            }));
+        },
+        aiGroupUpdateSubject: async (jid, subject) => {
+            await aiGroupQuery(jid, 'set', [
+                {
+                    tag: 'subject',
+                    attrs: {},
+                    content: Buffer.from(subject, 'utf-8')
+                }
+            ]);
+        },
+        aiGroupInviteCode: async (jid) => {
+            const result = await aiGroupQuery(jid, 'get', [{ tag: 'invite', attrs: {} }]);
+            const inviteNode = getBinaryNodeChild(result, 'invite');
+            return inviteNode?.attrs.code;
+        },
+        aiGroupRevokeInvite: async (jid) => {
+            const result = await aiGroupQuery(jid, 'set', [{ tag: 'invite', attrs: {} }]);
+            const inviteNode = getBinaryNodeChild(result, 'invite');
+            return inviteNode?.attrs.code;
+        },
+        aiGroupAcceptInvite: async (code) => {
+            const results = await aiGroupQuery('@g.us', 'set', [{ tag: 'invite', attrs: { code } }]);
+            const result = getBinaryNodeChild(results, 'group');
+            return result?.attrs.jid;
+        },
+        aiGroupSettingUpdate: async (jid, setting) => {
+            await aiGroupQuery(jid, 'set', [{ tag: setting, attrs: {} }]);
+        },
+        aiGroupToggleEphemeral: async (jid, ephemeralExpiration) => {
+            const content = ephemeralExpiration
+                ? { tag: 'ephemeral', attrs: { expiration: ephemeralExpiration.toString() } }
+                : { tag: 'not_ephemeral', attrs: {} };
+            await aiGroupQuery(jid, 'set', [content]);
+        }
+    };
+};
+
+export const extractAIGroupMetadata = (result) => {
+    // IQ response nests group inside create node: result  create  group
+    const createNode = getBinaryNodeChild(result, 'create');
+    const group =
+        getBinaryNodeChild(createNode || result, 'group') ||
+        getBinaryNodeChild(result, 'group');
+    const descChild = getBinaryNodeChild(group, 'description');
+    let desc, descId, descOwner, descOwnerPn, descTime;
+    if (descChild) {
+        desc = getBinaryNodeChildString(descChild, 'body');
+        descOwner = descChild.attrs.participant ? jidNormalizedUser(descChild.attrs.participant) : undefined;
+        descOwnerPn = descChild.attrs.participant_pn
+            ? jidNormalizedUser(descChild.attrs.participant_pn)
+            : undefined;
+        descTime = +descChild.attrs.t;
+        descId = descChild.attrs.id;
+    }
+    const groupId = group.attrs.id.includes('@') ? group.attrs.id : jidEncode(group.attrs.id, 'g.us');
+    const eph = getBinaryNodeChild(group, 'ephemeral')?.attrs.expiration;
+    const metadata = {
+        id: groupId,
+        subject: group.attrs.subject,
+        subjectTime: +group.attrs.s_t,
+        creation: +group.attrs.creation,
+        owner: group.attrs.creator ? jidNormalizedUser(group.attrs.creator) : undefined,
+        ownerPn: group.attrs.creator_pn ? jidNormalizedUser(group.attrs.creator_pn) : undefined,
+        owner_country_code: group.attrs.creator_country_code,
+        size: group.attrs.size ? +group.attrs.size : getBinaryNodeChildren(group, 'participant').length,
+        desc,
+        descId,
+        descOwner,
+        descOwnerPn,
+        descTime,
+        isAIGroup: true,
+        addressingMode: group.attrs.addressing_mode === 'lid' ? WAMessageAddressingMode.LID : WAMessageAddressingMode.PN,
+        participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => ({
+            id: attrs.jid,
+            phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
+            lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+            admin: attrs.type || null
+        })),
+        ephemeralDuration: eph ? +eph : undefined
+    };
+    return metadata;
+};