@kanaraa/baileys 3.4.0 → 3.4.2

package/lib/Defaults/levvleys-version.json

@@ -0,0 +1,3 @@
+{
+    "version": [2, 3000, 1043857760]
+}

package/lib/Signal/Group/queue-job.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queueJob;
+const _queueAsyncBuckets = new Map();
+const _gcLimit = 10000;
+async function _asyncQueueExecutor(queue, cleanup) {
+    let offt = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const limit = Math.min(queue.length, _gcLimit);
+        for (let i = offt; i < limit; i++) {
+            const job = queue[i];
+            try {
+                job.resolve(await job.awaitable());
+            }
+            catch (e) {
+                job.reject(e);
+            }
+        }
+        if (limit < queue.length) {
+            if (limit >= _gcLimit) {
+                queue.splice(0, limit);
+                offt = 0;
+            }
+            else {
+                offt = limit;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    cleanup();
+}
+function queueJob(bucket, awaitable) {
+    // Skip name assignment since it's readonly in strict mode
+    if (typeof bucket !== 'string') {
+        console.warn('Unhandled bucket type (for naming):', typeof bucket, bucket);
+    }
+    let inactive = false;
+    if (!_queueAsyncBuckets.has(bucket)) {
+        _queueAsyncBuckets.set(bucket, []);
+        inactive = true;
+    }
+    const queue = _queueAsyncBuckets.get(bucket);
+    const job = new Promise((resolve, reject) => {
+        queue.push({
+            awaitable,
+            resolve: resolve,
+            reject
+        });
+    });
+    if (inactive) {
+        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
+    }
+    return job;
+}

package/lib/Socket/messages-send.js

@@ -1165,6 +1165,27 @@ export const makeMessagesSocket = (config) => {
                     statusJidList: options.statusJidList,
                     additionalNodes
                 });
+
+                if (content && typeof content === 'object' && 'richMessage' in content && content.richMessage?.bypassDownload !== false) {
+                    const editMsg = {
+                        botForwardedMessage: {
+                            message: {
+                                protocolMessage: {
+                                    key: {
+                                        remoteJid: jid,
+                                        fromMe: true,
+                                        id: fullMsg.key.id
+                                    },
+                                    type: 14,
+                                    editedMessage: fullMsg.message
+                                }
+                            }
+                        }
+                    };
+                    await relayMessage(jid, editMsg, {
+                        messageId: generateMessageIDV2(authState.creds.me.id)
+                    });
+                }
                 if (config.emitOwnEvents) {
                     process.nextTick(async () => {
                         await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));

package/lib/Socket/usync.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUSyncSocket = void 0;
+const boom_1 = require("@hapi/boom");
+const WABinary_1 = require("../WABinary");
+const socket_1 = require("./socket");
+const makeUSyncSocket = (config) => {
+    const sock = (0, socket_1.makeSocket)(config);
+    const { generateMessageTag, query, } = sock;
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.Boom('USyncQuery must have at least one protocol');
+        }
+        // todo: validate users, throw WARNING on no valid users
+        // variable below has only validated users
+        const validUsers = usyncQuery.users;
+        const userNodes = validUsers.map((user) => {
+            return {
+                tag: 'user',
+                attrs: {
+                    jid: !user.phone ? user.id : undefined,
+                },
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
+            };
+        });
+        const listNode = {
+            tag: 'list',
+            attrs: {},
+            content: userNodes
+        };
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        };
+        const iq = {
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'usync',
+            },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0',
+                    },
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
+                }
+            ],
+        };
+        const result = await query(iq);
+        return usyncQuery.parseUSyncQueryResult(result);
+    };
+    return {
+        ...sock,
+        executeUSyncQuery,
+    };
+};
+exports.makeUSyncSocket = makeUSyncSocket;

package/lib/Store/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeInMemoryStore = void 0;
+const make_in_memory_store_1 = __importDefault(require("./make-in-memory-store"));
+exports.makeInMemoryStore = make_in_memory_store_1.default;

