@blckrose/baileys 1.0.0 → 1.0.5

package/lib/Utils/messages.js

@@ -365,13 +365,50 @@ export const generateWAMessageContent = async (message, options) => {
     else if (hasNonNullishProperty(message, 'pin')) {
         m.pinInChatMessage = {};
         m.messageContextInfo = {};
-        m.pinInChatMessage.key = message.pin;
-        m.pinInChatMessage.type = message.type;
-        m.pinInChatMessage.senderTimestampMs = Date.now();
-        m.messageContextInfo.messageAddOnDurationInSecs = message.type === 1 ? message.time || 86400 : 0;
+        m.pinInChatMessage.key = message.pin.key;
+        m.pinInChatMessage.type = message.pin?.type || 1;
+        m.pinInChatMessage.senderTimestampMs = message.pin?.time || Date.now();
+        m.messageContextInfo.messageAddOnDurationInSecs = message.pin.type === 1 ? message.pin.time || 86400 : 0;
+        m.messageContextInfo.messageAddOnExpiryType = proto.MessageContextInfo.MessageAddonExpiryType.STATIC;
+    }
+    else if (hasNonNullishProperty(message, 'keep')) {
+        m.keepInChatMessage = {};
+        m.keepInChatMessage.key = message.keep.key;
+        m.keepInChatMessage.keepType = message.keep?.type || 1;
+        m.keepInChatMessage.timestampMs = message.keep?.time || Date.now();
+    }
+    else if (hasNonNullishProperty(message, 'call')) {
+        m.scheduledCallCreationMessage = {};
+        m.scheduledCallCreationMessage.scheduledTimestampMs = message.call?.time || Date.now();
+        m.scheduledCallCreationMessage.callType = message.call?.type || 1;
+        m.scheduledCallCreationMessage.title = message.call?.name || 'Call Creation';
+        m.scheduledCallCreationMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+    }
+    else if (hasNonNullishProperty(message, 'paymentInvite')) {
+        m.messageContextInfo = {};
+        m.paymentInviteMessage = {};
+        m.paymentInviteMessage.expiryTimestamp = message.paymentInvite?.expiry || 0;
+        m.paymentInviteMessage.serviceType = message.paymentInvite?.type || 2;
+        m.paymentInviteMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
     }
     else if (hasNonNullishProperty(message, 'buttonReply')) {
         switch (message.type) {
+            case 'list':
+                m.listResponseMessage = {
+                    title: message.buttonReply.title,
+                    description: message.buttonReply.description,
+                    singleSelectReply: {
+                        selectedRowId: message.buttonReply.rowId
+                    },
+                    listType: proto.Message.ListResponseMessage.ListType.SINGLE_SELECT
+                };
+                break;
             case 'template':
                 m.templateButtonReplyMessage = {
                     selectedDisplayText: message.buttonReply.displayText,
@@ -386,7 +423,81 @@ export const generateWAMessageContent = async (message, options) => {
                     type: proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT
                 };
                 break;
+            case 'interactive':
+                m.interactiveResponseMessage = {
+                    body: {
+                        text: message.buttonReply.displayText,
+                        format: proto.Message.InteractiveResponseMessage.Body.Format.EXTENSIONS_1
+                    },
+                    nativeFlowResponseMessage: {
+                        name: message.buttonReply.nativeFlows.name,
+                        paramsJson: message.buttonReply.nativeFlows.paramsJson,
+                        version: message.buttonReply.nativeFlows.version
+                    }
+                };
+                break;
+        }
+    }
+    else if (hasNonNullishProperty(message, 'album')) {
+        const imageMessages = message.album.filter(item => 'image' in item);
+        const videoMessages = message.album.filter(item => 'video' in item);
+        m.albumMessage = WAProto.Message.AlbumMessage.fromObject({
+            expectedImageCount: imageMessages.length,
+            expectedVideoCount: videoMessages.length
+        });
+    }
+    else if (hasNonNullishProperty(message, 'order')) {
+        m.orderMessage = WAProto.Message.OrderMessage.fromObject(message.order);
+        m.orderMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+    }
+    else if (hasNonNullishProperty(message, 'payment')) {
+        const requestPaymentMessage = {
+            amount: {
+                currencyCode: message.payment?.currency || 'IDR',
+                offset: message.payment?.offset || 0,
+                value: message.payment?.amount || 999999999
+            },
+            expiryTimestamp: message.payment?.expiry || 0,
+            amount1000: (message.payment?.amount || 999999999) * 1000,
+            currencyCodeIso4217: message.payment?.currency || 'IDR',
+            requestFrom: message.payment?.from || '0@s.whatsapp.net',
+            noteMessage: {
+                extendedTextMessage: {
+                    text: message.payment?.note || 'Notes'
+                }
+            },
+            background: {
+                placeholderArgb: message.payment?.image?.placeholderArgb || 4278190080,
+                textArgb: message.payment?.image?.textArgb || 4294967295,
+                subtextArgb: message.payment?.image?.subtextArgb || 4294967295,
+                type: 1
+            }
+        };
+        requestPaymentMessage.noteMessage.extendedTextMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m.requestPaymentMessage = requestPaymentMessage;
+    }
+    else if (hasNonNullishProperty(message, 'pollResult')) {
+        if (!Array.isArray(message.pollResult.values)) {
+            throw new Boom('Invalid pollResult values', { statusCode: 400 });
         }
+        const pollResultSnapshotMessage = {
+            name: message.pollResult.name,
+            pollVotes: message.pollResult.values.map(([optionName, optionVoteCount]) => ({
+                optionName,
+                optionVoteCount
+            }))
+        };
+        pollResultSnapshotMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m.pollResultSnapshotMessage = pollResultSnapshotMessage;
     }
     else if (hasOptionalProperty(message, 'ptv') && message.ptv) {
         const { videoMessage } = await prepareWAMessageMedia({ video: message.video }, options);
@@ -482,8 +593,267 @@ export const generateWAMessageContent = async (message, options) => {
     else {
         m = await prepareWAMessageMedia(message, options);
     }
+    if ('sections' in message && !!message.sections) {
+        const listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            sections: message.sections,
+            listType: proto.Message.ListMessage.ListType.SINGLE_SELECT
+        };
+        listMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { listMessage };
+    }
+    else if ('productList' in message && !!message.productList) {
+        const thumbnail = message.thumbnail ? await generateThumbnail(message.thumbnail, 'image') : null;
+        const listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            productListInfo: {
+                productSections: message.productList,
+                headerImage: {
+                    productId: message.productList[0].products[0].productId,
+                    jpegThumbnail: thumbnail?.thumbnail || null
+                },
+                businessOwnerJid: message.businessOwnerJid
+            },
+            listType: proto.Message.ListMessage.ListType.PRODUCT_LIST
+        };
+        listMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { listMessage };
+    }
+    else if ('buttons' in message && !!message.buttons) {
+        const buttonsMessage = {
+            buttons: message.buttons.map(b => ({ ...b, type: proto.Message.ButtonsMessage.Button.Type.RESPONSE }))
+        };
+        if ('text' in message) {
+            buttonsMessage.contentText = message.text;
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.EMPTY;
+        }
+        else {
+            if ('caption' in message) {
+                buttonsMessage.contentText = message.caption;
+            }
+            const type = Object.keys(m)[0].replace('Message', '').toUpperCase();
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType[type];
+            Object.assign(buttonsMessage, m);
+        }
+        if ('footer' in message && !!message.footer) {
+            buttonsMessage.footerText = message.footer;
+        }
+        if ('title' in message && !!message.title) {
+            buttonsMessage.text = message.title;
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.TEXT;
+        }
+        buttonsMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { buttonsMessage };
+    }
+    else if ('templateButtons' in message && !!message.templateButtons) {
+        const hydratedTemplate = {
+            hydratedButtons: message.templateButtons
+        };
+        if ('text' in message) {
+            hydratedTemplate.hydratedContentText = message.text;
+        }
+        else {
+            if ('caption' in message) {
+                hydratedTemplate.hydratedContentText = message.caption;
+            }
+            Object.assign(hydratedTemplate, m);
+        }
+        if ('footer' in message && !!message.footer) {
+            hydratedTemplate.hydratedFooterText = message.footer;
+        }
+        hydratedTemplate.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { templateMessage: { fourRowTemplate: hydratedTemplate, hydratedTemplate } };
+    }
+    else if ('interactiveButtons' in message && !!message.interactiveButtons) {
+        const interactiveMessage = {
+            nativeFlowMessage: proto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
+                buttons: message.interactiveButtons,
+            })
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+        }
+        else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: message?.media ?? false,
+            };
+            Object.assign(interactiveMessage.header, m);
+        }
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        if ('title' in message && !!message.title) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: message?.media ?? false,
+            };
+            Object.assign(interactiveMessage.header, m);
+        }
+        if ('contextInfo' in message && !!message.contextInfo) {
+            interactiveMessage.contextInfo = message.contextInfo;
+        }
+        if ('mentions' in message && !!message.mentions) {
+            interactiveMessage.contextInfo = { mentionedJid: message.mentions };
+        }
+        m = { interactiveMessage };
+    }
+    else if ('shop' in message && !!message.shop) {
+        const interactiveMessage = {
+            shopStorefrontMessage: proto.Message.InteractiveMessage.ShopMessage.fromObject({
+                surface: message.shop,
+                id: message.id
+            })
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+        }
+        else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: message?.media ?? false,
+            };
+            Object.assign(interactiveMessage.header, m);
+        }
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        if ('title' in message && !!message.title) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: message?.media ?? false,
+            };
+            Object.assign(interactiveMessage.header, m);
+        }
+        if ('contextInfo' in message && !!message.contextInfo) {
+            interactiveMessage.contextInfo = message.contextInfo;
+        }
+        if ('mentions' in message && !!message.mentions) {
+            interactiveMessage.contextInfo = { mentionedJid: message.mentions };
+        }
+        m = { interactiveMessage };
+    }
+    else if ('collection' in message && !!message.collection) {
+        const interactiveMessage = {
+            collectionMessage: {
+                bizJid: message.collection.bizJid,
+                id: message.collection.id,
+                messageVersion: message?.collection?.version
+            }
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: false
+            };
+        }
+        else {
+            if ('caption' in message) {
+                interactiveMessage.body = { text: message.caption };
+                interactiveMessage.header = {
+                    title: message.title,
+                    subtitle: message.subtitle,
+                    hasMediaAttachment: message.hasMediaAttachment ? message.hasMediaAttachment : false,
+                    ...Object.assign(interactiveMessage, m)
+                };
+            }
+        }
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { interactiveMessage };
+    }
+    else if ('cards' in message && !!message.cards) {
+        const slides = await Promise.all(message.cards.map(async (slide) => {
+            const { image, video, product, title, body, footer, buttons } = slide;
+            let header;
+            if (product) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: product.productImage, ...options }, options);
+                header = {
+                    productMessage: {
+                        product: {
+                            ...product,
+                            productImage: imageMessage,
+                        },
+                        ...slide
+                    }
+                };
+            }
+            else if (image) {
+                header = await prepareWAMessageMedia({ image: image, ...options }, options);
+            }
+            else if (video) {
+                header = await prepareWAMessageMedia({ video: video, ...options }, options);
+            }
+            return {
+                header: {
+                    title,
+                    hasMediaAttachment: true,
+                    ...header
+                },
+                body: { text: body },
+                footer: { text: footer },
+                nativeFlowMessage: { buttons }
+            };
+        }));
+        const interactiveMessage = {
+            carouselMessage: { cards: slides }
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: false
+            };
+        }
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { interactiveMessage };
+    }
+    if (hasOptionalProperty(message, 'ephemeral') && !!message.ephemeral) {
+        m = { ephemeralMessage: { message: m } };
+    }
     if (hasOptionalProperty(message, 'viewOnce') && !!message.viewOnce) {
-        m = { viewOnceMessage: { message: m } };
+        m = { viewOnceMessageV2: { message: m } };
+    }
+    if (hasOptionalProperty(message, 'viewOnceExt') && !!message.viewOnceExt) {
+        m = { viewOnceMessageV2Extension: { message: m } };
     }
     if (hasOptionalProperty(message, 'mentions') && message.mentions?.length) {
         const messageType = Object.keys(m)[0];
@@ -867,4 +1237,72 @@ export const assertMediaContent = (content) => {
     }
     return mediaContent;
 };
