@aseppxyzz12/baileys 1.1.8

package/lib/Socket/mex.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { Boom: Boom } = require("@hapi/boom");
+const {
+    getBinaryNodeChild: getBinaryNodeChild,
+    S_WHATSAPP_NET: S_WHATSAPP_NET,
+} = require("../WABinary");
+const wMexQuery = (variables, queryId, query, generateMessageTag) =>
+    query({
+        tag: "iq",
+        attrs: {
+            id: generateMessageTag(),
+            type: "get",
+            to: S_WHATSAPP_NET,
+            xmlns: "w:mex",
+        },
+        content: [
+            {
+                tag: "query",
+                attrs: { query_id: queryId },
+                content: Buffer.from(JSON.stringify({ variables: variables }), "utf-8"),
+            },
+        ],
+    });
+const executeWMexQuery = async (variables, queryId, dataPath, query, generateMessageTag) => {
+    const result = await wMexQuery(variables, queryId, query, generateMessageTag);
+    const child = getBinaryNodeChild(result, "result");
+    if (child?.content) {
+        const data = JSON.parse(child.content.toString());
+        if (data.errors && data.errors.length > 0) {
+            const errorMessages = data.errors
+                .map((err) => err.message || "Unknown error")
+                .join(", ");
+            const firstError = data.errors[0];
+            const errorCode = firstError.extensions?.error_code || 400;
+            throw new Boom(`GraphQL server error: ${errorMessages}`, {
+                statusCode: errorCode,
+                data: firstError,
+            });
+        }
+        const response = dataPath ? data?.data?.[dataPath] : data?.data;
+        if (typeof response !== "undefined") {
+            return response;
+        }
+    }
+    const action = (dataPath || "").startsWith("xwa2_")
+        ? dataPath.substring(5).replace(/_/g, " ")
+        : dataPath?.replace(/_/g, " ");
+    throw new Boom(`Failed to ${action}, unexpected response structure.`, {
+        statusCode: 400,
+        data: result,
+    });
+};
+module.exports = { executeWMexQuery: executeWMexQuery };

