@violetix/baileys 0.5.5 → 0.6.0

package/lib/Utils/messages.js

@@ -6,7 +6,6 @@ import { proto } from '../../WAProto/index.js';
 import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, DONATE_URL, LIBRARY_NAME, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
 import { AssociationType, ButtonHeaderType, ButtonType, CarouselCardType, ListType, ProtocolType, WAMessageStatus, WAProto } from '../Types/index.js';
 import { isLidUser, isPnUser, isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
-import { buildA2UIWidget } from './a2ui.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
 import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getImageProcessingLibrary, getRawMediaUploadData, getStream, toBuffer } from './messages-media.js';
@@ -50,7 +49,7 @@ export const generateLinkPreviewIfRequired = async (text, getUrlInfo, logger) =>
 const assertColor = async (color) => {
     let assertedColor;
     if (typeof color === 'number') {
-        assertedColor = color >>> 0;
+        assertedColor = color > 0 ? color : 0xffffffff + Number(color) + 1;
     }
     else {
         let hex = color.trim().replace('#', '');
@@ -58,18 +57,8 @@ const assertColor = async (color) => {
             hex = 'FF' + hex.padStart(6, '0');
         }
         assertedColor = parseInt(hex, 16);
+        return assertedColor;
     }
-    return assertedColor;
-};
-/**
- * Option identifier for an image poll: WhatsApp hashes the option name, appends the base64
- * media hash, and hashes that — `sha256(hex(sha256(name)) + base64(fileSha256))`. A vote carries
- * this hash, not the name, so it has to match byte for byte.
- */
-export const hashImagePollOption = (optionName, fileSha256) => {
-    const nameHash = sha256(Buffer.from(String(optionName), 'utf-8')).toString('hex');
-    const mediaHashB64 = fileSha256 ? Buffer.from(fileSha256).toString('base64') : '';
-    return sha256(Buffer.from(nameHash + mediaHashB64, 'utf-8')).toString('hex');
 };
 export const prepareWAMessageMedia = async (message, options) => {
     const logger = options.logger;
@@ -88,12 +77,11 @@ export const prepareWAMessageMedia = async (message, options) => {
     };
     delete uploadData[mediaType];
     // check if cacheable + generate cache key
-    const isNewsletter = !!options.jid && isJidNewsletter(options.jid);
     const cacheableKey = typeof uploadData.media === 'object' &&
         'url' in uploadData.media &&
         !!uploadData.media.url &&
         !!options.mediaCache &&
-        JSON.stringify([mediaType, options.mediaTypeOverride || mediaType, isNewsletter, uploadData.media.url.toString()]);
+        mediaType + ':' + uploadData.media.url.toString();
     if (mediaType === 'document' && !uploadData.fileName) {
         uploadData.fileName = 'file';
     }
@@ -105,12 +93,12 @@ export const prepareWAMessageMedia = async (message, options) => {
         if (mediaBuff) {
             logger?.debug({ cacheableKey }, 'got media cache hit');
             const obj = proto.Message.decode(mediaBuff);
-            // ptv entries are cached after videoMessage was renamed to ptvMessage
-            const key = obj.ptvMessage ? 'ptvMessage' : `${mediaType}Message`;
+            const key = `${mediaType}Message`;
             Object.assign(obj[key], { ...uploadData, media: undefined });
             return obj;
         }
     }
+    const isNewsletter = !!options.jid && isJidNewsletter(options.jid);
     if (isNewsletter) {
         logger?.info({ key: cacheableKey }, 'Preparing raw media for newsletter');
         const { filePath, fileSha256, fileLength } = await getRawMediaUploadData(uploadData.media, options.mediaTypeOverride || mediaType, logger);
@@ -151,9 +139,9 @@ export const prepareWAMessageMedia = async (message, options) => {
     const requiresDurationComputation = mediaType === 'audio' && typeof uploadData.seconds === 'undefined';
     const requiresThumbnailComputation = (mediaType === 'image' || mediaType === 'video') && typeof uploadData['jpegThumbnail'] === 'undefined';
     const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true && typeof uploadData.waveform === 'undefined';
-    const requiresAudioBackground = options.backgroundColor != null && mediaType === 'audio' && uploadData.ptt === true;
+    const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
-    const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength, streamingSidecar } = await 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
@@ -219,7 +207,6 @@ export const prepareWAMessageMedia = async (message, options) => {
             fileSha256,
             fileLength,
             mediaKeyTimestamp: unixTimestampSeconds(),
-            ...(streamingSidecar ? { streamingSidecar } : {}),
             ...uploadData,
             media: undefined
         })
@@ -259,7 +246,7 @@ const prepareProductMessage = async (message, options) => {
  */
 // Lia@Changes 21-04-26 --- Enhanced prepareStickerPackMessage
 const prepareStickerPackMessage = async (message, options) => {
-    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'GitHub: cv3inx', description = '🏷️ violetix/baileys' } = message;
+    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'GitHub: itsliaaa', description = '🏷️ itsliaaa/baileys' } = message;
     if (stickers.length > 60) {
         throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
     }
@@ -665,42 +652,46 @@ export const generateWAMessageContent = async (message, options) => {
                 thumbnailEncSha256: imageMessage.fileEncSha256
             };
         }