+
+export const patchMessageForMdIfRequired = (message) => {
+    if (message?.buttonsMessage ||
+        message?.templateMessage ||
+        message?.listMessage ||
+        message?.interactiveMessage?.nativeFlowMessage
+    ) {
+        message = {
+            viewOnceMessageV2Extension: {
+                message: {
+                    messageContextInfo: {
+                        deviceListMetadataVersion: 2,
+                        deviceListMetadata: {}
+                    },
+                    ...message
+                }
+            }
+        };
+    }
+    return message;
+};
+export const prepareAlbumMessageContent = async (jid, albums, options) => {
+    let mediaHandle;
+    let mediaMsg;
+    const message = [];
+    const albumMsg = generateWAMessageFromContent(jid, {
+        albumMessage: {
+            expectedImageCount: albums.filter(item => 'image' in item).length,
+            expectedVideoCount: albums.filter(item => 'video' in item).length
+        }
+    }, options);
+    await options.sock.relayMessage(jid, albumMsg.message, { messageId: albumMsg.key.id });
+    for (const i in albums) {
+        const media = albums[i];
+        if ('image' in media) {
+            mediaMsg = await generateWAMessage(jid, { image: media.image, ...media, ...options }, {
+                userJid: options.userJid,
+                upload: async (encFilePath, opts) => {
+                    const up = await options.sock.waUploadToServer(encFilePath, { ...opts, newsletter: isJidNewsletter(jid) });
+                    mediaHandle = up.handle;
+                    return up;
+                },
+                ...options
+            });
+        } else if ('video' in media) {
+            mediaMsg = await generateWAMessage(jid, { video: media.video, ...media, ...options }, {
+                userJid: options.userJid,
+                upload: async (encFilePath, opts) => {
+                    const up = await options.sock.waUploadToServer(encFilePath, { ...opts, newsletter: isJidNewsletter(jid) });
+                    mediaHandle = up.handle;
+                    return up;
+                },
+                ...options
+            });
+        }
+        if (mediaMsg) {
+            mediaMsg.message.messageContextInfo = {
+                messageSecret: randomBytes(32),
+                messageAssociation: {
+                    associationType: 1,
+                    parentMessageKey: albumMsg.key
+                }
+            };
+        }
+        message.push(mediaMsg);
+    }
+    return message;
+};
 //# sourceMappingURL=messages.js.map

