@hansaka02/baileys 7.3.2 → 7.3.4

package/lib/Utils/messages.js

@@ -1,22 +1,43 @@
 "use strict"
 
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod }
-}
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const boom_1 = require("@hapi/boom")
-const axios_1 = __importDefault(require("axios"))
-const crypto_1 = require("crypto")
-const fs_1 = require("fs")
-const WAProto_1 = require("../../WAProto")
-const Defaults_1 = require("../Defaults")
-const Types_1 = require("../Types")
-const WABinary_1 = require("../WABinary")
-const crypto_2 = require("./crypto")
-const generics_1 = require("./generics")
-const messages_media_1 = require("./messages-media")
+const { Boom } = require("@hapi/boom")
+const axios_1 = require("axios")
+const { randomBytes } = require("crypto")
+const { promises } = require("fs")
+const { proto } = require("../../WAProto")
+const {
+  URL_REGEX, 
+  WA_DEFAULT_EPHEMERAL
+} = require("../Defaults/constants")
+const { MEDIA_KEYS } = require("../Defaults/media")
+const {
+  WAProto, 
+  WAMessageStatus
+} = require("../Types")
+const { 
+  isJidGroup, 
+  isJidNewsletter,
+  isJidStatusBroadcast, 
+  jidNormalizedUser
+} = require("../WABinary")
+const { sha256 } = require("./crypto")
+const {
+  generateMessageID, 
+  getKeyAuthor, 
+  unixTimestampSeconds 
+} = require("./generics")
+const { 
+  downloadContentFromMessage, 
+  encryptedStream, 
+  generateThumbnail, 
+  getAudioDuration, 
+  getAudioWaveform, 
+  getRawMediaUploadData, 
+  getStream, 
+  toBuffer 
+} = require("./messages-media")
 
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
@@ -28,11 +49,11 @@ const MIMETYPE_MAP = {
 }
 
 const MessageTypeProto = {
-    'image': Types_1.WAProto.Message.ImageMessage,
-    'video': Types_1.WAProto.Message.VideoMessage,
-    'audio': Types_1.WAProto.Message.AudioMessage,
-    'sticker': Types_1.WAProto.Message.StickerMessage,
-    'document': Types_1.WAProto.Message.DocumentMessage,
+    'image': WAProto.Message.ImageMessage,
+    'video': WAProto.Message.VideoMessage,
+    'audio': WAProto.Message.AudioMessage,
+    'sticker': WAProto.Message.StickerMessage,
+    'document': WAProto.Message.DocumentMessage
 }
 
 /**
@@ -40,7 +61,7 @@ const MessageTypeProto = {
  * @param text eg. hello https://google.com
  * @returns the URL, eg. https://google.com
  */