package/lib/Store/make-in-memory-store.js

@@ -0,0 +1,439 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waLabelAssociationKey = exports.waMessageID = exports.waChatKey = void 0;
+const WAProto_1 = require("../../WAProto");
+const Defaults_1 = require("../Defaults");
+const LabelAssociation_1 = require("../Types/LabelAssociation");
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+const make_ordered_dictionary_1 = __importDefault(require("./make-ordered-dictionary"));
+const object_repository_1 = require("./object-repository");
+const waChatKey = (pin) => ({
+    key: (c) => (pin ? (c.pinned ? '1' : '0') : '') + (c.archived ? '0' : '1') + (c.conversationTimestamp ? c.conversationTimestamp.toString(16).padStart(8, '0') : '') + c.id,
+    compare: (k1, k2) => k2.localeCompare(k1)
+});
+exports.waChatKey = waChatKey;
+const waMessageID = (m) => m.key.id || '';
+exports.waMessageID = waMessageID;
+exports.waLabelAssociationKey = {
+    key: (la) => (la.type === LabelAssociation_1.LabelAssociationType.Chat ? la.chatId + la.labelId : la.chatId + la.messageId + la.labelId),
+    compare: (k1, k2) => k2.localeCompare(k1)
+};
+const makeMessagesDictionary = () => (0, make_ordered_dictionary_1.default)(exports.waMessageID);
+exports.default = (config) => {
+    const socket = config.socket;
+    const chatKey = config.chatKey || (0, exports.waChatKey)(true);
+    const labelAssociationKey = config.labelAssociationKey || exports.waLabelAssociationKey;
+    const logger = config.logger || Defaults_1.DEFAULT_CONNECTION_CONFIG.logger.child({ stream: 'in-mem-store' });
+    const KeyedDB = require('@adiwajshing/keyed-db').default;
+    const chats = new KeyedDB(chatKey, c => c.id);
+    const messages = {};
+    const contacts = {};
+    const groupMetadata = {};
+    const presences = {};
+    const state = { connection: 'close' };
+    const labels = new object_repository_1.ObjectRepository();
+    const labelAssociations = new KeyedDB(labelAssociationKey, labelAssociationKey.key);
+    const assertMessageList = (jid) => {
+        if (!messages[jid]) {
+            messages[jid] = makeMessagesDictionary();
+        }
+        return messages[jid];
+    };
+    const contactsUpsert = (newContacts) => {
+        const oldContacts = new Set(Object.keys(contacts));
+        for (const contact of newContacts) {
+            oldContacts.delete(contact.id);
+            contacts[contact.id] = Object.assign(contacts[contact.id] || {}, contact);
+        }
+        return oldContacts;
+    };
+    const labelsUpsert = (newLabels) => {
+        for (const label of newLabels) {
+            labels.upsertById(label.id, label);
+        }
+    };
+    const getValidContacts = () => {
+        for (const contact of Object.keys(contacts)) {
+            if (contact.indexOf('@') < 0) {
+                delete contacts[contact];
+            }
+        }
+        return Object.keys(contacts);
+    };
+    /**
+     * binds to a WileysEventEmitter.
+     * It listens to all events and constructs a state that you can query accurate data from.
+     * Eg. can use the store to fetch chats, contacts, messages etc.
+     * @param ev typically the event emitter from the socket connection
+     */
+    const bind = (ev) => {
+        ev.on('connection.update', update => {
+            Object.assign(state, update);
+        });
+        ev.on('messaging-history.set', ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
+            if (syncType === WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND) {
+                return; // FOR NOW,
+                //TODO: HANDLE
+            }
+            if (isLatest) {
+                chats.clear();
+                for (const id in messages) {
+                    delete messages[id];
+                }
+            }
+            const chatsAdded = chats.insertIfAbsent(...newChats).length;
+            logger.debug({ chatsAdded }, 'synced chats');
+            const oldContacts = contactsUpsert(newContacts);
+            if (isLatest) {
+                for (const jid of oldContacts) {
+                    delete contacts[jid];
+                }
+            }
+            logger.debug({ deletedContacts: isLatest ? oldContacts.size : 0, newContacts }, 'synced contacts');
+            for (const msg of newMessages) {
+                const jid = msg.key.remoteJid;
+                const list = assertMessageList(jid);
+                list.upsert(msg, 'prepend');
+            }
+            logger.debug({ messages: newMessages.length }, 'synced messages');
+        });
+        ev.on('contacts.upsert', contacts => {
+            contactsUpsert(contacts);
+        });
+        ev.on('contacts.update', async (updates) => {
+            var _a;
+            for (const update of updates) {
+                let contact;
+                if (contacts[update.id]) {
+                    contact = contacts[update.id];
+                }
+                else {
+                    const validContacts = getValidContacts();
+                    const contactHashes = validContacts.map((contactId) => {
+                        const { user } = (0, WABinary_1.jidDecode)(contactId);
+                        return [contactId, ((0, Utils_1.md5)(Buffer.from(user + 'WA_ADD_NOTIF', 'utf8'))).toString('base64').slice(0, 3)];
+                    });
+                    contact = contacts[((_a = contactHashes.find(([, b]) => b === update.id)) === null || _a === void 0 ? void 0 : _a[0]) || '']; // find contact by attrs.hash, when user is not saved as a contact
+                }
+                if (contact) {
+                    if (update.imgUrl === 'changed') {
+                        contact.imgUrl = socket ? await (socket === null || socket === void 0 ? void 0 : socket.profilePictureUrl(contact.id)) : undefined;
+                    }
+                    else if (update.imgUrl === 'removed') {
+                        delete contact.imgUrl;
+                    }
+                    Object.assign(contacts[contact.id], contact);
+                }
+                else {
+                    logger.debug({ update }, 'got update for non-existant contact');
+                }
+            }
+        });
+        ev.on('chats.upsert', newChats => {
+            chats.upsert(...newChats);
+        });
+        ev.on('chats.update', updates => {
+            for (let update of updates) {
+                const result = chats.update(update.id, chat => {
+                    if (update.unreadCount > 0) {
+                        update = { ...update };
+                        update.unreadCount = (chat.unreadCount || 0) + update.unreadCount;
+                    }
+                    Object.assign(chat, update);
+                });
+                if (!result) {
+                    logger.debug({ update }, 'got update for non-existant chat');
+                }
+            }
+        });
+        ev.on('labels.edit', (label) => {
+            if (label.deleted) {
+                return labels.deleteById(label.id);
+            }
+            // WhatsApp can store only up to 20 labels
+            if (labels.count() < 20) {
+                return labels.upsertById(label.id, label);
+            }
+            logger.error('Labels count exceed');
+        });
+        ev.on('labels.association', ({ type, association }) => {
+            switch (type) {
+                case 'add':
+                    labelAssociations.upsert(association);
+                    break;
+                case 'remove':
+                    labelAssociations.delete(association);
+                    break;
+                default:
+                    console.error(`unknown operation type [${type}]`);
+            }
+        });
+        ev.on('presence.update', ({ id, presences: update }) => {
+            presences[id] = presences[id] || {};
+            Object.assign(presences[id], update);
+        });
+        ev.on('chats.delete', deletions => {
+            for (const item of deletions) {
+                if (chats.get(item)) {
+                    chats.deleteById(item);
+                }
+            }
+        });
+        ev.on('messages.upsert', ({ messages: newMessages, type }) => {
+            switch (type) {
+                case 'append':
+                case 'notify':
+                    for (const msg of newMessages) {
+                        const jid = (0, WABinary_1.jidNormalizedUser)(msg.key.remoteJid);
+                        const list = assertMessageList(jid);
+                        list.upsert(msg, 'append');
+                        if (type === 'notify' && !chats.get(jid)) {
+                            ev.emit('chats.upsert', [
+                                {
+                                    id: jid,
+                                    conversationTimestamp: (0, Utils_1.toNumber)(msg.messageTimestamp),
+                                    unreadCount: 1
+                                }
+                            ]);
+                        }
+                    }
+                    break;
+            }
+        });
+        ev.on('messages.update', updates => {
+            var _a;
+            for (const { update, key } of updates) {
+                const list = assertMessageList((0, WABinary_1.jidNormalizedUser)(key.remoteJid));
+                if (update === null || update === void 0 ? void 0 : update.status) {
+                    const listStatus = (_a = list.get(key.id)) === null || _a === void 0 ? void 0 : _a.status;
+                    if (listStatus && (update === null || update === void 0 ? void 0 : update.status) <= listStatus) {
+                        logger.debug({ update, storedStatus: listStatus }, 'status stored newer then update');
+                        delete update.status;
+                        logger.debug({ update }, 'new update object');
+                    }
+                }
+                const result = list.updateAssign(key.id, update);
+                if (!result) {
+                    logger.debug({ update }, 'got update for non-existent message');
+                }
+            }
+        });
+        ev.on('messages.delete', item => {
+            if ('all' in item) {
+                const list = messages[item.jid];
+                list === null || list === void 0 ? void 0 : list.clear();
+            }
+            else {
+                const jid = item.keys[0].remoteJid;
+                const list = messages[jid];
+                if (list) {
+                    const idSet = new Set(item.keys.map(k => k.id));
+                    list.filter(m => !idSet.has(m.key.id));
+                }
+            }
+        });
+        ev.on('groups.update', updates => {
+            for (const update of updates) {
+                const id = update.id;
+                if (groupMetadata[id]) {
+                    Object.assign(groupMetadata[id], update);
+                }
+                else {
+                    logger.debug({ update }, 'got update for non-existant group metadata');
+                }
+            }
+        });
+        ev.on('group-participants.update', ({ id, participants, action }) => {
+            const metadata = groupMetadata[id];
+            if (metadata) {
+                switch (action) {
+                    case 'add':
+                        metadata.participants.push(...participants.map(id => ({ id, isAdmin: false, isSuperAdmin: false })));
+                        break;
+                    case 'demote':
+                    case 'promote':
+                        for (const participant of metadata.participants) {
+                            if (participants.includes(participant.id)) {
+                                participant.isAdmin = action === 'promote';
+                            }
+                        }
+                        break;
+                    case 'remove':
+                        metadata.participants = metadata.participants.filter(p => !participants.includes(p.id));
+                        break;
+                }
+            }
+        });
+        ev.on('message-receipt.update', updates => {
+            for (const { key, receipt } of updates) {
+                const obj = messages[key.remoteJid];
+                const msg = obj === null || obj === void 0 ? void 0 : obj.get(key.id);
+                if (msg) {
+                    (0, Utils_1.updateMessageWithReceipt)(msg, receipt);
+                }
+            }
+        });
+        ev.on('messages.reaction', (reactions) => {
+            for (const { key, reaction } of reactions) {
+                const obj = messages[key.remoteJid];
+                const msg = obj === null || obj === void 0 ? void 0 : obj.get(key.id);
+                if (msg) {
+                    (0, Utils_1.updateMessageWithReaction)(msg, reaction);
+                }
+            }
+        });
+    };
+    const toJSON = () => ({
+        chats,
+        contacts,
+        messages,
+        labels,
+        labelAssociations
+    });
+    const fromJSON = (json) => {
+        chats.upsert(...json.chats);
+        labelAssociations.upsert(...json.labelAssociations || []);
+        contactsUpsert(Object.values(json.contacts));
+        labelsUpsert(Object.values(json.labels || {}));
+        for (const jid in json.messages) {
+            const list = assertMessageList(jid);
+            for (const msg of json.messages[jid]) {
+                list.upsert(WAProto_1.proto.WebMessageInfo.fromObject(msg), 'append');
+            }
+        }
+    };
+    return {
+        chats,
+        contacts,
+        messages,
+        groupMetadata,
+        state,
+        presences,
+        labels,
+        labelAssociations,
+        bind,
+        /** loads messages from the store, if not found -- uses the legacy connection */
+        loadMessages: async (jid, count, cursor) => {
+            const list = assertMessageList(jid);
+            const mode = !cursor || 'before' in cursor ? 'before' : 'after';
+            const cursorKey = !!cursor ? ('before' in cursor ? cursor.before : cursor.after) : undefined;
+            const cursorValue = cursorKey ? list.get(cursorKey.id) : undefined;
+            let messages;
+            if (list && mode === 'before' && (!cursorKey || cursorValue)) {
+                if (cursorValue) {
+                    const msgIdx = list.array.findIndex(m => m.key.id === (cursorKey === null || cursorKey === void 0 ? void 0 : cursorKey.id));
+                    messages = list.array.slice(0, msgIdx);
+                }
+                else {
+                    messages = list.array;
+                }
+                const diff = count - messages.length;
+                if (diff < 0) {
+                    messages = messages.slice(-count); // get the last X messages
+                }
+            }
+            else {
+                messages = [];
+            }
+            return messages;
+        },
+        /**
+         * Get all available labels for profile
+         *
+         * Keep in mind that the list is formed from predefined tags and tags
+         * that were "caught" during their editing.
+         */
+        getLabels: () => {
+            return labels;
+        },
+        /**
+         * Get labels for chat
+         *
+         * @returns Label IDs
+         **/
+        getChatLabels: (chatId) => {
+            return labelAssociations.filter((la) => la.chatId === chatId).all();
+        },
+        /**
+         * Get labels for message
+         *
+         * @returns Label IDs
+         **/
+        getMessageLabels: (messageId) => {
+            const associations = labelAssociations
+                .filter((la) => la.messageId === messageId)
+                .all();
+            return associations.map(({ labelId }) => labelId);
+        },
+        loadMessage: async (jid, id) => { var _a; return (_a = messages[jid]) === null || _a === void 0 ? void 0 : _a.get(id); },
+        mostRecentMessage: async (jid) => {
+            var _a;
+            const message = (_a = messages[jid]) === null || _a === void 0 ? void 0 : _a.array.slice(-1)[0];
+            return message;
+        },
+        fetchImageUrl: async (jid, sock) => {
+            const contact = contacts[jid];
+            if (!contact) {
+                return sock === null || sock === void 0 ? void 0 : sock.profilePictureUrl(jid);
+            }
+            if (typeof contact.imgUrl === 'undefined') {
+                contact.imgUrl = await (sock === null || sock === void 0 ? void 0 : sock.profilePictureUrl(jid));
+            }
+            return contact.imgUrl;
+        },
+        fetchGroupMetadata: async (jid, sock) => {
+            if (!groupMetadata[jid]) {
+                const metadata = await (sock === null || sock === void 0 ? void 0 : sock.groupMetadata(jid));
+                if (metadata) {
+                    groupMetadata[jid] = metadata;
+                }
+            }
+            return groupMetadata[jid];
+        },
+        // fetchBroadcastListInfo: async(jid: string, sock: WASocket | undefined) => {
+        // 	if(!groupMetadata[jid]) {
+        // 		const metadata = await sock?.getBroadcastListInfo(jid)
+        // 		if(metadata) {
+        // 			groupMetadata[jid] = metadata
+        // 		}
+        // 	}
+        // 	return groupMetadata[jid]
+        // },
+        fetchMessageReceipts: async ({ remoteJid, id }) => {
+            const list = messages[remoteJid];
+            const msg = list === null || list === void 0 ? void 0 : list.get(id);
+            return msg === null || msg === void 0 ? void 0 : msg.userReceipt;
+        },
+        toJSON,
+        fromJSON,
+        writeToFile: (path) => {
+            // require fs here so that in case "fs" is not available -- the app does not crash
+            const { writeFileSync } = require('fs');
+            writeFileSync(path, JSON.stringify(toJSON()));
+        },
+        readFromFile: (path) => {
+            // require fs here so that in case "fs" is not available -- the app does not crash
+            const { readFileSync, existsSync } = require('fs');
+            if (existsSync(path)) {
+                logger.debug({ path }, 'reading from file');
+                try {
+                    const jsonStr = readFileSync(path, { encoding: 'utf-8' });
+                    if (jsonStr.trim().length) {
+                        const json = JSON.parse(jsonStr);
+                        fromJSON(json);
+                    }
+                    else {
+                        logger.warn({ path }, 'skipping empty json file');
+                    }
+                }
+                catch (err) {
+                    logger.warn({ path, err }, 'failed to parse json from file');
+                }
+            }
+        }
+    };
+};