package/lib/Socket/newsletter.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { QueryIds: QueryIds, XWAPaths: XWAPaths } = require("../Types");
+const { generateProfilePicture: generateProfilePicture } = require("../Utils");
+const { getBinaryNodeChild: getBinaryNodeChild } = require("../WABinary");
+const { makeGroupsSocket: makeGroupsSocket } = require("./groups");
+const { executeWMexQuery: genericExecuteWMexQuery } = require("./mex");
+const parseNewsletterCreateResponse = (response) => {
+    const { id: id, thread_metadata: thread, viewer_metadata: viewer } = response;
+    return {
+        id: id,
+        owner: undefined,
+        name: thread.name.text,
+        creation_time: parseInt(thread.creation_time, 10),
+        description: thread.description.text,
+        invite: thread.invite,
+        subscribers: parseInt(thread.subscribers_count, 10),
+        verification: thread.verification,
+        picture: { id: thread.picture.id, directPath: thread.picture.direct_path },
+        mute_state: viewer.mute,
+    };
+};
+const parseNewsletterMetadata = (result) => {
+    if (typeof result !== "object" || result === null) {
+        return null;
+    }
+    if ("id" in result && typeof result.id === "string") {
+        return result;
+    }
+    if (
+        "result" in result &&
+        typeof result.result === "object" &&
+        result.result !== null &&
+        "id" in result.result
+    ) {
+        return result.result;
+    }
+    return null;
+};
+const makeNewsletterSocket = (config) => {
+    const conn = makeGroupsSocket(config);
+    const { query: query, generateMessageTag: generateMessageTag } = conn;
+    const executeWMexQuery = (variables, queryId, dataPath) =>
+        genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
+ 
+        
+    const newsletterUpdate = async (jid, updates) => {
+        const variables = {
+            newsletter_id: jid,
+            updates: { ...updates, settings: null },
+        };
+        return executeWMexQuery(variables, QueryIds.UPDATE_METADATA, XWAPaths.UPDATE);
+    };
+    return {
+        ...conn,
+        executeWMexQuery: executeWMexQuery,
+        newsletterCreate: async (name, description) => {
+            const variables = {
+                input: { name: name, description: description ?? null },
+            };
+            const rawResponse = await executeWMexQuery(variables, QueryIds.CREATE, XWAPaths.CREATE);
+            return parseNewsletterCreateResponse(rawResponse);
+        },
+        newsletterUpdate: newsletterUpdate,
+        newsletterSubscribers: async (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.SUBSCRIBERS, XWAPaths.SUBSCRIBERS),
+        newsletterMetadata: async (type, key) => {
+            const variables = {
+                fetch_creation_time: true,
+                fetch_full_image: true,
+                fetch_viewer_metadata: true,
+                input: { key: key, type: type.toUpperCase() },
+            };
+            const result = await executeWMexQuery(variables, QueryIds.METADATA, XWAPaths.METADATA);
+            return parseNewsletterMetadata(result);
+        },
+        newsletterFollow: (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.FOLLOW),
+        newsletterUnfollow: (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.UNFOLLOW, XWAPaths.UNFOLLOW),
+        newsletterMute: (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.MUTE_V2),
+        newsletterUnmute: (jid) =>
+            executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.UNMUTE_V2),
+        newsletterUpdateName: async (jid, name) => await newsletterUpdate(jid, { name: name }),
+        newsletterUpdateDescription: async (jid, description) =>
+            await newsletterUpdate(jid, { description: description }),
+        newsletterUpdatePicture: async (jid, content) => {
+            const { img: img } = await generateProfilePicture(content);
+            return await newsletterUpdate(jid, { picture: img.toString("base64") });
+        },
+        newsletterRemovePicture: async (jid) => await newsletterUpdate(jid, { picture: "" }),
+        newsletterReactMessage: async (jid, serverId, reaction) => {
+            await query({
+                tag: "message",
+                attrs: {
+                    to: jid,
+                    ...(reaction ? {} : { edit: "7" }),
+                    type: "reaction",
+                    server_id: serverId,
+                    id: generateMessageTag(),
+                },
+                content: [{ tag: "reaction", attrs: reaction ? { code: reaction } : {} }],
+            });
+        },
+        newsletterFetchMessages: async (jid, count, since, after) => {
+            const messageUpdateAttrs = { count: count.toString() };
+            if (typeof since === "number") {
+                messageUpdateAttrs.since = since.toString();
+            }
+            if (after) {
+                messageUpdateAttrs.after = after.toString();
+            }
+            const result = await query({
+                tag: "iq",
+                attrs: {
+                    id: generateMessageTag(),
+                    type: "get",
+                    xmlns: "newsletter",
+                    to: jid,
+                },
+                content: [{ tag: "message_updates", attrs: messageUpdateAttrs }],
+            });
+            return result;
+        },
+        subscribeNewsletterUpdates: async (jid) => {
+            const result = await query({
+                tag: "iq",
+                attrs: {
+                    id: generateMessageTag(),
+                    type: "set",
+                    xmlns: "newsletter",
+                    to: jid,
+                },
+                content: [{ tag: "live_updates", attrs: {}, content: [] }],
+            });
+            const liveUpdatesNode = getBinaryNodeChild(result, "live_updates");
+            const duration = liveUpdatesNode?.attrs?.duration;
+            return duration ? { duration: duration } : null;
+        },
+        newsletterAdminCount: async (jid) => {
+            const response = await executeWMexQuery(
+                { newsletter_id: jid },
+                QueryIds.ADMIN_COUNT,
+                XWAPaths.ADMIN_COUNT
+            );
+            return response.admin_count;
+        },
+        newsletterChangeOwner: async (jid, newOwnerJid) => {
+            await executeWMexQuery(
+                { newsletter_id: jid, user_id: newOwnerJid },
+                QueryIds.CHANGE_OWNER,
+                XWAPaths.CHANGE_OWNER
+            );
+        },
+        newsletterDemote: async (jid, userJid) => {
+            await executeWMexQuery(
+                { newsletter_id: jid, user_id: userJid },
+                QueryIds.DEMOTE,
+                XWAPaths.DEMOTE
+            );
+        },
+        newsletterDelete: async (jid) => {
+            await executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.DELETE_V2);
+        },
+    };
+};
+module.exports = {
+    makeNewsletterSocket: makeNewsletterSocket,
+    parseNewsletterMetadata: parseNewsletterMetadata,
+};

