aunubaileys 1.0.33 → 1.0.35

package/README.md

@@ -64,6 +64,14 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🆕 What's new in 1.0.35 / Baru di 1.0.35
+
+- 📡 **Decrypt failures now emit a structured signal instead of a log flood** — one rotten session can fail hundreds of messages in minutes (B-01), and every failure was logged at ERROR level, drowning the logs while the bot had no programmatic way to know a Bad MAC flood was happening. Now: (1) the decrypt error log is throttled per sender address — first line immediately, then at most one line per minute per sender carrying the suppressed-failure count; (2) a new `messages.decrypt-failure` event carries the chat, sender, signal address, consecutive failure count, and whether this failure tripped the session/sender-key reset — consumers can alert and aggregate without parsing logs. The failure handling itself is unchanged. Closing release of the 1.0.14–1.0.35 fix train.
+
+### 🆕 What's new in 1.0.34 / Baru di 1.0.34
+
+- 🗳️ **One person no longer counts as two poll voters across the LID/PN split** — poll aggregation keyed voters by their raw message-key identity, so someone voting first as a phone number and later as a LID (or the reverse) counted as two different voters, and a poll update arriving in the other identity form piled up as a second entry instead of replacing the old one. `getAggregateVotesInPollMessage` and `updateMessageWithPollUpdate` now accept an optional `{ lidStore }` option: voters are canonicalized to their phone-number JID and deduped per option. Without a store, legacy behaviour is unchanged.
+
 ### 🆕 What's new in 1.0.33 / Baru di 1.0.33
 
 - 💓 **One lost keep-alive pong no longer kills the connection** — upstream ended the connection as soon as the gap since last inbound traffic exceeded one interval + 5s; on a quiet connection the ping response is the only inbound traffic, so a single lost pong killed a healthy connection and forced a full reconnect. The connection is now ended only after two consecutive intervals without a reply; genuinely dead connections are still detected, one interval later.

package/lib/Socket/messages-recv.js

@@ -751,6 +751,19 @@ export const makeMessagesRecvSocket = (config) => {
                                         else {
                                             decryptFailCounts.set(failKey, fails);
                                         }
+                                        // AunuBaileys: structured decrypt-failure event so
+                                        // consumers can alert and aggregate on Bad MAC
+                                        // floods (B-01) instead of parsing log lines.
+                                        ev.emit('messages.decrypt-failure', {
+                                            remoteJid: msg.key.remoteJid,
+                                            author,
+                                            address: addr,
+                                            isGroup: isGroupMsg,
+                                            failures: fails,
+                                            healed: fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT,
+                                            messageId: node.attrs.id,
+                                            timestamp: Date.now()
+                                        });
                                     }
                                     catch (healErr) {
                                         logger.debug({ err: healErr }, 'aunu: session self-heal step failed, continuing with normal retry');

package/lib/Types/Events.d.ts

@@ -43,6 +43,21 @@ export type BaileysEventMap = {
     };
     'contacts.upsert': Contact[];
     'contacts.update': Partial<Contact>[];
+    'messages.decrypt-failure': {
+        /** the chat the failed message arrived in */
+        remoteJid: string;
+        /** sender JID (participant in groups) */
+        author: string;
+        /** signal-protocol address the failure was counted against */
+        address: string;
+        isGroup: boolean;
+        /** consecutive failures for this address, including this one */
+        failures: number;
+        /** true when this failure tripped the session/sender-key reset */
+        healed: boolean;
+        messageId: string;
+        timestamp: number;
+    };
     'messages.delete': {
         keys: WAMessageKey[];
     } | {

package/lib/Utils/decode-wa-message.js

@@ -109,6 +109,26 @@ export function decodeMessageNode(stanza, meId, meLid) {
         sender: msgType === 'chat' ? author : chatId
     };
 }
+// AunuBaileys: per-address throttle for the per-message decrypt error log.
+// One rotten session can fail hundreds of messages in minutes (B-01: every
+// failure from a single LID address flooded the logs at ERROR level); the
+// first failure per address logs immediately, then at most one line per
+// minute, carrying how many failures were suppressed in between. Nothing
+// about the failure handling itself changes — only the log volume.
+const DECRYPT_ERROR_LOG_INTERVAL_MS = 60_000;
+const decryptErrorLogState = new Map();
+const logDecryptErrorThrottled = (logger, address, key, err) => {
+    const now = Date.now();
+    const state = decryptErrorLogState.get(address) || { lastLoggedAt: 0, suppressed: 0 };
+    if (now - state.lastLoggedAt >= DECRYPT_ERROR_LOG_INTERVAL_MS) {
+        logger.error({ key, err, suppressedFailures: state.suppressed }, 'failed to decrypt message');
+        decryptErrorLogState.set(address, { lastLoggedAt: now, suppressed: 0 });
+    }
+    else {
+        decryptErrorLogState.set(address, { ...state, suppressed: state.suppressed + 1 });
+    }
+};
+
 export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
     const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid);
     return {
@@ -171,7 +191,7 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                                 });
                             }
                             catch (err) {
-                                logger.error({ key: fullMessage.key, err }, 'failed to decrypt message');
+                                logDecryptErrorThrottled(logger, author, fullMessage.key, err);
                             }
                         }
                         if (fullMessage.message) {
@@ -182,7 +202,7 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                         }
                     }
                     catch (err) {
-                        logger.error({ key: fullMessage.key, err }, 'failed to decrypt message');
+                        logDecryptErrorThrottled(logger, author, fullMessage.key, err);
                         fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
                         fullMessage.messageStubParameters = [err.message];
                     }