package/lib/Store/make-ordered-dictionary.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function makeOrderedDictionary(idGetter) {
+    const array = [];
+    const dict = {};
+    const get = (id) => dict[id];
+    const update = (item) => {
+        const id = idGetter(item);
+        const idx = array.findIndex(i => idGetter(i) === id);
+        if (idx >= 0) {
+            array[idx] = item;
+            dict[id] = item;
+        }
+        return false;
+    };
+    const upsert = (item, mode) => {
+        const id = idGetter(item);
+        if (get(id)) {
+            update(item);
+        }
+        else {
+            if (mode === 'append') {
+                array.push(item);
+            }
+            else {
+                array.splice(0, 0, item);
+            }
+            dict[id] = item;
+        }
+    };
+    const remove = (item) => {
+        const id = idGetter(item);
+        const idx = array.findIndex(i => idGetter(i) === id);
+        if (idx >= 0) {
+            array.splice(idx, 1);
+            delete dict[id];
+            return true;
+        }
+        return false;
+    };
+    return {
+        array,
+        get,
+        upsert,
+        update,
+        remove,
+        updateAssign: (id, update) => {
+            const item = get(id);
+            if (item) {
+                Object.assign(item, update);
+                delete dict[id];
+                dict[idGetter(item)] = item;
+                return true;
+            }
+            return false;
+        },
+        clear: () => {
+            array.splice(0, array.length);
+            for (const key of Object.keys(dict)) {
+                delete dict[key];
+            }
+        },
+        filter: (contain) => {
+            let i = 0;
+            while (i < array.length) {
+                if (!contain(array[i])) {
+                    delete dict[idGetter(array[i])];
+                    array.splice(i, 1);
+                }
+                else {
+                    i += 1;
+                }
+            }
+        },
+        toJSON: () => array,
+        fromJSON: (newItems) => {
+            array.splice(0, array.length, ...newItems);
+        }
+    };
+}
+exports.default = makeOrderedDictionary;