package/lib/Socket/registration.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mobileRegisterFetch = exports.mobileRegisterEncrypt = exports.mobileRegister = exports.mobileRegisterExists = exports.mobileRegisterCode = exports.registrationParams = exports.makeRegistrationSocket = void 0;
+/* eslint-disable camelcase */
+const axios_1 = __importDefault(require("axios"));
+const Defaults_1 = require("../Defaults");
+const crypto_1 = require("../Utils/crypto");
+const WABinary_1 = require("../WABinary");
+const business_1 = require("./business");
+const community_1 = require("./community");
+function urlencode(str) {
+    return str.replace(/-/g, '%2d').replace(/_/g, '%5f').replace(/~/g, '%7e');
+}
+const validRegistrationOptions = (config) => (config === null || config === void 0 ? void 0 : config.phoneNumberCountryCode) &&
+    config.phoneNumberNationalNumber &&
+    config.phoneNumberMobileCountryCode;
+const makeRegistrationSocket = (config) => {
+    const sock = (0, community_1.makeCommunitiesSocket)(config);
+    const register = async (code) => {
+        if (!validRegistrationOptions(config.auth.creds.registration)) {
+            throw new Error('please specify the registration options');
+        }
+        const result = await mobileRegister({ ...sock.authState.creds, ...sock.authState.creds.registration, code }, config.options);
+        sock.authState.creds.me = {
+            id: (0, WABinary_1.jidEncode)(result.login, 's.whatsapp.net'),
+            name: '~'
+        };
+        sock.authState.creds.registered = true;
+        sock.ev.emit('creds.update', sock.authState.creds);
+        return result;
+    };
+    const requestRegistrationCode = async (registrationOptions) => {
+        registrationOptions = registrationOptions || config.auth.creds.registration;
+        if (!validRegistrationOptions(registrationOptions)) {
+            throw new Error('Invalid registration options');
+        }
+        sock.authState.creds.registration = registrationOptions;
+        sock.ev.emit('creds.update', sock.authState.creds);
+        return mobileRegisterCode({ ...config.auth.creds, ...registrationOptions }, config.options);
+    };
+    return {
+        ...sock,
+        register,
+        requestRegistrationCode,
+    };
+};
+exports.makeRegistrationSocket = makeRegistrationSocket;
+function convertBufferToUrlHex(buffer) {
+    var id = '';
+    buffer.forEach((x) => {
+        // encode random identity_id buffer as percentage url encoding
+        id += `%${x.toString(16).padStart(2, '0').toLowerCase()}`;
+    });
+    return id;
+}
+function registrationParams(params) {
+    const e_regid = Buffer.alloc(4);
+    e_regid.writeInt32BE(params.registrationId);
+    const e_skey_id = Buffer.alloc(3);
+    e_skey_id.writeInt16BE(params.signedPreKey.keyId);
+    params.phoneNumberCountryCode = params.phoneNumberCountryCode.replace('+', '').trim();
+    params.phoneNumberNationalNumber = params.phoneNumberNationalNumber.replace(/[/-\s)(]/g, '').trim();
+    return {
+        cc: params.phoneNumberCountryCode,
+        in: params.phoneNumberNationalNumber,
+        Rc: '0',
+        lg: 'en',
+        lc: 'GB',
+        mistyped: '6',
+        authkey: Buffer.from(params.noiseKey.public).toString('base64url'),
+        e_regid: e_regid.toString('base64url'),
+        e_keytype: 'BQ',
+        e_ident: Buffer.from(params.signedIdentityKey.public).toString('base64url'),
+        // e_skey_id: e_skey_id.toString('base64url'),
+        e_skey_id: 'AAAA',
+        e_skey_val: Buffer.from(params.signedPreKey.keyPair.public).toString('base64url'),
+        e_skey_sig: Buffer.from(params.signedPreKey.signature).toString('base64url'),
+        fdid: params.phoneId,
+        network_ratio_type: '1',
+        expid: params.deviceId,
+        simnum: '1',
+        hasinrc: '1',
+        pid: Math.floor(Math.random() * 1000).toString(),
+        id: convertBufferToUrlHex(params.identityId),
+        backup_token: convertBufferToUrlHex(params.backupToken),
+        token: (0, crypto_1.md5)(Buffer.concat([Defaults_1.MOBILE_TOKEN, Buffer.from(params.phoneNumberNationalNumber)])).toString('hex'),
+        fraud_checkpoint_code: params.captcha,
+    };
+}
+exports.registrationParams = registrationParams;
+/**
+ * Requests a registration code for the given phone number.
+ */
+function mobileRegisterCode(params, fetchOptions) {
+    return mobileRegisterFetch('/code', {
+        params: {
+            ...registrationParams(params),
+            mcc: `${params.phoneNumberMobileCountryCode}`.padStart(3, '0'),
+            mnc: `${params.phoneNumberMobileNetworkCode || '001'}`.padStart(3, '0'),
+            sim_mcc: '000',
+            sim_mnc: '000',
+            method: (params === null || params === void 0 ? void 0 : params.method) || 'sms',
+            reason: '',
+            hasav: '1'
+        },
+        ...fetchOptions,
+    });
+}
+exports.mobileRegisterCode = mobileRegisterCode;
+function mobileRegisterExists(params, fetchOptions) {
+    return mobileRegisterFetch('/exist', {
+        params: registrationParams(params),
+        ...fetchOptions
+    });
+}
+exports.mobileRegisterExists = mobileRegisterExists;
+/**
+ * Registers the phone number on whatsapp with the received OTP code.
+ */
+async function mobileRegister(params, fetchOptions) {
+    //const result = await mobileRegisterFetch(`/reg_onboard_abprop?cc=${params.phoneNumberCountryCode}&in=${params.phoneNumberNationalNumber}&rc=0`)
+    return mobileRegisterFetch('/register', {
+        params: { ...registrationParams(params), code: params.code.replace('-', '') },
+        ...fetchOptions,
+    });
+}
+exports.mobileRegister = mobileRegister;
+/**
+ * Encrypts the given string as AEAD aes-256-gcm with the public whatsapp key and a random keypair.
+ */
+function mobileRegisterEncrypt(data) {
+    const keypair = crypto_1.Curve.generateKeyPair();
+    const key = crypto_1.Curve.sharedKey(keypair.private, Defaults_1.REGISTRATION_PUBLIC_KEY);
+    const buffer = (0, crypto_1.aesEncryptGCM)(Buffer.from(data), new Uint8Array(key), Buffer.alloc(12), Buffer.alloc(0));
+    return Buffer.concat([Buffer.from(keypair.public), buffer]).toString('base64url');
+}
+exports.mobileRegisterEncrypt = mobileRegisterEncrypt;
+async function mobileRegisterFetch(path, opts = {}) {
+    let url = `${Defaults_1.MOBILE_REGISTRATION_ENDPOINT}${path}`;
+    if (opts.params) {
+        const parameter = [];
+        for (const param in opts.params) {
+            if (opts.params[param] !== null && opts.params[param] !== undefined) {
+                parameter.push(param + '=' + urlencode(opts.params[param]));
+            }
+        }
+        url += `?${parameter.join('&')}`;
+        delete opts.params;
+    }
+    if (!opts.headers) {
+        opts.headers = {};
+    }
+    opts.headers['User-Agent'] = Defaults_1.MOBILE_USERAGENT;
+    const response = await (0, axios_1.default)(url, opts);
+    var json = response.data;
+    if (response.status > 300 || json.reason) {
+        throw json;
+    }
+    if (json.status && !['ok', 'sent'].includes(json.status)) {
+        throw json;
+    }
+    return json;
+}
+exports.mobileRegisterFetch = mobileRegisterFetch;