package/lib/Utils/messages.d.ts

@@ -44,7 +44,7 @@ export declare const updateMessageWithReceipt: (msg: Pick<WAMessage, "userReceip
 /** Update the message with a new reaction */
 export declare const updateMessageWithReaction: (msg: Pick<WAMessage, "reactions">, reaction: proto.IReaction) => void;
 /** Update the message with a new poll update */
-export declare const updateMessageWithPollUpdate: (msg: Pick<WAMessage, "pollUpdates">, update: proto.IPollUpdate) => void;
+export declare const updateMessageWithPollUpdate: (msg: Pick<WAMessage, "pollUpdates">, update: proto.IPollUpdate, options?: PollLIDOptions) => void;
 type VoteAggregation = {
     name: string;
     voters: string[];
@@ -55,7 +55,8 @@ type VoteAggregation = {
  * @param meId your jid
  * @returns A list of options & their voters
  */
-export declare function getAggregateVotesInPollMessage({ message, pollUpdates }: Pick<WAMessage, 'pollUpdates' | 'message'>, meId?: string): VoteAggregation[];
+export interface PollLIDOptions { lidStore?: { getPNForLID(jid: string): string | undefined }; }
+export declare function getAggregateVotesInPollMessage({ message, pollUpdates }: Pick<WAMessage, 'pollUpdates' | 'message'>, meId?: string, options?: PollLIDOptions): VoteAggregation[];
 /** Given a list of message keys, aggregates them by chat & sender. Useful for sending read receipts in bulk */
 export declare const aggregateMessageKeysNotFromMe: (keys: proto.IMessageKey[]) => {
     jid: string;

package/lib/Utils/messages.js

@@ -1008,9 +1008,16 @@ export const updateMessageWithReaction = (msg, reaction) => {
     msg.reactions = reactions;
 };
 /** Update the message with a new poll update */
-export const updateMessageWithPollUpdate = (msg, update) => {
-    const authorID = getKeyAuthor(update.pollUpdateMessageKey);
-    const reactions = (msg.pollUpdates || []).filter(r => getKeyAuthor(r.pollUpdateMessageKey) !== authorID);
+export const updateMessageWithPollUpdate = (msg, update, options) => {
+    // AunuBaileys: normalize the voter through the LID store when one is
+    // given, so a vote arriving in the other identity form REPLACES the
+    // voter's earlier update instead of piling up as a second voter.
+    const resolveVoter = (key) => {
+        const author = getKeyAuthor(key);
+        return options?.lidStore?.getPNForLID?.(author) || author;
+    };
+    const authorID = resolveVoter(update.pollUpdateMessageKey);
+    const reactions = (msg.pollUpdates || []).filter(r => resolveVoter(r.pollUpdateMessageKey) !== authorID);
     if (update.vote?.selectedOptions?.length) {
         reactions.push(update);
     }
@@ -1022,7 +1029,7 @@ export const updateMessageWithPollUpdate = (msg, update) => {
  * @param meId your jid
  * @returns A list of options & their voters
  */
-export function getAggregateVotesInPollMessage({ message, pollUpdates }, meId) {
+export function getAggregateVotesInPollMessage({ message, pollUpdates }, meId, options) {
     const opts = message?.pollCreationMessage?.options ||
         message?.pollCreationMessageV2?.options ||
         message?.pollCreationMessageV3?.options ||
@@ -1050,7 +1057,15 @@ export function getAggregateVotesInPollMessage({ message, pollUpdates }, meId) {
                 };
                 data = voteHashMap[hash];
             }
-            voteHashMap[hash].voters.push(getKeyAuthor(update.pollUpdateMessageKey, meId));
+            // AunuBaileys: voters are canonicalized to their phone-number
+            // JID through the LID store when one is given, and deduped per
+            // option — without this, one person voting first as PN and
+            // later as LID counted as two different voters.
+            const voter = getKeyAuthor(update.pollUpdateMessageKey, meId);
+            const canonicalVoter = options?.lidStore?.getPNForLID?.(voter) || voter;
+            if (!data.voters.includes(canonicalVoter)) {
+                data.voters.push(canonicalVoter);
+            }
         }
     }
     return Object.values(voteHashMap);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "description": "AunuBaileys \u2014 a WhatsApp Web API for bots that never sleep. Full upstream power with the beloved in-memory store restored and pairing that just works. Forged by AunuCore.",
   "keywords": [
     "whatsapp",