package/lib/Utils/streamToBuffer.js

@@ -0,0 +1,17 @@
+import { Readable } from 'stream';
+
+/**
+ * Mengonversi Node.js Readable Stream menjadi Buffer.
+ * @param {Readable} stream Aliran data yang dapat dibaca.
+ * @returns {Promise<Buffer>} Promise yang diselesaikan dengan Buffer berisi semua data dari aliran.
+ */
+async function streamToBuffer(stream) {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        stream.on('data', chunk => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        stream.on('end', () => resolve(Buffer.concat(chunks)));
+        stream.on('error', reject);
+    });
+}
+
+export { streamToBuffer };

package/lib/Utils/use-mongo-file-auth-state.js

@@ -0,0 +1,77 @@
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+
+/*
+code from amiruldev readjusted by @irull2nd, don't delete WM!
+*/
+export const useMongoFileAuthState = async (collection) => {
+    const writeData = (data, id) => {
+        const informationToStore = JSON.parse(
+            JSON.stringify(data, BufferJSON.replacer)
+        );
+        const update = {
+            $set: {
+                ...informationToStore,
+            },
+        };
+
+        return collection.updateOne({ _id: id }, update, { upsert: true });
+    };
+
+    const readData = async (id) => {
+        try {
+            const data = JSON.stringify(await collection.findOne({ _id: id }));
+            return JSON.parse(data, BufferJSON.reviver);
+        }
+        catch (err) {
+            console.log(err);
+        }
+    };
+
+    const removeData = async (id) => {
+        try {
+            await collection.deleteOne({ _id: id });
+        }
+        catch (err) {
+            console.log('error', err);
+        }
+    };
+
+    const creds = (await readData('creds')) || initAuthCreds();
+
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(
+                        ids.map(async (id) => {
+                            let value = await readData(`${type}-${id}`);
+                            if (type === 'app-state-sync-key') {
+                                value = proto.Message.AppStateSyncKeyData.fromObject(data);
+                            }
+                            data[id] = value;
+                        })
+                    );
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category of Object.keys(data)) {
+                        for (const id of Object.keys(data[category])) {
+                            const value = data[category][id];
+                            const key = `${category}-${id}`;
+                            tasks.push(value ? writeData(value, key) : removeData(key));
+                        }
+                    }
+                    await Promise.all(tasks);
+                },
+            },
+        },
+        saveCreds: () => {
+            return writeData(creds, 'creds');
+        }
+    };
+};