-const extractUrlFromText = (text) => text.match(Defaults_1.URL_REGEX)?.[0]
+const extractUrlFromText = (text) => text.match(URL_REGEX)?.[0]
 
 const generateLinkPreviewIfRequired = async (text, getUrlInfo, logger) => {
     const url = extractUrlFromText(text)
@@ -78,14 +99,14 @@ const prepareWAMessageMedia = async (message, options) => {
     const logger = options.logger
     let mediaType
 
-    for (const key of Defaults_1.MEDIA_KEYS) {
+    for (const key of MEDIA_KEYS) {
         if (key in message) {
             mediaType = key
         }
     }
 
     if (!mediaType) {
-        throw new boom_1.Boom('Invalid media type', { statusCode: 400 });
+        throw new Boom('Invalid media type', { statusCode: 400 });
     }
 
     const uploadData = {
@@ -114,18 +135,18 @@ const prepareWAMessageMedia = async (message, options) => {
         const mediaBuff = await options.mediaCache.get(cacheableKey)
         if (mediaBuff) {
             logger?.debug({ cacheableKey }, 'got media cache hit')
-            const obj = Types_1.WAProto.Message.decode(mediaBuff)
+            const obj = WAProto.Message.decode(mediaBuff)
             const key = `${mediaType}Message`
             Object.assign(obj[key], { ...uploadData, media: undefined })
             return obj
         }
     }
 
-    const isNewsletter = !!options.jid && WABinary_1.isJidNewsletter(options.jid)
+    const isNewsletter = !!options.jid && isJidNewsletter(options.jid)
 
     if (isNewsletter) {
         logger?.info({ key: cacheableKey }, 'Preparing raw media for newsletter')
-        const { filePath, fileSha256, fileLength } = await messages_media_1.getRawMediaUploadData(uploadData.media, options.mediaTypeOverride || mediaType, logger)
+        const { filePath, fileSha256, fileLength } = await getRawMediaUploadData(uploadData.media, options.mediaTypeOverride || mediaType, logger)
         const fileSha256B64 = fileSha256.toString('base64')
         const { mediaUrl, directPath } = await options.upload(filePath, {
             fileEncSha256B64: fileSha256B64,
@@ -133,9 +154,9 @@ const prepareWAMessageMedia = async (message, options) => {
             timeoutMs: options.mediaUploadTimeoutMs
         })
 
-        await fs_1.promises.unlink(filePath)
+        await promises.unlink(filePath)
 
-        const obj = Types_1.WAProto.Message.fromObject({
+        const obj = WAProto.Message.fromObject({
             // todo: add more support here
             [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
                 url: mediaUrl,
@@ -154,7 +175,7 @@ const prepareWAMessageMedia = async (message, options) => {
 
         if (cacheableKey) {
             logger?.debug({ cacheableKey }, 'set cache');
-            await options.mediaCache.set(cacheableKey, Types_1.WAProto.Message.encode(obj).finish())
+            await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish())
         }
 
         return obj
@@ -166,7 +187,7 @@ const prepareWAMessageMedia = async (message, options) => {
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation
 
-    const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await messages_media_1.encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
+    const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
         logger,
         saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
         opts: options.options
@@ -188,7 +209,7 @@ const prepareWAMessageMedia = async (message, options) => {
         (async () => {
             try {
                 if (requiresThumbnailComputation) {
-                    const { thumbnail, originalImageDimensions } = await messages_media_1.generateThumbnail(originalFilePath, mediaType, options)
+                    const { thumbnail, originalImageDimensions } = await generateThumbnail(originalFilePath, mediaType, options)
                     uploadData.jpegThumbnail = thumbnail
                     if (!uploadData.width && originalImageDimensions) {
                         uploadData.width = originalImageDimensions.width
@@ -201,12 +222,12 @@ const prepareWAMessageMedia = async (message, options) => {
                 }
 
                 if (requiresDurationComputation) {
-                    uploadData.seconds = await messages_media_1.getAudioDuration(originalFilePath)
+                    uploadData.seconds = await getAudioDuration(originalFilePath)
                     logger?.debug('computed audio duration')
                 }
 
                 if (requiresWaveformProcessing) {
-                    uploadData.waveform = await messages_media_1.getAudioWaveform(originalFilePath, logger)
+                    uploadData.waveform = await getAudioWaveform(originalFilePath, logger)
                     logger?.debug('processed waveform')
                 }
 
@@ -221,10 +242,10 @@ const prepareWAMessageMedia = async (message, options) => {
         })()
     ]).finally(async () => {
         try {
-            await fs_1.promises.unlink(encFilePath)
+            await promises.unlink(encFilePath)
 
             if (originalFilePath) {
-                await fs_1.promises.unlink(originalFilePath)
+                await promises.unlink(originalFilePath)
             }
 
             logger?.debug('removed tmp files')
@@ -234,7 +255,7 @@ const prepareWAMessageMedia = async (message, options) => {
         }
     })
 
-    const obj = Types_1.WAProto.Message.fromObject({
+    const obj = WAProto.Message.fromObject({
         [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
             url: mediaUrl,
             directPath,
@@ -242,7 +263,7 @@ const prepareWAMessageMedia = async (message, options) => {
             fileEncSha256,
             fileSha256,
             fileLength,
-            mediaKeyTimestamp: generics_1.unixTimestampSeconds(),
+            mediaKeyTimestamp: unixTimestampSeconds(),
             ...uploadData,
             media: undefined
         })
@@ -255,75 +276,86 @@ const prepareWAMessageMedia = async (message, options) => {
 
     if (cacheableKey) {
         logger?.debug({ cacheableKey }, 'set cache');
-        await options.mediaCache.set(cacheableKey, Types_1.WAProto.Message.encode(obj).finish())
+        await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish())
     }
 
     return obj
 }
 
 const prepareAlbumMessageContent = async (jid, albums, options) => {
-        let mediaHandle
-        let mediaMsg 
-        let 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.suki.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.suki.waUploadToServer(encFilePath, { ...opts, newsletter: WABinary_1.isJidNewsletter(jid) })
-                                        mediaHandle = up.handle
-                                        return up
-                                }, 
-                                ...options
-                        }) 
-                } else if ('video' in message) {
-                        mediaMsg = await generateWAMessage(jid, {
-                                video: media.video, 
-                                ...media, 
-                                ...options
-                        }, {
-                                userJid: options.userJid, 
-                                upload: async (encFilePath, opts) => {
-                                        const up = await options.suki.waUploadToServer(encFilePath, { ...opts, newsletter: WABinary_1.isJidNewsletter(jid) })
-                                        mediaHandle = up.handle
-                                        return up
-                                }, 
-                                ...options
-                        }) 
-                }
+    if (!Array.isArray(albums)) {
+        throw new Error("albums must be an array containing media objects.")
+    }
 
-                if (mediaMsg) {
-                        mediaMsg.message.messageContextInfo = {
-                                messageSecret: crypto_1.randomBytes(32), 
-                                messageAssociation: {
-                                        associationType: 1,
-                                        parentMessageKey: albumMsg.key
-                                }
-                        }
-                } 
+    if (albums.length === 0) {
+        throw new Error("albums cannot be empty. At least one media item is required.")
+    }
+
+    const validCount = albums.filter(m => ('image' in m) || ('video' in m)).length
+    
+    if (validCount === 0) {
+        throw new Error("albums contains no valid media. Use 'image' or 'video' keys.")
+    }
+
+    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)
 
-                message.push(mediaMsg)
+    await options.suki.relayMessage(jid, albumMsg.message, {
+        messageId: albumMsg.key.id
+    })
+
+    for (const media of albums) {
+        let content = {}
+        if ('image' in media) {
+            content = { image: media.image }
+        } else if ('video' in media) {
+            content = { video: media.video }
+        } else {
+            continue
         }
 
-        return message
+        mediaMsg = await generateWAMessage(
+            jid,
+            {
+                ...content,
+                ...media
+            },
+            {
+                userJid: options.userJid,
+                upload: async (encFilePath, opts) => {
+                    const up = await options.suki.waUploadToServer(
+                        encFilePath,
+                        { ...opts, newsletter: isJidNewsletter(jid) }
+                    )
+                    mediaHandle = up.handle
+                    return up
+                },
+                ...options
+            }
+        )
+
+        if (mediaMsg) {
+            mediaMsg.message.messageContextInfo = {
+                messageSecret: randomBytes(32),
+                messageAssociation: {
+                    associationType: proto.MessageAssociation.AssociationType.MEDIA_ALBUM,
+                    parentMessageKey: albumMsg.key
+                }
+            }
+        }
+
+        message.push(mediaMsg)
+    }
+
+    return message
 }
 
 const prepareDisappearingMessageSettingContent = (expiration) => {
@@ -331,14 +363,14 @@ const prepareDisappearingMessageSettingContent = (expiration) => {
         ephemeralMessage: {
             message: {
                 protocolMessage: {
-                    type: Types_1.WAProto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
+                    type: WAProto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
                     ephemeralExpiration: expiration ? expiration : 0
                 }
             }
         }
     }
 
-    return Types_1.WAProto.Message.fromObject(content)
+    return WAProto.Message.fromObject(content)
 }
 
 /**
@@ -350,12 +382,12 @@ const generateForwardMessageContent = (message, forceForward) => {
     let content = message.message
 
     if (!content) {
-        throw new boom_1.Boom('no content in message', { statusCode: 400 })
+        throw new Boom('no content in message', { statusCode: 400 })
     }
 
     // hacky copy
     content = normalizeMessageContent(content)
-    content = WAProto_1.proto.Message.decode(WAProto_1.proto.Message.encode(content).finish())
+    content = proto.Message.decode(proto.Message.encode(content).finish())
 
     let key = Object.keys(content)[0]
     let score = content[key].contextInfo?.forwardingScore || 0
@@ -435,18 +467,18 @@ const generateWAMessageContent = async (message, options) => {
         let contactMessage
 
         if (!contactLen) {
-            throw new boom_1.Boom('require atleast 1 contact', { statusCode: 400 })
+            throw new Boom('require atleast 1 contact', { statusCode: 400 })
         }
 
         if (contactLen === 1) {
             contactMessage = {
-                    contactMessage: Types_1.WAProto.Message.ContactMessage.fromObject(message.contacts.contacts[0])
+                    contactMessage: WAProto.Message.ContactMessage.fromObject(message.contacts.contacts[0])
             }
         }
 
         else {
             contactMessage = {
-                    contactsArrayMessage: Types_1.WAProto.Message.ContactsArrayMessage.fromObject(message.contacts)
+                    contactsArrayMessage: WAProto.Message.ContactsArrayMessage.fromObject(message.contacts)
             }
         }
 
@@ -465,13 +497,13 @@ const generateWAMessageContent = async (message, options) => {
 
             if (message.live) {
                 locationMessage = {
-                    liveLocationMessage: Types_1.WAProto.Message.LiveLocationMessage.fromObject(message.location) 
+                    liveLocationMessage: WAProto.Message.LiveLocationMessage.fromObject(message.location) 
             }
         }
 
         else {
                 locationMessage = {
-                    locationMessage: Types_1.WAProto.Message.LocationMessage.fromObject(message.location) 
+                    locationMessage: WAProto.Message.LocationMessage.fromObject(message.location) 
             }
         }
 
@@ -490,13 +522,13 @@ const generateWAMessageContent = async (message, options) => {
             message.react.senderTimestampMs = Date.now()
         }
 
-        m.reactionMessage = Types_1.WAProto.Message.ReactionMessage.fromObject(message.react)
+        m.reactionMessage = WAProto.Message.ReactionMessage.fromObject(message.react)
     }
 
     else if ('delete' in message) {
         m.protocolMessage = {
             key: message.delete,
-            type: Types_1.WAProto.Message.ProtocolMessage.Type.REVOKE
+            type: WAProto.Message.ProtocolMessage.Type.REVOKE
         }
     } 
 
@@ -514,7 +546,7 @@ const generateWAMessageContent = async (message, options) => {
 
     else if ('disappearingMessagesInChat' in message) {
         const exp = typeof message.disappearingMessagesInChat === 'boolean' ?
-            (message.disappearingMessagesInChat ? Defaults_1.WA_DEFAULT_EPHEMERAL : 0) :
+            (message.disappearingMessagesInChat ? WA_DEFAULT_EPHEMERAL : 0) :
             message.disappearingMessagesInChat
         m = prepareDisappearingMessageSettingContent(exp)
     }
@@ -531,7 +563,7 @@ const generateWAMessageContent = async (message, options) => {
 
         if (options.getProfilePicUrl) {
             const pfpUrl = await options.getProfilePicUrl(message.groupInvite.jid)
-            const { thumbnail } = await messages_media_1.generateThumbnail(pfpUrl, 'image') 
+            const { thumbnail } = await generateThumbnail(pfpUrl, 'image') 
             m.groupInviteMessage.jpegThumbnail = thumbnail
         }
 
@@ -552,7 +584,7 @@ const generateWAMessageContent = async (message, options) => {
 
         if (options.getProfilePicUrl) {
             const pfpUrl = await options.getProfilePicUrl(message.adminInvite.jid)
-            const { thumbnail } = await messages_media_1.generateThumbnail(pfpUrl, 'image') 
+            const { thumbnail } = await generateThumbnail(pfpUrl, 'image') 
             m.newsletterAdminInviteMessage.jpegThumbnail = thumbnail
         }
 
@@ -570,7 +602,7 @@ const generateWAMessageContent = async (message, options) => {
         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 = WAProto_1.proto.MessageContextInfo.MessageAddonExpiryType.STATIC
+        m.messageContextInfo.messageAddOnExpiryType = proto.MessageContextInfo.MessageAddonExpiryType.STATIC
     }
 
     else if ('keep' in message) {
@@ -616,7 +648,7 @@ const generateWAMessageContent = async (message, options) => {
                     singleSelectReply: {
                             selectedRowId: message.buttonReply.rowId
                     }, 
-                    lisType: WAProto_1.proto.Message.ListResponseMessage.ListType.SINGLE_SELECT
+                    lisType: proto.Message.ListResponseMessage.ListType.SINGLE_SELECT
                 }
                 break
             case 'template':
@@ -630,14 +662,14 @@ const generateWAMessageContent = async (message, options) => {
                 m.buttonsResponseMessage = {
                     selectedButtonId: message.buttonReply.id,
                     selectedDisplayText: message.buttonReply.displayText,
-                    type: WAProto_1.proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT
+                    type: proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT
                 }
                 break
             case 'interactive':
                 m.interactiveResponseMessage = {
                     body: {
                        text: message.buttonReply.displayText,
-                       format: WAProto_1.proto.Message.InteractiveResponseMessage.Body.Format.EXTENSIONS_1 
+                       format: proto.Message.InteractiveResponseMessage.Body.Format.EXTENSIONS_1 
                     }, 
                     nativeFlowResponseMessage: {
                             name: message.buttonReply.nativeFlows.name, 
@@ -659,14 +691,14 @@ const generateWAMessageContent = async (message, options) => {
             const imageMessages = message.album.filter(item => 'image' in item) 
             const videoMessages = message.album.filter(item => 'video' in item) 
 
-            m.albumMessage = Types_1.WAProto.Message.AlbumMessage.fromObject({
+            m.albumMessage = WAProto.Message.AlbumMessage.fromObject({
                     expectedImageCount: imageMessages.length, 
                     expectedVideoCount: videoMessages.length
             }) 
     }
 
     else if ('order' in message) {
-            m.orderMessage = Types_1.WAProto.Message.OrderMessage.fromObject(message.order) 
+            m.orderMessage = WAProto.Message.OrderMessage.fromObject(message.order) 
 
         m.orderMessage.contextInfo = {
             ...(message.contextInfo || {}),
@@ -675,10 +707,10 @@ const generateWAMessageContent = async (message, options) => {
     }
 
     else if ('event' in message) { 
-       m.eventMessage = Types_1.WAProto.Message.EventMessage.fromObject(message.event) 
+       m.eventMessage = WAProto.Message.EventMessage.fromObject(message.event) 
 
        if (!message.event.startTime) {
-           m.eventMessage.startTime = generics_1.unixTimestampSeconds() + 86400
+           m.eventMessage.startTime = unixTimestampSeconds() + 86400
        }
 
        if (options.getCallLink && message.event.call) {
@@ -696,7 +728,7 @@ const generateWAMessageContent = async (message, options) => {
     else if ('product' in message) {
         const { imageMessage } = await prepareWAMessageMedia({ image: message.product.productImage }, options)
 
-        m.productMessage = Types_1.WAProto.Message.ProductMessage.fromObject({
+        m.productMessage = WAProto.Message.ProductMessage.fromObject({
             ...message,
             product: {
                 ...message.product,
@@ -712,7 +744,7 @@ const generateWAMessageContent = async (message, options) => {
 
     else if ('pollResult' in message) {
             if (!Array.isArray(message.pollResult.values)) {
-            throw new boom_1.Boom('Invalid pollResult values', { statusCode: 400 })
+            throw new Boom('Invalid pollResult values', { statusCode: 400 })
         }
 
             const pollResultSnapshotMessage = {
@@ -733,12 +765,12 @@ const generateWAMessageContent = async (message, options) => {
 
     else if ('poll' in message) {
         if (!Array.isArray(message.poll.values)) {
-            throw new boom_1.Boom('Invalid poll values', { statusCode: 400 })
+            throw new Boom('Invalid poll values', { statusCode: 400 })
         }
 
         if (message.poll.selectableCount < 0
             || message.poll.selectableCount > message.poll.values.length) {
-            throw new boom_1.Boom(`poll.selectableCount in poll should be >= 0 and <= ${message.poll.values.length}`, { statusCode: 400 })
+            throw new Boom(`poll.selectableCount in poll should be >= 0 and <= ${message.poll.values.length}`, { statusCode: 400 })
         }
 
         const pollCreationMessage = {
@@ -802,9 +834,9 @@ const generateWAMessageContent = async (message, options) => {
 
        const stickerData = {}
        const stickerPromises = stickers.map(async (s, i) => {
-           const { stream } = await messages_media_1.getStream(s.sticker) 
-           const buffer = await messages_media_1.toBuffer(stream) 
-           const hash = crypto_2.sha256(buffer).toString('base64url') 
+           const { stream } = await getStream(s.sticker) 
+           const buffer = await toBuffer(stream) 
+           const hash = sha256(buffer).toString('base64url') 
            const fileName = `${i.toString().padStart(2, '0')}_${hash}.webp`
            stickerData[fileName] = [new Uint8Array(buffer), { level: 0 }]
 
@@ -830,10 +862,10 @@ const generateWAMessageContent = async (message, options) => {
            }) 
        }) 
 
-       const coverBuffer = await messages_media_1.toBuffer((await messages_media_1.getStream(cover)).stream) 
+       const coverBuffer = await toBuffer((await getStream(cover)).stream) 
 
        const [stickerPackUpload, coverUpload] = await Promise.all([
-           messages_media_1.encryptedStream(zipBuffer, 'sticker-pack', { logger: options.logger, opts: options.options }), 
+           encryptedStream(zipBuffer, 'sticker-pack', { logger: options.logger, opts: options.options }), 
            prepareWAMessageMedia({ image: coverBuffer }, { ...options, mediaTypeOverride: 'image' })
        ]) 
 
@@ -845,15 +877,15 @@ const generateWAMessageContent = async (message, options) => {
 
 
        const coverImage = coverUpload.imageMessage
-       const imageDataHash = crypto_2.sha256(coverBuffer).toString('base64') 
-       const stickerPackId = packId || generics_1.generateMessageID() 
+       const imageDataHash = sha256(coverBuffer).toString('base64') 
+       const stickerPackId = packId || generateMessageID() 
 
        m.stickerPackMessage = {
             name, 
             publisher, 
             stickerPackId, 
             packDescription: description, 
-            stickerPackOrigin: WAProto_1.proto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY, 
+            stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY, 
             stickerPackSize: stickerPackUpload.fileLength, 
             stickers: stickerMetadata, 
             fileSha256: stickerPackUpload.fileSha256, 
@@ -861,7 +893,7 @@ const generateWAMessageContent = async (message, options) => {
             mediaKey: stickerPackUpload.mediaKey, 
             directPath: stickerPackUploadResult.directPath, 
             fileLength: stickerPackUpload.fileLength, 
-            mediaKeyTimestamp: generics_1.unixTimestampSeconds(), 
+            mediaKeyTimestamp: unixTimestampSeconds(), 
             trayIconFileName: `${stickerPackId}.png`, 
             imageDataHash, 
             thumbnailDirectPath: coverImage.directPath, 
@@ -879,7 +911,7 @@ const generateWAMessageContent = async (message, options) => {
 
    else if ('sharePhoneNumber' in message) {
         m.protocolMessage = {
-            type: Types_1.WAProto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
+            type: WAProto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
         }
     }
 
@@ -906,7 +938,7 @@ const generateWAMessageContent = async (message, options) => {
             footerText: message.footer, 
             description: message.text, 
             sections: message.sections, 
-            listType: WAProto_1.proto.Message.ListMessage.ListType.SINGLE_SELECT
+            listType: proto.Message.ListMessage.ListType.SINGLE_SELECT
         }
 
         listMessage.contextInfo = {
@@ -918,7 +950,7 @@ const generateWAMessageContent = async (message, options) => {
     }
 
     else if ('productList' in message && !!message.productList) {
-            const thumbnail = message.thumbnail ? await messages_media_1.generateThumbnail(message.thumbnail, 'image') : null
+            const thumbnail = message.thumbnail ? await generateThumbnail(message.thumbnail, 'image') : null
 
         const listMessage = {
             title: message.title, 
@@ -933,7 +965,7 @@ const generateWAMessageContent = async (message, options) => {
                 }, 
                 businessOwnerJid: message.businessOwnerJid
             }, 
-            listType: WAProto_1.proto.Message.ListMessage.ListType.PRODUCT_LIST
+            listType: proto.Message.ListMessage.ListType.PRODUCT_LIST
         }
 
         listMessage.contextInfo = {
@@ -946,12 +978,12 @@ const generateWAMessageContent = async (message, options) => {
 
     else if ('buttons' in message && !!message.buttons) {        
         const buttonsMessage = {
-            buttons: message.buttons.map(b => ({ ...b, type: WAProto_1.proto.Message.ButtonsMessage.Button.Type.RESPONSE }))
+            buttons: message.buttons.map(b => ({ ...b, type: proto.Message.ButtonsMessage.Button.Type.RESPONSE }))
         }
 
         if ('text' in message) {
             buttonsMessage.contentText = message.text
-            buttonsMessage.headerType = WAProto_1.proto.Message.ButtonsMessage.HeaderType.EMPTY
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.EMPTY
         }
 
         else {
@@ -961,7 +993,7 @@ const generateWAMessageContent = async (message, options) => {
 
             const type = Object.keys(m)[0].replace('Message', '').toUpperCase()
 
-            buttonsMessage.headerType = WAProto_1.proto.Message.ButtonsMessage.HeaderType[type]
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType[type]
 
             Object.assign(buttonsMessage, m)
         }
@@ -972,7 +1004,7 @@ const generateWAMessageContent = async (message, options) => {
 
         if ('title' in message && !!message.title) {
                 buttonsMessage.text = message.title
-            buttonsMessage.headerType = WAProto_1.proto.Message.ButtonsMessage.HeaderType.TEXT
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.TEXT
         }
 
         buttonsMessage.contextInfo = {
@@ -1250,12 +1282,12 @@ const generateWAMessageContent = async (message, options) => {
                 key: message.edit,
                 editedMessage: m,
                 timestampMs: Date.now(),
-                type: Types_1.WAProto.Message.ProtocolMessage.Type.MESSAGE_EDIT
+                type: WAProto.Message.ProtocolMessage.Type.MESSAGE_EDIT
             }
         }
     }
 
-    return Types_1.WAProto.Message.fromObject(m)
+    return WAProto.Message.fromObject(m)
 }
 
 const generateWAMessageFromContent = (jid, message, options) => {
@@ -1265,11 +1297,11 @@ const generateWAMessageFromContent = (jid, message, options) => {
 
     const innerMessage = normalizeMessageContent(message)
     const key = getContentType(innerMessage)
-    const timestamp = generics_1.unixTimestampSeconds(options.timestamp)
+    const timestamp = unixTimestampSeconds(options.timestamp)
     const threadId = []
     const { quoted, userJid } = options
 
-    if (quoted && !WABinary_1.isJidNewsletter(jid)) {
+    if (quoted && !isJidNewsletter(jid)) {
         const participant = quoted.key.fromMe
             ? userJid
             : quoted.participant || quoted.key.participant || quoted.key.remoteJid
@@ -1277,7 +1309,7 @@ const generateWAMessageFromContent = (jid, message, options) => {
         let quotedMsg = normalizeMessageContent(quoted.message)
         const msgType = getContentType(quotedMsg)
 
-        quotedMsg = WAProto_1.proto.Message.fromObject({ [msgType]: quotedMsg[msgType] })
+        quotedMsg = proto.Message.fromObject({ [msgType]: quotedMsg[msgType] })
 
         const quotedContent = quotedMsg[msgType]
 
@@ -1297,7 +1329,7 @@ const generateWAMessageFromContent = (jid, message, options) => {
 
         const contextInfo = (key === 'requestPaymentMessage' ? requestPayment?.contextInfo : innerMessage[key].contextInfo) || {}
 
-        contextInfo.participant = WABinary_1.jidNormalizedUser(participant)
+        contextInfo.participant = jidNormalizedUser(participant)
         contextInfo.stanzaId = quoted.key.id
         contextInfo.quotedMessage = quotedMsg
 
@@ -1306,16 +1338,16 @@ const generateWAMessageFromContent = (jid, message, options) => {
         }
 
         if (contextInfo.quotedMessage) {
-            contextInfo.quotedType = WAProto_1.proto.ContextInfo.QuotedType.EXPLICIT
+            contextInfo.quotedType = proto.ContextInfo.QuotedType.EXPLICIT
         }
 
-        if (contextInfo.quotedMessage && WABinary_1.isJidGroup(jid)) {
+        if (contextInfo.quotedMessage && isJidGroup(jid)) {
             threadId.push({
-                threadType: WAProto_1.proto.ThreadID.ThreadType.VIEW_REPLIES, 
+                threadType: proto.ThreadID.ThreadType.VIEW_REPLIES, 
                 threadKey: {
                     remoteJid: quoted?.key?.remoteJid, 
                     fromMe: quoted?.key?.fromMe, 
-                    id: generics_1.generateMessageID(), 
+                    id: generateMessageID(), 
                     ...(quoted?.key?.fromMe ? {} : { participant: quoted?.key?.participant }) 
                 }
             })  
@@ -1330,10 +1362,10 @@ const generateWAMessageFromContent = (jid, message, options) => {
 
     if (key !== 'protocolMessage' &&
         key !== 'ephemeralMessage' &&
-        !WABinary_1.isJidNewsletter(jid)) { 
+        !isJidNewsletter(jid)) { 
         message.messageContextInfo = {
             threadId: threadId.length > 0 ? threadId : [], 
-            messageSecret: crypto_1.randomBytes(32), 
+            messageSecret: randomBytes(32), 
             ...message.messageContextInfo
         }
         innerMessage[key].contextInfo = {
@@ -1342,28 +1374,28 @@ const generateWAMessageFromContent = (jid, message, options) => {
         }
     }
 
-    message = Types_1.WAProto.Message.fromObject(message)
+    message = WAProto.Message.fromObject(message)
 
     const messageJSON = {
         key: {
             remoteJid: jid,
             fromMe: true,
-            id: options?.messageId || generics_1.generateMessageID()
+            id: options?.messageId || generateMessageID()
         },
         message: message,
         messageTimestamp: timestamp,
         messageStubParameters: [],
-        participant: WABinary_1.isJidGroup(jid) || WABinary_1.isJidStatusBroadcast(jid) ? userJid : undefined,
-        status: Types_1.WAMessageStatus.PENDING
+        participant: isJidGroup(jid) || isJidStatusBroadcast(jid) ? userJid : undefined,
+        status: WAMessageStatus.PENDING
     }
 
-    return Types_1.WAProto.WebMessageInfo.fromObject(messageJSON)
+    return WAProto.WebMessageInfo.fromObject(messageJSON)
 }
 
 const generateWAMessage = async (jid, content, options) => {
     options.logger = options?.logger?.child({ msgId: options.messageId })
 
-    return generateWAMessageFromContent(jid, await generateWAMessageContent(content, { newsletter: WABinary_1.isJidNewsletter(jid), ...options }), options)
+    return generateWAMessageFromContent(jid, await generateWAMessageContent(content, { newsletter: isJidNewsletter(jid), ...options }), options)
 }
 
 const getContentType = (content) => {
@@ -1517,9 +1549,9 @@ const updateMessageWithReceipt = (msg, receipt) => {
 
 /** Update the message with a new reaction */
 const updateMessageWithReaction = (msg, reaction) => {
-    const authorID = generics_1.getKeyAuthor(reaction.key)
+    const authorID = getKeyAuthor(reaction.key)
     const reactions = (msg.reactions || [])
-        .filter(r => generics_1.getKeyAuthor(r.key) !== authorID)
+        .filter(r => getKeyAuthor(r.key) !== authorID)
 
     reaction.text = reaction.text || ''
     reactions.push(reaction) 
@@ -1528,9 +1560,9 @@ const updateMessageWithReaction = (msg, reaction) => {
 
 /** Update the message with a new poll update */
 const updateMessageWithPollUpdate = (msg, update) => {
-    const authorID = generics_1.getKeyAuthor(update.pollUpdateMessageKey)
+    const authorID = getKeyAuthor(update.pollUpdateMessageKey)
     const votes = (msg.pollUpdates || [])
-        .filter(r => generics_1.getKeyAuthor(r.pollUpdateMessageKey) !== authorID)
+        .filter(r => getKeyAuthor(r.pollUpdateMessageKey) !== authorID)
 
     if (update.vote?.selectedOptions?.length) {
         votes.push(update)
@@ -1541,9 +1573,9 @@ const updateMessageWithPollUpdate = (msg, update) => {
 
 /** Update the message with a new event response*/
 const updateMessageWithEventResponse = (msg, update) => {
-    const authorID = generics_1.getKeyAuthor(update.eventResponseMessageKey)
+    const authorID = getKeyAuthor(update.eventResponseMessageKey)
     const responses = (msg.eventResponses || [])
-    	.filter(r => generics_1.getKeyAuthor(r.eventResponseMessageKey) !== authorID)
+    	.filter(r => getKeyAuthor(r.eventResponseMessageKey) !== authorID)
     
     responses.push(update) 
     msg.eventResponses = responses
@@ -1561,7 +1593,7 @@ function getAggregateVotesInPollMessage({ message, pollUpdates }, meId) {
     const opts = message?.pollCreationMessage?.options || message?.pollCreationMessageV2?.options || message?.pollCreationMessageV3?.options || []
 
     const voteHashMap = opts.reduce((acc, opt) => {
-        const hash = crypto_2.sha256(Buffer.from(opt.optionName || '')).toString()
+        const hash = sha256(Buffer.from(opt.optionName || '')).toString()
         acc[hash] = {
             name: opt.optionName || '',
             voters: []
@@ -1590,7 +1622,7 @@ function getAggregateVotesInPollMessage({ message, pollUpdates }, meId) {
                 data = voteHashMap[hash]
             }
 
-            voteHashMap[hash].voters.push(generics_1.getKeyAuthor(update.pollUpdateMessageKey, meId))
+            voteHashMap[hash].voters.push(getKeyAuthor(update.pollUpdateMessageKey, meId))
         }
     }
 
@@ -1616,9 +1648,9 @@ function getAggregateResponsesInEventMessage({ eventResponses }, meLid) {
     
     for (const update of eventResponses) {
     	const { response } = update.response || 0
-    	const responseType = WAProto_1.proto.Message.EventResponseMessage.EventResponseType[response]
+    	const responseType = proto.Message.EventResponseMessage.EventResponseType[response]
     	if (responseType !== 'UNKNOWN' && responseMap[responseType]) {
-    		responseMap[responseType].responders.push(generics_1.getKeyAuthor(update.eventResponseMessageKey, meLid)) 
+    		responseMap[responseType].responders.push(getKeyAuthor(update.eventResponseMessageKey, meLid)) 
     	}
     }
 
@@ -1676,7 +1708,7 @@ const downloadMediaMessage = async (message, type, options, ctx) => {
         const mContent = extractMessageContent(message.message)
 
         if (!mContent) {
-            throw new boom_1.Boom('No message present', { statusCode: 400, data: message })
+            throw new Boom('No message present', { statusCode: 400, data: message })
         }
 
         const contentType = getContentType(mContent)
@@ -1684,7 +1716,7 @@ const downloadMediaMessage = async (message, type, options, ctx) => {
         const media = contentType === 'productMessage' ? mContent[contentType]?.product?.productImage : mContent[contentType]
 
         if (!media || typeof media !== 'object' || (!('url' in media) && !('thumbnailDirectPath' in media))) {
-            throw new boom_1.Boom(`"${contentType}" message is not a media message`)
+            throw new Boom(`"${contentType}" message is not a media message`)
         }
 
         let download
@@ -1701,7 +1733,7 @@ const downloadMediaMessage = async (message, type, options, ctx) => {
             download = media
         }
 
-        const stream = await messages_media_1.downloadContentFromMessage(download, mediaType, options)
+        const stream = await downloadContentFromMessage(download, mediaType, options)
 
         if (type === 'buffer') {
             const bufferArray = []
@@ -1728,7 +1760,7 @@ const assertMediaContent = (content) => {
                 || content?.stickerMessage
 
     if (!mediaContent) {
-        throw new boom_1.Boom('given message is not a media message', { statusCode: 400, data: content })
+        throw new Boom('given message is not a media message', { statusCode: 400, data: content })
     }
     return mediaContent
 }