-        if (options.backgroundColor != null) {
+        if (options.backgroundColor) {
             extContent.backgroundArgb = await assertColor(options.backgroundColor);
         }
         if (options.font) {
             extContent.font = options.font;
         }
-        if (options.textColorArgb != null) {
+        if (options.textColorArgb) {
             extContent.textArgb = await assertColor(options.textColorArgb);
         }
         m.extendedTextMessage = extContent;
     }
-    // Lia@Changes 08-09-26 --- Accept group status content as { groupStatusMessage | groupStatusMessageV2 | groupStatus: { text|image|video|audio } }
     else if (hasNonNullishProperty(message, 'groupStatusMessage') ||
-        hasNonNullishProperty(message, 'groupStatusMessageV2') ||
-        (hasNonNullishProperty(message, 'groupStatus') && typeof message.groupStatus === 'object')) {
-        const inner = message.groupStatusMessageV2 || message.groupStatusMessage || message.groupStatus;
+        hasNonNullishProperty(message, 'groupStatusMessageV2')) {
+        const inner = hasNonNullishProperty(message, 'groupStatusMessageV2')
+            ? message.groupStatusMessageV2
+            : message.groupStatusMessage;
         const innerMessage = inner?.message || inner;
         if (!innerMessage || typeof innerMessage !== 'object') {
             throw new Boom('Invalid group status message', { statusCode: 400 }); // Lia@Note 08-09-26 --- To avoid bug 👀
         }
         const { backgroundColor, font, color, ...contentBody } = innerMessage;
-        if (backgroundColor) {
-            options.backgroundColor = backgroundColor;
-        }
-        if (font !== undefined) {
-            options.font = font;
-        }
-        if (color) {
-            options.textColorArgb = color;
-        }
+        if (backgroundColor) options.backgroundColor = backgroundColor;
+        if (font !== undefined) options.font = font;
+        if (color) options.textColorArgb = color;
         m = await generateWAMessageContent(contentBody, options);
         if (!hasOptionalProperty(m, 'groupStatusMessageV2')) {
             message.groupStatus = true; // Lia@Note 08-09-26 --- let the wrap below normalize it into groupStatusMessageV2
         }
-        else {
-            delete message.groupStatus; // Lia@Note 08-09-26 --- already wrapped, don't wrap twice
+    }
+    // Lia@Changes 08-09-26 --- Accept nested group status content { groupStatus: { text|image|video|audio } }
+    else if (hasNonNullishProperty(message, 'groupStatus') &&
+        message.groupStatus &&
+        typeof message.groupStatus === 'object') {
+        const { backgroundColor, font, color, ...contentBody } = message.groupStatus;
+        if (backgroundColor) options.backgroundColor = backgroundColor;
+        if (font !== undefined) options.font = font;
+        if (color) options.textColorArgb = color;
+        m = await generateWAMessageContent(contentBody, options);
+        if (!hasOptionalProperty(m, 'groupStatusMessageV2')) {
+            message.groupStatus = true;
         }
     }
     else if (hasNonNullishProperty(message, 'contacts')) {
@@ -885,10 +876,6 @@ export const generateWAMessageContent = async (message, options) => {
                     selectableOptionsCount: 1
                 };
             }
-            else if (message.poll.hideVoter || message.poll.canAddOption) {
-                // only poll v6 carries hideParticipantName / allowAddOption; older versions drop them
-                m.pollCreationMessageV6 = pollCreationMessage;
-            }
             else if (message.poll.selectableCount === 1) {
                 //poll v3 is for single select polls
                 m.pollCreationMessageV3 = pollCreationMessage;
@@ -903,36 +890,6 @@ export const generateWAMessageContent = async (message, options) => {
             messageSecret: message.poll.messageSecret || randomBytes(32)
         };
     }
-    // Image poll: the parent carries only the option names and their hashes. The images
-    // themselves travel as separate pollCreationOptionImageMessage children, associated back
-    // to this message by MEDIA_POLL — sendMessage sends those after the parent.
-    else if (hasNonNullishProperty(message, 'imagePoll')) {
-        if (!Array.isArray(message.imagePoll.options) || !message.imagePoll.options.length) {
-            throw new Boom('Invalid imagePoll options', { statusCode: 400 });
-        }
-        const selectableOptionsCount = message.imagePoll.selectableCount ?? 1;
-        if (selectableOptionsCount < 0 || selectableOptionsCount > message.imagePoll.options.length) {
-            throw new Boom(`imagePoll.selectableCount should be >= 0 and <= ${message.imagePoll.options.length}`, {
-                statusCode: 400
-            });
-        }
-        const missingHash = message.imagePoll.options.find(option => !option.optionHash);
-        if (missingHash) {
-            throw new Boom('imagePoll options must be prepared with hashImagePollOption; send via sendMessage instead of building the content by hand', { statusCode: 400 });
-        }
-        m.pollCreationMessageV3 = {
-            name: message.imagePoll.name,
-            selectableOptionsCount,
-            options: message.imagePoll.options.map(option => ({
-                optionName: option.optionName,
-                optionHash: option.optionHash
-            })),
-            pollContentType: proto.Message.PollContentType.IMAGE
-        };
-        m.messageContextInfo = {
-            messageSecret: message.imagePoll.messageSecret || randomBytes(32)
-        };
-    }
     // Lia@Changes 08-02-26 --- Add poll result snapshot message
     else if (hasNonNullishProperty(message, 'pollResult')) {
         const pollResultSnapshotMessage = {
@@ -1036,12 +993,6 @@ export const generateWAMessageContent = async (message, options) => {
             }
         };
     }
-    // An A2UI widget has no base content of its own — the interactive chain below replaces `m`
-    // wholesale. Without this it falls through to the media branch and is rejected as a media
-    // message, so a widget would need a dummy `text` to send at all.
-    else if (hasNonNullishProperty(message, 'a2ui')) {
-        m = {};
-    }
     else {
         m = await prepareWAMessageMedia(message, options);
     }
@@ -1165,31 +1116,6 @@ export const generateWAMessageContent = async (message, options) => {
             }
         };
     }