package/lib/Store/object-repository.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectRepository = void 0;
+class ObjectRepository {
+    constructor(entities = {}) {
+        this.entityMap = new Map(Object.entries(entities));
+    }
+    findById(id) {
+        return this.entityMap.get(id);
+    }
+    findAll() {
+        return Array.from(this.entityMap.values());
+    }
+    upsertById(id, entity) {
+        return this.entityMap.set(id, { ...entity });
+    }
+    deleteById(id) {
+        return this.entityMap.delete(id);
+    }
+    count() {
+        return this.entityMap.size;
+    }
+    toJSON() {
+        return this.findAll();
+    }
+}
+exports.ObjectRepository = ObjectRepository;

package/lib/Types/Newsletter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XWAPaths = exports.MexOperations = void 0;
+var MexOperations;
+(function (MexOperations) {
+    MexOperations["PROMOTE"] = "NotificationNewsletterAdminPromote";
+    MexOperations["DEMOTE"] = "NotificationNewsletterAdminDemote";
+    MexOperations["UPDATE"] = "NotificationNewsletterUpdate";
+})(MexOperations || (exports.MexOperations = MexOperations = {}));
+var XWAPaths;
+(function (XWAPaths) {
+    XWAPaths["PROMOTE"] = "xwa2_notify_newsletter_admin_promote";
+    XWAPaths["DEMOTE"] = "xwa2_notify_newsletter_admin_demote";
+    XWAPaths["ADMIN_COUNT"] = "xwa2_newsletter_admin";
+    XWAPaths["CREATE"] = "xwa2_newsletter_create";
+    XWAPaths["NEWSLETTER"] = "xwa2_newsletter";
+    XWAPaths["METADATA_UPDATE"] = "xwa2_notify_newsletter_on_metadata_update";
+})(XWAPaths || (exports.XWAPaths = XWAPaths = {}));