package/lib/Socket/rich-content.js

@@ -0,0 +1,279 @@
+"use strict";
+// Ported & adapted from PouCode fork for AsepXyz Baileys.
+// Handles special sendMessage() content shapes: payment requests, product
+// cards, albums, events, poll results, orders, group status & labels.
+Object.defineProperty(exports, "__esModule", { value: true });
+const { proto } = require("../../WAProto");
+const crypto = require("crypto");
+
+class AsepXyzRichContent {
+    constructor(utils, waUploadToServer, relayMessageFn) {
+        this.utils = utils;
+        this.relayMessage = relayMessageFn;
+        this.waUploadToServer = waUploadToServer;
+    }
+
+    detectType(content) {
+        if (content.requestPaymentMessage) return 'PAYMENT';
+        if (content.productMessage) return 'PRODUCT';
+        if (content.eventMessage) return 'EVENT';
+        if (content.pollResultMessage) return 'POLL_RESULT';
+        if (content.orderMessage) return 'ORDER';
+        if (content.groupStatus) return 'GROUP_STATUS';
+        if (content.groupLabel) return 'GROUP_LABEL';
+        return null;
+    }
+
+    async handlePayment(content, quoted) {
+        const data = content.requestPaymentMessage;
+        let notes = {};
+
+        if (data.sticker?.stickerMessage) {
+            notes = {
+                stickerMessage: {
+                    ...data.sticker.stickerMessage,
+                    contextInfo: {
+                        stanzaId: quoted?.key?.id,
+                        participant: quoted?.key?.participant || content.sender,
+                        quotedMessage: quoted?.message
+                    }
+                }
+            };
+        } else if (data.note) {
+            notes = {
+                extendedTextMessage: {
+                    text: data.note,
+                    contextInfo: {
+                        stanzaId: quoted?.key?.id,
+                        participant: quoted?.key?.participant || content.sender,
+                        quotedMessage: quoted?.message
+                    }
+                }
+            };
+        }
+
+        return {
+            requestPaymentMessage: proto.Message.RequestPaymentMessage.fromObject({
+                expiryTimestamp: data.expiry || 0,
+                amount1000: data.amount || 0,
+                currencyCodeIso4217: data.currency || "IDR",
+                requestFrom: data.from || "0@s.whatsapp.net",
+                noteMessage: notes,
+                background: data.background ?? {
+                    id: "DEFAULT",
+                    placeholderArgb: 0xFFF0F0F0
+                }
+            })
+        };
+    }
+
+    async handleProduct(content, jid, quoted) {
+        const {
+            title,
+            description,
+            thumbnail,
+            productId,
+            retailerId,
+            url,
+            body = "",
+            footer = "",
+            buttons = [],
+            priceAmount1000 = null,
+            currencyCode = "IDR"
+        } = content.productMessage;
+
+        let productImage;
+
+        if (Buffer.isBuffer(thumbnail)) {
+            const { imageMessage } = await this.utils.generateWAMessageContent({ image: thumbnail }, { upload: this.waUploadToServer });
+            productImage = imageMessage;
+        } else if (typeof thumbnail === 'object' && thumbnail?.url) {
+            const { imageMessage } = await this.utils.generateWAMessageContent({ image: { url: thumbnail.url } }, { upload: this.waUploadToServer });
+            productImage = imageMessage;
+        }
+
+        return {
+            viewOnceMessage: {
+                message: {
+                    interactiveMessage: {
+                        body: { text: body },
+                        footer: { text: footer },
+                        header: {
+                            title,
+                            hasMediaAttachment: true,
+                            productMessage: {
+                                product: {
+                                    productImage,
+                                    productId,
+                                    title,
+                                    description,
+                                    currencyCode,
+                                    priceAmount1000,
+                                    retailerId,
+                                    url,
+                                    productImageCount: 1
+                                },
+                                businessOwnerJid: "0@s.whatsapp.net"
+                            }
+                        },
+                        nativeFlowMessage: { buttons }
+                    }
+                }
+            }
+        };
+    }
+
+    async handleEvent(content, jid, quoted) {
+        const eventData = content.eventMessage;
+
+        const msg = await this.utils.generateWAMessageFromContent(jid, {
+            viewOnceMessage: {
+                message: {
+                    messageContextInfo: {
+                        deviceListMetadata: {},
+                        deviceListMetadataVersion: 2,
+                        messageSecret: crypto.randomBytes(32),
+                        supportPayload: JSON.stringify({
+                            version: 2,
+                            is_ai_message: true,
+                            should_show_system_message: true,
+                            ticket_id: crypto.randomBytes(16).toString('hex')
+                        })
+                    },
+                    eventMessage: {
+                        contextInfo: {
+                            mentionedJid: [jid],
+                            participant: jid,
+                            remoteJid: "status@broadcast",
+                            forwardedNewsletterMessageInfo: {
+                                newsletterName: "AsepXyz",
+                                newsletterJid: eventData.newsletterJid || "0@newsletter",
+                                serverMessageId: 1
+                            }
+                        },
+                        isCanceled: eventData.isCanceled || false,
+                        name: eventData.name,
+                        description: eventData.description,
+                        location: eventData.location || {
+                            degreesLatitude: 0,
+                            degreesLongitude: 0,
+                            name: "Location"
+                        },
+                        joinLink: eventData.joinLink || '',
+                        startTime: typeof eventData.startTime === 'string' ? parseInt(eventData.startTime) : eventData.startTime || Date.now(),
+                        endTime: typeof eventData.endTime === 'string' ? parseInt(eventData.endTime) : eventData.endTime || Date.now() + 3600000,
+                        extraGuestsAllowed: eventData.extraGuestsAllowed !== false
+                    }
+                }
+            }
+        }, { quoted });
+
+        await this.relayMessage(jid, msg.message, { messageId: msg.key.id });
+        return msg;
+    }
+
+    async handlePollResult(content, jid, quoted) {
+        const pollData = content.pollResultMessage;
+        const msg = await this.utils.generateWAMessageFromContent(jid, {
+            pollResultSnapshotMessage: {
+                name: pollData.name,
+                pollVotes: pollData.pollVotes.map(vote => ({
+                    optionName: vote.optionName,
+                    optionVoteCount: typeof vote.optionVoteCount === 'number' ? vote.optionVoteCount.toString() : vote.optionVoteCount
+                })),
+                contextInfo: {
+                    isForwarded: true,
+                    forwardingScore: 1,
+                    forwardedNewsletterMessageInfo: {
+                        newsletterName: pollData.newsletter?.newsletterName || "AsepXyz",
+                        newsletterJid: pollData.newsletter?.newsletterJid || "0@newsletter",
+                        serverMessageId: 1000,
+                        contentType: "UPDATE"
+                    }
+                }
+            }
+        }, {
+            userJid: this.utils.generateMessageID().split('@')[0] + '@s.whatsapp.net',
+            quoted
+        });
+
+        await this.relayMessage(jid, msg.message, { messageId: msg.key.id });
+        return msg;
+    }
+
+    async handleOrderMessage(content, jid, quoted) {
+        const orderData = content.orderMessage;
+
+        const orderMsg = await this.utils.generateWAMessageFromContent(jid, {
+            orderMessage: {
+                orderId: orderData.orderId || ("ASEPXYZ" + Date.now()),
+                thumbnail: orderData.thumbnail || null,
+                itemCount: orderData.itemCount || 0,
+                status: "ACCEPTED",
+                surface: "CATALOG",
+                message: orderData.message,
+                orderTitle: orderData.orderTitle,
+                sellerJid: "0@whatsapp.net",
+                token: orderData.token || "ASEPXYZ_EXAMPLE_TOKEN",
+                totalAmount1000: orderData.totalAmount1000 || 0,
+                totalCurrencyCode: orderData.totalCurrencyCode || "IDR",
+                messageVersion: 2
+            }
+        }, { quoted });
+
+        await this.relayMessage(jid, orderMsg.message, {});
+        return orderMsg;
+    }
+
+    async handleGroupStory(content, jid, quoted) {
+        const storyData = content.groupStatus;
+        let messageContent;
+
+        if (storyData.message) {
+            messageContent = storyData;
+        } else {
+            messageContent = await this.utils.generateWAMessageContent(storyData, { upload: this.waUploadToServer });
+        }
+
+        const msg = {
+            message: {
+                groupStatusMessageV2: {
+                    message: messageContent.message || messageContent
+                }
+            }
+        };
+
+        return await this.relayMessage(jid, msg.message, { messageId: this.utils.generateMessageID() });
+    }
+
+    async handleGbLabel(content, jid) {
+        const x = content.groupLabel;
+        if (!jid.endsWith('@g.us')) {
+            throw new Error('group required!');
+        }
+
+        const msg = await this.utils.generateWAMessageFromContent(jid, {
+            protocolMessage: {
+                type: "GROUP_MEMBER_LABEL_CHANGE",
+                memberLabel: {
+                    label: x.labelText.slice(0, 30)
+                }
+            }
+        }, {});
+
+        await this.relayMessage(jid, msg.message, {
+            additionalNodes: [
+                {
+                    tag: 'meta',
+                    attrs: {
+                        tag_reason: 'user_update',
+                        appdata: 'member_tag'
+                    },
+                    content: undefined
+                }
+            ]
+        });
+    }
+}
+module.exports = AsepXyzRichContent;
+module.exports.default = AsepXyzRichContent;