@alannxd/baileys 2.1.3 → 3.0.0

package/lib/Socket/dugong.d.ts

@@ -58,26 +58,67 @@ declare namespace kikyy {
     interface ProductMessage {
         title: string;
         description: string;
-        thumbnail: string;
+        thumbnail: Buffer | { url: string };
         productId: string;
         retailerId: string;
         url: string;
         body?: string;
         footer?: string;
         buttons?: proto.Message.InteractiveMessage.INativeFlowButton[];
+        priceAmount1000?: number | null;
+        currencyCode?: string;
     }
 
     interface InteractiveMessage {
+        header?: string;
         title: string;
         footer?: string;
         thumbnail?: string;
+        image?: string | Buffer | { url: string };
+        video?: string | Buffer | { url: string };
+        document?: string | Buffer | { url: string };
+        mimetype?: string;
+        fileName?: string;
+        jpegThumbnail?: string | Buffer | { url: string };
+        contextInfo?: {
+            mentionedJid?: string[];
+            forwardingScore?: number;
+            isForwarded?: boolean;
+            externalAdReply?: {
+                title?: string;
+                body?: string;
+                mediaType?: number;
+                thumbnailUrl?: string;
+                mediaUrl?: string;
+                sourceUrl?: string;
+                showAdAttribution?: boolean;
+                renderLargerThumbnail?: boolean;
+                [key: string]: any;
+            };
+            [key: string]: any;
+        };
+        externalAdReply?: {
+            title?: string;
+            body?: string;
+            mediaType?: number;
+            thumbnailUrl?: string;
+            mediaUrl?: string;
+            sourceUrl?: string;
+            showAdAttribution?: boolean;
+            renderLargerThumbnail?: boolean;
+            [key: string]: any;
+        };
         buttons?: proto.Message.InteractiveMessage.INativeFlowButton[];
-        nativeFlowMessage?: proto.Message.InteractiveMessage.INativeFlowMessage;
+        nativeFlowMessage?: {
+            messageParamsJson?: string;
+            buttons?: proto.Message.InteractiveMessage.INativeFlowButton[];
+            [key: string]: any;
+        };
     }
 
     interface AlbumItem {
-        image?: { url: string; caption?: string };
-        video?: { url: string; caption?: string };
+        image?: string | Buffer | { url: string; caption?: string };
+        video?: string | Buffer | { url: string; caption?: string };
     }
 
     interface EventMessageLocation {
@@ -106,6 +147,16 @@ declare namespace kikyy {
         name: string;
         pollVotes: PollVote[];
     }
+
+    interface GroupStatusMessage {
+        message?: any;
+        image?: string | Buffer | { url: string };
+        video?: string | Buffer | { url: string };
+        text?: string;
+        caption?: string;
+        document?: string | Buffer | { url: string };
+        [key: string]: any;
+    }
  
     interface MessageContent {
         requestPaymentMessage?: PaymentMessage;
@@ -114,27 +165,39 @@ declare namespace kikyy {
         albumMessage?: AlbumItem[];
         eventMessage?: EventMessage;
         pollResultMessage?: PollResultMessage;
+        groupStatusMessage?: GroupStatusMessage;
+        sender?: string;
     }
 
     interface MessageOptions {
         quoted?: proto.IWebMessageInfo;
         filter?: boolean;
     }
+
+    interface Utils {
+        prepareWAMessageMedia: (media: any, options: WAMessageContentGenerationOptions) => Promise<any>;
+        generateWAMessageContent: (content: any, options: WAMessageContentGenerationOptions) => Promise<any>;
+        generateWAMessageFromContent: (jid: string, content: any, options?: any) => Promise<any>;
+        generateWAMessage: (jid: string, content: any, options?: any) => Promise<any>;
+        generateMessageID: () => string;
+        prepareMessageContent?: (content: any, options?: any) => Promise<any>;
+    }
+
+    interface BailUtils {
+        generateWAMessageContent?: (content: any, options: WAMessageContentGenerationOptions) => Promise<any>;
+        generateMessageID: () => string;
+        getContentType: (msg: any) => string;
+    }
 }
 
 declare class kikyy {
     constructor(
-        utils: {
-            prepareWAMessageMedia: (media: any, options: kikyy.WAMessageContentGenerationOptions) => Promise<any>;
-            generateWAMessageContent: (content: any, options: kikyy.WAMessageContentGenerationOptions) => Promise<any>;
-            generateWAMessageFromContent: (jid: string, content: any, options?: any) => Promise<any>;
-            generateMessageID: () => string;
-        },
+        utils: kikyy.Utils,
         waUploadToServer: kikyy.WAMediaUploadFunction,
         relayMessageFn?: (jid: string, content: any, options?: any) => Promise<any>
     );
     
-    detectType(content: kikyy.MessageContent): 'PAYMENT' | 'PRODUCT' | 'INTERACTIVE' | 'ALBUM' | 'EVENT' | 'POLL_RESULT' | null;
+    detectType(content: kikyy.MessageContent): 'PAYMENT' | 'PRODUCT' | 'INTERACTIVE' | 'ALBUM' | 'EVENT' | 'POLL_RESULT' | 'GROUP_STORY' | null;
 
     handlePayment(
         content: { requestPaymentMessage: kikyy.PaymentMessage },
@@ -151,7 +214,7 @@ declare class kikyy {
         content: { interactiveMessage: kikyy.InteractiveMessage },
         jid: string,
         quoted?: proto.IWebMessageInfo
-    ): Promise<{ viewOnceMessage: proto.Message.ViewOnceMessage }>;
+    ): Promise<{ interactiveMessage: proto.Message.InteractiveMessage }>;
 
     handleAlbum(
         content: { albumMessage: kikyy.AlbumItem[] },
@@ -170,6 +233,22 @@ declare class kikyy {
         jid: string,
         quoted?: proto.IWebMessageInfo
     ): Promise<any>;
+
+    handleGroupStory(
+        content: { groupStatusMessage: kikyy.GroupStatusMessage },
+        jid: string,
+        quoted?: proto.IWebMessageInfo
+    ): Promise<any>;
+
+    buildMessageContent(
+        content: any,
+        opts?: kikyy.WAMessageContentGenerationOptions
+    ): Promise<any>;
+
+    utils: kikyy.Utils;
+    relayMessage: (jid: string, content: any, options?: any) => Promise<any>;
+    waUploadToServer: kikyy.WAMediaUploadFunction;
+    bail: kikyy.BailUtils;
 }
 
-export = kikyy;
+export = kikyy;

package/lib/Socket/dugong.js

@@ -1,15 +1,22 @@
-// "kikyy dugonggg", gw kangen sama sebutan itu jir (r)
+// "kikyy dugonggg", ah dejavu (r)
 // tanggal 14 agustus 2025 makassar
-// telegram: @kiuurmine & @kyuucode
+// telegram: @tskiofc & @kyuucode
 
 const WAProto = require('../../WAProto').proto;
 const crypto = require('crypto');
+const Utils_1 = require("../Utils");
 
 class kikyy {
     constructor(utils, waUploadToServer, relayMessageFn) {
         this.utils = utils;
         this.relayMessage = relayMessageFn
         this.waUploadToServer = waUploadToServer;
+        
+        this.bail = {
+            generateWAMessageContent: this.utils.generateWAMessageContent || Utils_1.generateWAMessageContent,
+            generateMessageID: Utils_1.generateMessageID,
+            getContentType: (msg) => Object.keys(msg.message || {})[0]
+        };
     }
 
     detectType(content) {
@@ -18,7 +25,8 @@ class kikyy {
         if (content.interactiveMessage) return 'INTERACTIVE';
         if (content.albumMessage) return 'ALBUM';
         if (content.eventMessage) return 'EVENT';
-        if (content.pollResultMessage) return 'POLL_RESULT'
+        if (content.pollResultMessage) return 'POLL_RESULT';
+        if (content.groupStatusMessage) return 'GROUP_STORY';
         return null;
     }
 
@@ -64,7 +72,7 @@ class kikyy {
             })
         };
     }
-
+        
     async handleProduct(content, jid, quoted) {
         const {
             title, 
@@ -75,13 +83,26 @@ class kikyy {
             url, 
             body = "", 
             footer = "", 
-            buttons = []
+            buttons = [],
+            priceAmount1000 = null,
+            currencyCode = "IDR"
         } = content.productMessage;
 
-        const { imageMessage } = await this.utils.generateWAMessageContent(
-            { image: { url: thumbnail }}, 
-            { upload: this.waUploadToServer }
-        );
+        let productImage;
+
+        if (Buffer.isBuffer(thumbnail)) {
+            const { imageMessage } = await this.utils.generateWAMessageContent(
+                { image: thumbnail }, 
+                { upload: this.waUploadToServer }
+            );
+            productImage = imageMessage;
+        } else if (typeof thumbnail === 'object' && thumbnail.url) {
+            const { imageMessage } = await this.utils.generateWAMessageContent(
+                { image: { url: thumbnail.url }}, 
+                { upload: this.waUploadToServer }
+            );
+            productImage = imageMessage;
+        }
 
         return {
             viewOnceMessage: {
@@ -94,12 +115,12 @@ class kikyy {
                             hasMediaAttachment: true,
                             productMessage: {
                                 product: {
-                                    productImage: imageMessage,
+                                    productImage,
                                     productId,
                                     title,
                                     description,
-                                    currencyCode: "IDR",
-                                    priceAmount1000: null,
+                                    currencyCode,
+                                    priceAmount1000,
                                     retailerId,
                                     url,
                                     productImageCount: 1
@@ -113,65 +134,147 @@ class kikyy {
             }
         };
     }
-
+    
     async handleInteractive(content, jid, quoted) {
         const {
             title,
             footer,
             thumbnail,
+            image,
+            video,
+            document,
+            mimetype,
+            fileName,
+            jpegThumbnail,
+            contextInfo,
+            externalAdReply,
             buttons = [],
-            nativeFlowMessage
+            nativeFlowMessage,
+            header
         } = content.interactiveMessage;
 
+        let media = null;
+        let mediaType = null;
+
         if (thumbnail) {
-            const media = await this.utils.prepareWAMessageMedia(
+            media = await this.utils.prepareWAMessageMedia(
                 { image: { url: thumbnail } },
                 { upload: this.waUploadToServer }
             );
-            
-            return {
-                viewOnceMessage: {
-                    message: {
-                        messageContextInfo: {
-                            deviceListMetadata: {},
-                            deviceListMetadataVersion: 2
-                        },
-                        interactiveMessage: WAProto.Message.InteractiveMessage.create({
-                            body: { text: title },
-                            footer: { text: footer },
-                            header: {
-                                title: "",
-                                hasMediaAttachment: true,
-                                ...media
-                            },
-                            nativeFlowMessage: nativeFlowMessage || { buttons }
-                        })
-                    }
+            mediaType = 'image';
+        } else if (image) {
+            if (typeof image === 'object' && image.url) {
+                media = await this.utils.prepareWAMessageMedia(
+                    { image: { url: image.url } },
+                    { upload: this.waUploadToServer }
+                );
+            } else {
+                media = await this.utils.prepareWAMessageMedia(
+                    { image: image },
+                    { upload: this.waUploadToServer }
+                );
+            }
+            mediaType = 'image';
+        } else if (video) {
+            if (typeof video === 'object' && video.url) {
+                media = await this.utils.prepareWAMessageMedia(
+                    { video: { url: video.url } },
+                    { upload: this.waUploadToServer }
+                );
+            } else {
+                media = await this.utils.prepareWAMessageMedia(
+                    { video: video },
+                    { upload: this.waUploadToServer }
+                );
+            }
+            mediaType = 'video';
+        } else if (document) {
+            let documentPayload = { 
+                document: document 
+            };
+            if (jpegThumbnail) {
+                if (typeof jpegThumbnail === 'object' && jpegThumbnail.url) {
+                    documentPayload.jpegThumbnail = { url: jpegThumbnail.url };
+                } else {
+                    documentPayload.jpegThumbnail = jpegThumbnail;
                 }
+            }
+            
+            media = await this.utils.prepareWAMessageMedia(
+                documentPayload,
+                { upload: this.waUploadToServer }
+            );
+            if (fileName) {
+                media.documentMessage.fileName = fileName;
+            }
+            if (mimetype) {
+                media.documentMessage.mimetype = mimetype;
+            }
+            mediaType = 'document';
+        }
+        let interactiveMessage = {
+            body: { text: title || "" },
+            footer: { text: footer || "" }
+        };
+        if (buttons && buttons.length > 0) {
+            interactiveMessage.nativeFlowMessage = {
+                buttons: buttons
             };
+            if (nativeFlowMessage) {
+                interactiveMessage.nativeFlowMessage = {
+                    ...interactiveMessage.nativeFlowMessage,
+                    ...nativeFlowMessage
+                };
+            }
+        } else if (nativeFlowMessage) {
+            interactiveMessage.nativeFlowMessage = nativeFlowMessage;
+        }
+        
+        if (media) {
+            interactiveMessage.header = {
+                title: header || "",
+                hasMediaAttachment: true,
+                ...media
+            };
+        } else {
+            interactiveMessage.header = {
+                title: header || "",        
+                hasMediaAttachment: false
+            };
+        }
+        
+        let finalContextInfo = {};
+        if (contextInfo) {
+            finalContextInfo = {
+                mentionedJid: contextInfo.mentionedJid || [],
+                forwardingScore: contextInfo.forwardingScore || 0,
+                isForwarded: contextInfo.isForwarded || false,
+                ...contextInfo
+            };
+        }
+        
+        if (externalAdReply) {
+            finalContextInfo.externalAdReply = {
+                title: externalAdReply.title || "",
+                body: externalAdReply.body || "",
+                mediaType: externalAdReply.mediaType || 1,
+                thumbnailUrl: externalAdReply.thumbnailUrl || "",
+                mediaUrl: externalAdReply.mediaUrl || "",
+                sourceUrl: externalAdReply.sourceUrl || "",
+                showAdAttribution: externalAdReply.showAdAttribution || false,
+                renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false,
+                ...externalAdReply
+            };
+        }
+        
+        if (Object.keys(finalContextInfo).length > 0) {
+            interactiveMessage.contextInfo = finalContextInfo;
         }
-
         return {
-            viewOnceMessage: {
-                message: {
-                    messageContextInfo: {
-                        deviceListMetadata: {},
-                        deviceListMetadataVersion: 2
-                    },
-                    interactiveMessage: WAProto.Message.InteractiveMessage.create({
-                        body: { text: title },
-                        footer: { text: footer },
-                        header: {
-                            title: "",
-                            hasMediaAttachment: false
-                        },
-                        nativeFlowMessage: nativeFlowMessage || { buttons }
-                    })
-                }
-            }
+            interactiveMessage: interactiveMessage
         };
     }
-
+    
     async handleAlbum(content, jid, quoted) {
         const array = content.albumMessage;
         const album = await this.utils.generateWAMessageFromContent(jid, {
@@ -187,16 +290,16 @@ class kikyy {
             quoted,
             upload: this.waUploadToServer
         });
-
+        
         await this.relayMessage(jid, album.message, {
             messageId: album.key.id,
         });
-
+        
         for (let content of array) {
             const img = await this.utils.generateWAMessage(jid, content, {
                 upload: this.waUploadToServer,
             });
-
+            
             img.message.messageContextInfo = {
                 messageSecret: crypto.randomBytes(32),
                 messageAssociation: {
@@ -230,14 +333,14 @@ class kikyy {
                 priority: "high",
                 status: "sent",
             };
-
+            
             img.message.disappearingMode = {
                 initiator: 3,
                 trigger: 4,
                 initiatorDeviceJid: jid,
                 initiatedByExternalService: true,
                 initiatedByUserDevice: true,
-                initiatedBySystem: true,
+                initiatedBySystem: true,      
                 initiatedByServer: true,
                 initiatedByAdmin: true,
                 initiatedByUser: true,
@@ -261,7 +364,7 @@ class kikyy {
         }
         return album;
     }   
-    // tama tama
+
     async handleEvent(content, jid, quoted) {
         const eventData = content.eventMessage;
         
@@ -312,10 +415,10 @@ class kikyy {
         });
         return msg;
     }
-        
+    
     async handlePollResult(content, jid, quoted) {
         const pollData = content.pollResultMessage;
-        
+    
         const msg = await this.utils.generateWAMessageFromContent(jid, {
             pollResultSnapshotMessage: {
                 name: pollData.name,
@@ -330,13 +433,52 @@ class kikyy {
             userJid: this.utils.generateMessageID().split('@')[0] + '@s.whatsapp.net',
             quoted
         });
-        
+    
         await this.relayMessage(jid, msg.message, {
             messageId: msg.key.id
         });
-       
+
         return msg;
     }
+
+    async handleGroupStory(content, jid, quoted) {
+        const storyData = content.groupStatusMessage;
+        let waMsgContent;
+        
+        if (storyData.message) {
+            waMsgContent = storyData;
+        } else {
+            if (typeof this.bail?.generateWAMessageContent === "function") {
+                waMsgContent = await this.bail.generateWAMessageContent(storyData, {
+                    upload: this.waUploadToServer
+                });
+            } else if (typeof this.utils?.generateWAMessageContent === "function") {
+                waMsgContent = await this.utils.generateWAMessageContent(storyData, {
+                    upload: this.waUploadToServer
+                });
+            } else if (typeof this.utils?.prepareMessageContent === "function") {
+                waMsgContent = await this.utils.prepareMessageContent(storyData, {
+                    upload: this.waUploadToServer
+                });
+            } else {
+                waMsgContent = await Utils_1.generateWAMessageContent(storyData, {
+                    upload: this.waUploadToServer
+                });
+            }
+        }
+
+        let msg = {
+            message: {
+                groupStatusMessageV2: {
+                    message: waMsgContent.message || waMsgContent
+                }
+            }
+        };
+
+        return await this.relayMessage(jid, msg.message, {
+            messageId: this.bail.generateMessageID()
+        });
+    }
 }
 
-module.exports = kikyy;
+module.exports = kikyy;

package/lib/Socket/groups.js

@@ -305,6 +305,7 @@ const extractGroupMetadata = (result) => {
         participants: WABinary_1.getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
             return {
                 id: attrs.jid,
+                jid: attrs.phone_number || attrs.jid,
                 admin: (attrs.type || null),
             };
         }),

package/lib/Socket/index.js

@@ -8,3 +8,4 @@ const makeWASocket = (config) => ((0, registration_1.makeRegistrationSocket)({
     ...config
 }));
 exports.default = makeWASocket;
+exports.makeWASocket = makeWASocket;

package/lib/Socket/messages-send.js

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; 
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 }; 
@@ -291,7 +291,7 @@ const makeMessagesSocket = (config) => {
         }));
         return { nodes, shouldIncludeDeviceIdentity };
     }; //apela
-    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, cachedGroupMetadata, useCachedGroupMetadata, statusJidList, AI = true } = {}) => {
+    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, cachedGroupMetadata, useCachedGroupMetadata, statusJidList, AI = true }) => {
         const meId = authState.creds.me.id;
         let shouldIncludeDeviceIdentity = false;
         let didPushAdditional = false
@@ -335,6 +335,10 @@ const makeMessagesSocket = (config) => {
                 extraAttrs['mediatype'] = mediaType
             }
             
+            if (messages.pinInChatMessage || messages.keepInChatMessage || message.reactionMessage || message.protocolMessage?.editedMessage) {
+                extraAttrs['decrypt-fail'] = 'hide'
+            } 
+            
             if (messages.interactiveResponseMessage?.nativeFlowResponseMessage) {
                 extraAttrs['native_flow_name'] = messages.interactiveResponseMessage?.nativeFlowResponseMessage.name
             }
@@ -560,7 +564,7 @@ const makeMessagesSocket = (config) => {
                 }
             }
             
-            if(!isNewsletter && buttonType) {             
+            if(!isNewsletter && buttonType && !isStatus) {             
                 const content = WABinary_1.getAdditionalNode(buttonType)
                 const filteredNode = WABinary_1.getBinaryNodeFilter(additionalNodes)
 
@@ -774,7 +778,12 @@ const makeMessagesSocket = (config) => {
                 throw error;
             }
             ev.emit('messages.update', [
-                { key: message.key, update: { message: message.message } }
+                {
+                    key: message.key,
+                    update: { 
+                        message: message.message
+                    }
+                }
             ]);
             return message;
         },
@@ -824,14 +833,13 @@ const makeMessagesSocket = (config) => {
                             ...getParticipantAttr()
                         });
                     case 'ALBUM':
-                        const albumContent = await rahmi.handleAlbum(content, jid, quoted)
-                        return albumContent;
-                        
+                        return await rahmi.handleAlbum(content, jid, quoted)
                     case 'EVENT':
                         return await rahmi.handleEvent(content, jid, quoted)
-                        
                     case 'POLL_RESULT':
                         return await rahmi.handlePollResult(content, jid, quoted)
+                    case 'GROUP_STORY':
+                        return await rahmi.handleGroupStory(content, jid, quoted)
                 }
             }
             const fullMsg = await Utils_1.generateWAMessage(jid, content, {