package/lib/Utils/levvleys-event-stream.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAndEmitEventStream = exports.captureEventStream = void 0;
+const events_1 = __importDefault(require("events"));
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const readline_1 = require("readline");
+const generics_1 = require("./generics");
+const make_mutex_1 = require("./make-mutex");
+/**
+ * Captures events from a wileys event emitter & stores them in a file
+ * @param ev The event emitter to read events from
+ * @param filename File to save to
+ */
+const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit;
+    // write mutex so data is appended in order
+    const writeMutex = (0, make_mutex_1.makeMutex)();
+    // monkey patch eventemitter to capture all events
+    ev.emit = function (...args) {
+        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n';
+        const result = oldEmit.apply(ev, args);
+        writeMutex.mutex(async () => {
+            await (0, promises_1.writeFile)(filename, content, { flag: 'a' });
+        });
+        return result;
+    };
+};
+exports.captureEventStream = captureEventStream;
+/**
+ * Read event file and emit events from there
+ * @param filename filename containing event data
+ * @param delayIntervalMs delay between each event emit
+ */
+const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new events_1.default();
+    const fireEvents = async () => {
+        // from: https://stackoverflow.com/questions/6156501/read-a-file-one-line-at-a-time-in-node-js
+        const fileStream = (0, fs_1.createReadStream)(filename);
+        const rl = (0, readline_1.createInterface)({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+        // Note: we use the crlfDelay option to recognize all instances of CR LF
+        // ('\r\n') in input.txt as a single line break.
+        for await (const line of rl) {
+            if (line) {
+                const { event, data } = JSON.parse(line);
+                ev.emit(event, data);
+                delayIntervalMs && await (0, generics_1.delay)(delayIntervalMs);
+            }
+        }
+        fileStream.close();
+    };
+    return {
+        ev,
+        task: fireEvents()
+    };
+};
+exports.readAndEmitEventStream = readAndEmitEventStream;

package/lib/Utils/messages.js

@@ -1658,6 +1658,32 @@ export const generateWAMessageContent = async (message, options) => {
       sections.push(newLayout(layout, suggest.length === 1 ? suggest[0] : suggest));
     }
 
+    if (rich.widget) {
+      const w = rich.widget;
+      sections.push(newLayout('Single', {
+        title: w.title ?? '',
+        sections: w.sections ?? [],
+        actions: (w.actions ?? []).map(a => ({
+          label: a.label ?? '',
+          kind: a.kind ?? 'OTHER',
+          state: a.state ?? 'PENDING',
+          id: a.id ?? ''
+        })),
+        __typename: 'GenAIWidgetCardPrimitive'
+      }));
+    }
+
+    if (rich.footerAction || rich.footerBtn) {
+      const fa = rich.footerAction || rich.footerBtn;
+      sections.push(newLayout('Single', {
+        action: {
+          text: fa.text ?? '',
+          url: fa.url ?? ''
+        },
+        __typename: 'GenAIFooterActionPrimitive'
+      }));
+    }
+
     if (rich.footer) {
       sections.push(newLayout('Single', { text: rich.footer, __typename: 'GenAIMetadataTextPrimitive' }));
     }
@@ -1673,17 +1699,53 @@ export const generateWAMessageContent = async (message, options) => {
       }));
     }
 