-    // A2UI widget. `nativeFlowMessage` is always set, even empty: it is what the client keys the
-    // interactive render off, and it is also what makes the socket attach the <biz> node.
-    else if (hasNonNullishProperty(message, 'a2ui')) {
-        const interactiveMessage = {
-            bloksWidget: buildA2UIWidget(message.a2ui, {
-                type: message.a2uiType,
-                wrapped: message.a2uiWrapped !== false
-            }),
-            nativeFlowMessage: hasNonNullishProperty(message, 'nativeFlow')
-                ? prepareNativeFlowButtons(message)
-                : { messageParamsJson: '' }
-        };
-        // singleScreen drops the surrounding bubble so the widget is the whole message
-        if (!message.singleScreen) {
-            interactiveMessage.header = { hasMediaAttachment: false };
-            interactiveMessage.body = { text: message.text || '' };
-            interactiveMessage.footer = { text: message.footer || '' };
-        }
-        m = {
-            interactiveMessage,
-            messageContextInfo: {
-                messageSecret: message.messageSecret || randomBytes(32)
-            }
-        };
-    }
     else if (hasNonNullishProperty(message, 'nativeFlow')) {
         const interactiveMessage = {
             nativeFlowMessage: prepareNativeFlowButtons(message)
@@ -1547,17 +1473,10 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         // newsletters don't support ephemeral messages
         !isNewsletter) {
         /* @ts-ignore */
-        // WA Web stamps the chat's disappearing-mode setting alongside the TTL; without it the
-        // peer warns that the message will not disappear. Callers pass the setting timestamp
-        // when they track it (there is no chat store here), the trigger defaults to CHAT_SETTING.
         innerMessage[key].contextInfo = {
             ...(innerMessage[key].contextInfo || {}),
-            expiration: options.ephemeralExpiration || WA_DEFAULT_EPHEMERAL,
-            ...(options.ephemeralSettingTimestamp ? { ephemeralSettingTimestamp: options.ephemeralSettingTimestamp } : {}),
-            disappearingMode: {
-                initiator: proto.DisappearingMode.Initiator.CHANGED_IN_CHAT,
-                trigger: options.disappearingModeTrigger ?? proto.DisappearingMode.Trigger.CHAT_SETTING
-            }
+            expiration: options.ephemeralExpiration || WA_DEFAULT_EPHEMERAL
+            //ephemeralSettingTimestamp: options.ephemeralOptions.eph_setting_ts?.toString()
         };
     }
     // Lia@Changes 30-01-26 --- Add deviceListMetadata inside messageContextInfo for private chat
@@ -1743,12 +1662,9 @@ export const updateMessageWithEventResponse = (msg, update) => {
  * @returns A list of options & their voters
  */
 export function getAggregateVotesInPollMessage({ message, pollUpdates }, meId) {
-    message = normalizeMessageContent(message);
     const opts = message?.pollCreationMessage?.options ||
         message?.pollCreationMessageV2?.options ||
         message?.pollCreationMessageV3?.options ||
-        message?.pollCreationMessageV5?.options ||
-        message?.pollCreationMessageV6?.options ||
         [];
     const voteHashMap = opts.reduce((acc, opt) => {
         const hash = sha256(Buffer.from(opt.optionName || '')).toString();
@@ -1794,10 +1710,7 @@ export function getAggregateResponsesInEventMessage({ eventResponses }, meId) {
         };
     }
     for (const update of eventResponses || []) {
-        const response = update.response?.response ?? update.eventResponse;
-        const responseType = typeof response === 'number'
-            ? proto.Message.EventResponseMessage.EventResponseType[response]
-            : response || 'UNKNOWN';
+        const responseType = update.eventResponse || 'UNKNOWN';
         if (responseType !== 'UNKNOWN' && responseMap[responseType]) {
             responseMap[responseType].responders.push(getKeyAuthor(update.eventResponseMessageKey, meId));
         }
@@ -1828,8 +1741,9 @@ const REUPLOAD_REQUIRED_STATUS = [410, 404];
  */
 export const downloadMediaMessage = async (message, type, options, ctx) => {
     const result = await downloadMsg().catch(async (error) => {
-        const status = error?.output?.statusCode ?? error?.status;
-        if (ctx && REUPLOAD_REQUIRED_STATUS.includes(status)) {
+        if (ctx &&
+            typeof error?.status === 'number' && // treat errors with status as HTTP failures requiring reupload
+            REUPLOAD_REQUIRED_STATUS.includes(error.status)) {
             ctx.logger.info({ key: message.key }, 'sending reupload media request...');
             // request reupload
             message = await ctx.reuploadRequest(message);
@@ -1957,4 +1871,4 @@ export const shouldIncludeBizBinaryNode = (message) => !!(message.buttonsMessage
     message.templateMessage ||
     (message.interactiveMessage &&
         message.interactiveMessage.nativeFlowMessage));
-//# sourceMappingURL=messages.js.map
+//# sourceMappingURL=messages.js.map

package/lib/Utils/process-message.d.ts

@@ -19,24 +19,6 @@ export function decryptPollVote({ encPayload, encIv }: {
  * @param ctx additional info about the event required for decryption
  * @returns event response message
  */
-export function decryptPollVoteWithFallback(vote: {
-    encPayload: Uint8Array;
-    encIv: Uint8Array;
-}, ctx: {
-    pollCreatorJids: (string | undefined | null)[];
-    voterJids: (string | undefined | null)[];
-    pollMsgId: string;
-    pollEncKey: Uint8Array;
-}): proto.Message.PollVoteMessage;
-export function decryptEventResponseWithFallback(response: {
-    encPayload: Uint8Array;
-    encIv: Uint8Array;
-}, ctx: {
-    eventCreatorJids: (string | undefined | null)[];
-    responderJids: (string | undefined | null)[];
-    eventMsgId: string;
-    eventEncKey: Uint8Array;
-}): proto.Message.EventResponseMessage;
 export function decryptEventResponse({ encPayload, encIv }: {
     encPayload: any;
     encIv: any;

package/lib/Utils/process-message.js

@@ -114,10 +114,7 @@ export const isRealMessage = (message) => {
         hasSomeContent &&
         !normalizedContent?.protocolMessage &&
         !normalizedContent?.reactionMessage &&
-        !normalizedContent?.pollUpdateMessage &&
-        // edit envelopes and event responses are not new chat messages (unread/timestamp bump)
-        !normalizedContent?.secretEncryptedMessage &&
-        !normalizedContent?.encEventResponseMessage);
+        !normalizedContent?.pollUpdateMessage);
 };
 export const shouldIncrementChatUnread = (message) => !message.key.fromMe && !message.messageStubType;
 /**
@@ -163,41 +160,6 @@ export function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsg
         return Buffer.from(txt);
     }
 }
-const uniqueJids = (jids) => [...new Set(jids.filter(j => typeof j === 'string' && j.length > 0))];
-/**
- * Try every (creator, voter) pair until one decrypts. Voters derive the key from the creator
- * JID in `pollCreationMessageKey` (LID after the addressing migration, PN before), while the
- * poll secret may have been stored under the other form, so a single pair is not enough.
- */
-export function decryptPollVoteWithFallback(vote, { pollCreatorJids, voterJids, pollMsgId, pollEncKey }) {
-    let lastErr;
-    for (const pollCreatorJid of uniqueJids(pollCreatorJids)) {
-        for (const voterJid of uniqueJids(voterJids)) {
-            try {
-                return decryptPollVote(vote, { pollCreatorJid, pollMsgId, pollEncKey, voterJid });
-            }
-            catch (err) {
-                lastErr = err;
-            }
-        }
-    }
-    throw lastErr || new Boom('no jid candidates to decrypt poll vote', { statusCode: 400 });
-}
-/** Same candidate walk as {@link decryptPollVoteWithFallback} for event responses. */
-export function decryptEventResponseWithFallback(response, { eventCreatorJids, responderJids, eventMsgId, eventEncKey }) {
-    let lastErr;
-    for (const eventCreatorJid of uniqueJids(eventCreatorJids)) {
-        for (const responderJid of uniqueJids(responderJids)) {
-            try {
-                return decryptEventResponse(response, { eventCreatorJid, eventMsgId, eventEncKey, responderJid });
-            }
-            catch (err) {
-                lastErr = err;
-            }
-        }
-    }
-    throw lastErr || new Boom('no jid candidates to decrypt event response', { statusCode: 400 });
-}
 /**
  * Decrypt an event response
  * @param response encrypted event response
@@ -348,14 +310,14 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         switch (protocolMsg.type) {
             case proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION:
                 const histNotification = protocolMsg.historySyncNotification;
-                const process = shouldProcessHistoryMsg;
+                const process = false; // shouldProcessHistoryMsg; // FORCE DISABLED
                 const isLatest = !creds.processedHistoryMessages?.length;
                 logger?.info({
                     histNotification,
                     process,
                     id: message.key.id,
                     isLatest
-                }, 'got history notification');
+                }, 'got history notification (ignored by force)');
                 if (process) {
                     // TODO: investigate
                     if (histNotification.syncType !== proto.HistorySync.HistorySyncType.ON_DEMAND) {
@@ -535,34 +497,23 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         if (eventMsg) {
             try {
                 const meIdNormalised = jidNormalizedUser(meId);
-                const meLidNormalised = creds.me.lid ? jidNormalizedUser(creds.me.lid) : undefined;
-                // the responder encrypted with whichever form of the creator JID it holds (PN or
-                // LID); try the PN form first (previous behaviour), then the other form
-                const eventCreatorKey = jidNormalizedUser(creationMsgKey.participant || creationMsgKey.remoteJid);
-                const eventCreatorAlt = isLidUser(eventCreatorKey)
+                // all jids need to be PN
+                const eventCreatorKey = creationMsgKey.participant || creationMsgKey.remoteJid;
+                const eventCreatorPn = isLidUser(eventCreatorKey)
                     ? await signalRepository.lidMapping.getPNForLID(eventCreatorKey)
-                    : await signalRepository.lidMapping.getLIDForPN(eventCreatorKey);
-                const eventCreatorAltNorm = eventCreatorAlt ? jidNormalizedUser(eventCreatorAlt) : undefined;
-                const eventCreatorJids = creationMsgKey.fromMe
-                    ? [meIdNormalised, meLidNormalised]
-                    : isLidUser(eventCreatorKey)
-                        ? [eventCreatorAltNorm, eventCreatorKey]
-                        : [eventCreatorKey, eventCreatorAltNorm];
-                const responderJids = [
-                    getKeyAuthor(message.key, meIdNormalised),
-                    jidNormalizedUser(message.key.participant || message.key.remoteJid || ''),
-                    message.key.fromMe ? meLidNormalised : undefined
-                ];
+                    : eventCreatorKey;
+                const eventCreatorJid = getKeyAuthor({ remoteJid: jidNormalizedUser(eventCreatorPn), fromMe: meIdNormalised === eventCreatorPn }, meIdNormalised);
+                const responderJid = getKeyAuthor(message.key, meIdNormalised);
                 const eventEncKey = eventMsg?.messageContextInfo?.messageSecret;
                 if (!eventEncKey) {
                     logger?.warn({ creationMsgKey }, 'event response: missing messageSecret for decryption');
                 }
                 else {
-                    const responseMsg = decryptEventResponseWithFallback(encEventResponse, {
+                    const responseMsg = decryptEventResponse(encEventResponse, {
                         eventEncKey,
-                        eventCreatorJids,
+                        eventCreatorJid,
                         eventMsgId: creationMsgKey.id,
-                        responderJids
+                        responderJid
                     });
                     const eventResponse = {
                         eventResponseMessageKey: message.key,
@@ -741,38 +692,28 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                 emitGroupRequestJoin(participant, action, method);
                 break;
         }
-    }
-    else if (content?.pollUpdateMessage) {
-        const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey;
-        // the poll secret lives on the creation message; without it there is nothing to decrypt with
-        const pollMsg = creationMsgKey ? await getMessage(creationMsgKey) : undefined;
-        const pollEncKey = pollMsg?.messageContextInfo?.messageSecret;
-        if (!pollEncKey) {
-            logger?.debug({ creationMsgKey }, 'poll creation message or its secret not found, cannot decrypt vote');
-        }
-        else {
+    } /*  else if(content?.pollUpdateMessage) {
+        const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey!
+        // we need to fetch the poll creation message to get the poll enc key
+        // TODO: make standalone, remove getMessage reference
+        // TODO: Remove entirely
+        const pollMsg = await getMessage(creationMsgKey)
+        if(pollMsg) {
+            const meIdNormalised = jidNormalizedUser(meId)
+            const pollCreatorJid = getKeyAuthor(creationMsgKey, meIdNormalised)
+            const voterJid = getKeyAuthor(message.key, meIdNormalised)
+            const pollEncKey = pollMsg.messageContextInfo?.messageSecret!
+
             try {
-                const meIdNormalised = jidNormalizedUser(meId);
-                const meLidNormalised = creds.me.lid ? jidNormalizedUser(creds.me.lid) : undefined;
-                // voters derive the key from whichever form (PN or LID) of the creator JID they hold
-                const creatorPrimary = jidNormalizedUser(creationMsgKey.participant || creationMsgKey.remoteJid || '');
-                const creatorAlt = isLidUser(creatorPrimary)
-                    ? await signalRepository.lidMapping.getPNForLID(creatorPrimary)
-                    : await signalRepository.lidMapping.getLIDForPN(creatorPrimary);
-                const pollCreatorJids = creationMsgKey.fromMe
-                    ? [meIdNormalised, meLidNormalised]
-                    : [getKeyAuthor(creationMsgKey, meIdNormalised), creatorPrimary, creatorAlt ? jidNormalizedUser(creatorAlt) : undefined];
-                const voterJids = [
-                    getKeyAuthor(message.key, meIdNormalised),
-                    jidNormalizedUser(message.key.participant || message.key.remoteJid || ''),
-                    message.key.fromMe ? meLidNormalised : undefined
-                ];
-                const vote = decryptPollVoteWithFallback(content.pollUpdateMessage.vote, {
-                    pollEncKey,
-                    pollCreatorJids,
-                    voterJids,
-                    pollMsgId: creationMsgKey.id
-                });
+                const voteMsg = decryptPollVote(
+                    content.pollUpdateMessage.vote!,
+                    {
+                        pollEncKey,
+                        pollCreatorJid,
+                        pollMsgId: creationMsgKey.id!,
+                        voterJid,
+                    }
+                )
                 ev.emit('messages.update', [
                     {
                         key: creationMsgKey,
@@ -780,19 +721,26 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                             pollUpdates: [
                                 {
                                     pollUpdateMessageKey: message.key,
-                                    vote,
-                                    senderTimestampMs: toNumber(content.pollUpdateMessage.senderTimestampMs)
+                                    vote: voteMsg,
+                                    senderTimestampMs: (content.pollUpdateMessage.senderTimestampMs! as Long).toNumber(),
                                 }
                             ]
                         }
                     }
-                ]);
-            }
-            catch (err) {
-                logger?.warn({ err, creationMsgKey }, 'failed to decrypt poll vote');
+                ])
+            } catch(err) {
+                logger?.warn(
+                    { err, creationMsgKey },
+                    'failed to decrypt poll vote'
+                )
             }
+        } else {
+            logger?.warn(
+                { creationMsgKey },
+                'poll creation message not found, cannot decrypt update'
+            )
         }
-    }
+        } */
     if (Object.keys(chat).length > 1) {
         ev.emit('chats.update', [chat]);
     }

package/lib/Utils/rich-message-utils.js

@@ -99,7 +99,7 @@ export const toUnified = (submessages, uuid) => ({
     })
 });
 export const prepareRichResponseMessage = (content) => {
-    const { alignment, code, contentText, disclaimerText, footerText, headerText, imageText, inlineImage, inlineVideo, items, language = 'javascript', latex, links, noHeading, posts, products, suggested, richResponse, table, tapLinkUrl, title } = content;
+    const { alignment, code, contentText, disclaimerText, footerText, headerText, imageText, inlineImage, inlineVideo, items, language, latex, links, noHeading, posts, products, suggested, richResponse, table, tapLinkUrl, title } = content;
     let submessages = [];
     if (Array.isArray(richResponse)) {
         submessages = richResponse.map((submessage) => {
@@ -198,6 +198,7 @@ export const prepareRichResponseMessage = (content) => {
             });
         }
         if (code) {
+            language ||= 'javascript';
             submessages.push({
                 messageType: RichSubMessageType.CODE,
                 codeMetadata: {
@@ -236,7 +237,7 @@ export const prepareRichResponseMessage = (content) => {
             submessages.push({
                 messageType: RichSubMessageType.LATEX,
                 latexMetadata: {
-                    text: contentText,
+                    text,
                     expressions: latex
                 }
             });
@@ -366,4 +367,4 @@ export const wrapToBotForwardedMessage = (richResponseMessage) => ({
         message: { richResponseMessage }
     }
 });
-//# sourceMappingURL=rich-message-utils.js.map
+//# sourceMappingURL=rich-message-utils.js.map

package/lib/Utils/use-multi-file-auth-state.d.ts

@@ -1,4 +1,4 @@
-export function useMultiFileAuthState(folder: any, logger?: any): Promise<{
+export function useMultiFileAuthState(folder: any): Promise<{
     state: {
         creds: any;
         keys: {
@@ -6,8 +6,6 @@ export function useMultiFileAuthState(folder: any, logger?: any): Promise<{
             set: (data: any) => Promise<void>;
         };
     };
-    saveCreds: () => void;
-    _flushCreds: () => Promise<void>;
-    _destroy: () => void;
+    saveCreds: () => Promise<any>;
 }>;
-//# sourceMappingURL=use-multi-file-auth-state.d.ts.map
+//# sourceMappingURL=use-multi-file-auth-state.d.ts.map