package/lib/Utils/use-single-file-auth-state.js

@@ -0,0 +1,74 @@
+import { createRequire } from 'module';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+
+const require = createRequire(import.meta.url);
+
+// useless key map only there to maintain backwards compatibility
+// do not use in your own systems please
+const KEY_MAP = {
+    'pre-key': 'preKeys',
+    'session': 'sessions',
+    'sender-key': 'senderKeys',
+    'app-state-sync-key': 'appStateSyncKeys',
+    'app-state-sync-version': 'appStateVersions',
+    'sender-key-memory': 'senderKeyMemory'
+};
+
+/**
+ * @deprecated use multi file auth state instead please
+ * stores the full authentication state in a single JSON file
+ *
+ * DO NOT USE IN A PROD ENVIRONMENT, only meant to serve as an example
+ * */
+export const useSingleFileAuthState = (filename, logger) => {
+    const { readFileSync, writeFileSync, existsSync } = require('fs');
+    let creds;
+    let keys = {};
+    // save the authentication state to a file
+    const saveState = () => {
+        logger && logger.trace('saving auth state');
+        writeFileSync(filename,
+            // BufferJSON replacer utility saves buffers nicely
+            JSON.stringify({ creds, keys }, BufferJSON.replacer, 2));
+    };
+    if (existsSync(filename)) {
+        const result = JSON.parse(readFileSync(filename, { encoding: 'utf-8' }), BufferJSON.reviver);
+        creds = result.creds;
+        keys = result.keys;
+    }
+    else {
+        creds = initAuthCreds();
+        keys = {};
+    }
+    return {
+        state: {
+            creds,
+            keys: {
+                get: (type, ids) => {
+                    const key = KEY_MAP[type];
+                    return ids.reduce((dict, id) => {
+                        let value = keys[key]?.[id];
+                        if (value) {
+                            if (type === 'app-state-sync-key') {
+                                value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            dict[id] = value;
+                        }
+                        return dict;
+                    }, {});
+                },
+                set: (data) => {
+                    for (const _key in data) {
+                        const key = KEY_MAP[_key];
+                        keys[key] = keys[key] || {};
+                        Object.assign(keys[key], data[_key]);
+                    }
+                    saveState();
+                }
+            }
+        },
+        saveState
+    };
+};

package/lib/WABinary/generic-utils.js

@@ -110,4 +110,19 @@ export function binaryNodeToString(node, i = 0) {
     const content = children ? `>\n${children}\n${tabs(i)}</${node.tag}>` : '/>';
     return tag + content;
 }
+
+export const getBinaryFilteredButtons = (nodeContent) => {
+    if (!Array.isArray(nodeContent)) return false;
+    return nodeContent.some(a =>
+        ['native_flow'].includes(a?.content?.[0]?.content?.[0]?.tag) ||
+        ['interactive', 'buttons', 'list'].includes(a?.content?.[0]?.tag) ||
+        ['hsm', 'biz'].includes(a?.tag)
+    );
+};
+export const getBinaryFilteredBizBot = (nodeContent) => {
+    if (!Array.isArray(nodeContent)) return false;
+    return nodeContent.some(b =>
+        ['bot'].includes(b?.tag) && b?.attrs?.biz_bot === '1'
+    );
+};
 //# sourceMappingURL=generic-utils.js.map

package/lib/WABinary/index.js

@@ -1,6 +1,7 @@
 export * from './encode.js';
 export * from './decode.js';
 export * from './generic-utils.js';
+export { getBinaryFilteredButtons, getBinaryFilteredBizBot } from './generic-utils.js';
 export * from './jid-utils.js';
 export * from './types.js';
 //# sourceMappingURL=index.js.map

package/lib/WABinary/jid-utils.js

@@ -93,4 +93,6 @@ export const transferDevice = (fromJid, toJid) => {
     const { server, user } = jidDecode(toJid);
     return jidEncode(user, server, deviceId);
 };
+
+export const isJidUser = (jid) => jid?.endsWith('@s.whatsapp.net');
 //# sourceMappingURL=jid-utils.js.map