+    if (rich.customSections && Array.isArray(rich.customSections)) {
+      sections.push(...rich.customSections);
+    }
+
+    const generateVerificationMetadata = () => {
+      const signatureMaterial = Buffer.from(
+        'NIXEL.MessageBuilderV4.7-VerificationSignature.Metadata'
+      );
+      const certificateMaterial = Buffer.from(
+        'NIXEL.MessageBuilderV4.7-CertificateChain.Metadata'
+      );
+      const signature = Buffer.concat([
+        signatureMaterial,
+        randomBytes(64 - signatureMaterial.length)
+      ]).toString('base64');
+      const certificateChain = [
+        Buffer.concat([certificateMaterial, randomBytes(684 - certificateMaterial.length)]).toString('base64'),
+        Buffer.concat([certificateMaterial, randomBytes(892 - certificateMaterial.length)]).toString('base64')
+      ];
+      return {
+        proofs: [
+          {
+            version: 1,
+            useCase: 1,
+            signature,
+            certificateChain
+          }
+        ]
+      };
+    };
+
     const [resolvedSections, resolvedSubmessages] = await Promise.all([
       Toolkit.waitAllPromises(sections),
       Toolkit.waitAllPromises(submessages)
     ]);
 
+    const unifiedJsonStr = JSON.stringify({ response_id: randomUUID(), sections: resolvedSections });
+    const unifiedDataBase64 = Buffer.from(unifiedJsonStr).toString('base64');
+
     m = {
       messageContextInfo: {
         deviceListMetadata: {},
         deviceListMetadataVersion: 2,
         botMetadata: {
           messageDisclaimerText: rich.title ?? '',
+          verificationMetadata: generateVerificationMetadata(),
+          botResponseId: randomUUID(),
           richResponseSourcesMetadata: { sources: richResponseSources }
         }
       },
@@ -1693,12 +1755,12 @@ export const generateWAMessageContent = async (message, options) => {
             messageType: 1,
             submessages: resolvedSubmessages,
             unifiedResponse: {
-              data: Buffer.from(JSON.stringify({ response_id: randomUUID(), sections: resolvedSections })).toString('base64')
+              data: unifiedDataBase64
             },
             contextInfo: {
               forwardingScore: 1,
               isForwarded: true,
-              forwardedAiBotMessageInfo: { botJid: '0@bot' },
+              forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
               forwardOrigin: 4,
               ...(rich.contextInfo ?? {})
             }
@@ -1991,7 +2053,7 @@ export const generateWAMessageFromContent = (jid, message, options) => {
     }
   }
 
-  if (key !== "protocolMessage" && key !== "ephemeralMessage" && !isJidNewsletter(jid)) {
+    if (key !== "protocolMessage" && key !== "ephemeralMessage" && key !== "botForwardedMessage" && !isJidNewsletter(jid)) {
     message.messageContextInfo = {
       threadId: threadId.length > 0 ? threadId : [],
       messageSecret: randomBytes(32),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kanaraa/baileys",
   "type": "module",
-  "version": "3.4.0",
+  "version": "3.4.2",
   "description": "Modded Baileys v7, Rebuilt on top of official @whiskeysockets/baileys 7.0.0-rc13, with the interactive & rich-message content types (buttons, lists, carousel, cards, shop/collection, native flow, AI rich response, sticker packs, admin invite, payments, etc.).",
   "keywords": [
     "whatsapp",