@systemzero/baileys 1.0.5 → 1.0.7

package/lib/Defaults/index.js

@@ -108,8 +108,8 @@ export const MEDIA_HKDF_KEY_MAPPING = {
 export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
 export const MIN_PREKEY_COUNT = 5;
 export const INITIAL_PREKEY_COUNT = 812;
-export const UPLOAD_TIMEOUT = 30000; // 30 seconds
-export const MIN_UPLOAD_INTERVAL = 5000; // 5 seconds minimum between uploads
+export const UPLOAD_TIMEOUT = 45000; // 45 segundos (era 30, uploads podem demorar mais em conexões lentas)
+export const MIN_UPLOAD_INTERVAL = 30000; // 30 segundos entre uploads normais (era 5s, muito agressivo)
 export const DEFAULT_CACHE_TTLS = {
     SIGNAL_STORE: 5 * 60, // 5 minutes
     MSG_RETRY: 60 * 60, // 1 hour

package/lib/Socket/chats.js

@@ -2,7 +2,7 @@ import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, PROCESSABLE_HISTORY_TYPES } from '../Defaults/index.js';
-import { ALL_WA_PATCH_NAMES } from '../Types/index.js';
+import { ALL_WA_PATCH_NAMES, WAMessageStubType } from '../Types/index.js';
 import { SyncState } from '../Types/State.js';
 import { chatModificationToAppPatch, decodePatches, decodeSyncdSnapshot, encodeSyncdPatch, extractSyncdPatches, generateProfilePicture, getHistoryMsg, newLTHashState, processSyncAction } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
@@ -787,6 +787,17 @@ export const makeChatsSocket = (config) => {
         await Promise.all([fetchProps(), fetchBlocklist(), fetchPrivacySettings()]);
     };
     const upsertMessage = ev.createBufferedFunction(async (msg, type) => {
+        // isSystemNotification — flag para filtrar notificações do sistema (E2E notices, etc)
+        const SYSTEM_STUB_TYPES = new Set([
+            WAMessageStubType.E2E_ENCRYPTED,
+            WAMessageStubType.E2E_DEVICE_CHANGED,
+            WAMessageStubType.E2E_IDENTITY_CHANGED,
+            WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP,
+            WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB
+        ]);
+        if (msg.messageStubType && SYSTEM_STUB_TYPES.has(msg.messageStubType)) {
+            msg.isSystemNotification = true;
+        }
         ev.emit('messages.upsert', { messages: [msg], type });
         if (!!msg.pushName) {
             let jid = msg.key.fromMe ? authState.creds.me.id : msg.key.participant || msg.key.remoteJid;

package/lib/Socket/groups.js

@@ -1,7 +1,7 @@
 import { proto } from '../../WAProto/index.js';
 import { WAMessageAddressingMode, WAMessageStubType } from '../Types/index.js';
 import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/index.js';
-import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isLidUser, isPnUser, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isLidUser, isPnUser, jidEncode, jidNormalizedUser, sharedLidPhoneCache } from '../WABinary/index.js';
 import { makeChatsSocket } from './chats.js';
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
@@ -312,11 +312,20 @@ export const extractGroupMetadata = (result) => {
         joinApprovalMode: !!getBinaryNodeChild(group, 'membership_approval_mode'),
         memberAddMode,
         participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
-            // TODO: Store LID MAPPINGS
+            const phoneNumber = isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined;
+            const lid = isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined;
+
+            // alimenta o cache compartilhado LID<->telefone com o que o
+            // WhatsApp já entrega pronto na lista de participantes do grupo —
+            // sem isso, sharedLidPhoneCache.getPhoneForLid() nunca resolve
+            // pra membros que só apareceram em grupo (nunca tiveram DM direta)
+            if (phoneNumber) sharedLidPhoneCache.set(attrs.jid, phoneNumber);
+            if (lid) sharedLidPhoneCache.set(lid, attrs.jid);
+
             return {
                 id: attrs.jid,
-                phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
-                lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+                phoneNumber,
+                lid,
                 admin: (attrs.type || null)
             };
         }),

package/lib/Socket/messages-recv.js

@@ -7,7 +7,7 @@ import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT } from '../Defaul
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
 import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, extractAddressingContext, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
-import { areJidsSameUser, binaryNodeToString, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { areJidsSameUser, binaryNodeToString, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET, sharedLidPhoneCache } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
 import { makeMessagesSocket } from './messages-send.js';
 export const makeMessagesRecvSocket = (config) => {
@@ -433,6 +433,13 @@ export const makeMessagesRecvSocket = (config) => {
         const actingParticipantPn = fullNode.attrs.participant_pn;
         const affectedParticipantLid = getBinaryNodeChild(child, 'participant')?.attrs?.jid || actingParticipantLid;
         const affectedParticipantPn = getBinaryNodeChild(child, 'participant')?.attrs?.phone_number || actingParticipantPn;
+        // alimenta cache síncrono com os pares LID↔JID do autor da notificação
+        if (isLidUser(actingParticipantLid) && isPnUser(actingParticipantPn)) {
+            sharedLidPhoneCache.set(actingParticipantLid, actingParticipantPn);
+        }
+        if (isLidUser(affectedParticipantLid) && isPnUser(affectedParticipantPn)) {
+            sharedLidPhoneCache.set(affectedParticipantLid, affectedParticipantPn);
+        }
         switch (child?.tag) {
             case 'create':
                 const metadata = extractGroupMetadata(child);
@@ -476,7 +483,12 @@ export const makeMessagesRecvSocket = (config) => {
                 const stubType = `GROUP_PARTICIPANT_${child.tag.toUpperCase()}`;
                 msg.messageStubType = WAMessageStubType[stubType];
                 const participants = getBinaryNodeChildren(child, 'participant').map(({ attrs }) => {
-                    // TODO: Store LID MAPPINGS
+                    // alimenta cache síncrono LID↔JID a partir de participant_pn / phone_number
+                    if (isLidUser(attrs.jid) && isPnUser(attrs.phone_number)) {
+                        sharedLidPhoneCache.set(attrs.jid, attrs.phone_number);
+                    } else if (isPnUser(attrs.jid) && isLidUser(attrs.lid)) {
+                        sharedLidPhoneCache.set(attrs.lid, attrs.jid);
+                    }
                     return {
                         id: attrs.jid,
                         phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
@@ -970,11 +982,21 @@ export const makeMessagesRecvSocket = (config) => {
                     await signalRepository.lidMapping.storeLIDPNMappings([{ lid: alt, pn: primaryJid }]);
                     await signalRepository.migrateSession(primaryJid, alt);
                 }
+                // alimenta cache síncrono LID→JID
+                if (isPnUser(primaryJid)) sharedLidPhoneCache.set(alt, primaryJid);
             }
             else {
                 await signalRepository.lidMapping.storeLIDPNMappings([{ lid: primaryJid, pn: alt }]);
                 await signalRepository.migrateSession(alt, primaryJid);
+                // alimenta cache síncrono LID→JID
+                if (isLidUser(primaryJid) && isPnUser(alt)) sharedLidPhoneCache.set(primaryJid, alt);
             }
+
+
+
+
+
+
         }
         if (msg.key?.remoteJid && msg.key?.id && messageRetryManager) {
             messageRetryManager.addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message);
@@ -994,6 +1016,18 @@ export const makeMessagesRecvSocket = (config) => {
                     }
                     const errorMessage = msg?.messageStubParameters?.[0] || '';
                     const isPreKeyError = errorMessage.includes('PreKey');
+                    // A mensagem nunca foi decifrada — não dá pra saber o conteúdo,
+                    // mas o evento é emitido mesmo assim para que sistemas de
+                    // anti-fraude tratem como suspeita/indecifrável em vez de ignorar.
+                    ev.emit('messages.decrypt-failed', {
+                        key: msg.key,
+                        remoteJid: msg.key?.remoteJid,
+                        participant: msg.key?.participant,
+                        messageId: msg.key?.id,
+                        isPreKeyError,
+                        errorMessage,
+                        timestamp: msg.messageTimestamp
+                    });
                     logger.debug(`[handleMessage] Attempting retry request for failed decryption`);
                     // Handle both pre-key and normal retries in single mutex
                     await retryMutex.mutex(async () => {
@@ -1002,14 +1036,20 @@ export const makeMessagesRecvSocket = (config) => {
                                 logger.debug({ node }, 'Connection closed, skipping retry');
                                 return;
                             }
-                            // Handle pre-key errors with upload and delay
                             if (isPreKeyError) {
                                 logger.info({ error: errorMessage }, 'PreKey error detected, uploading and retrying');
                                 try {
                                     logger.debug('Uploading pre-keys for error recovery');
-                                    await uploadPreKeys(5);
+                                    // Sobe mais chaves de uma vez (30 em vez de 5) — o WhatsApp
+                                    // às vezes precisa de um conjunto maior pra resolver conflitos
+                                    // de ID quando a sessão local ficou dessincronizada do servidor.
+                                    await uploadPreKeys(30, 0, true);
+                                    // Aumentado de 1000ms pra 2500ms — o servidor do WhatsApp
+                                    // precisa de mais tempo pra processar e distribuir as novas
+                                    // chaves antes de a gente tentar o retry, especialmente em
+                                    // casos de dessincronização severa.
                                     logger.debug('Waiting for server to process new pre-keys');
-                                    await delay(1000);
+                                    await delay(2500);
                                 }
                                 catch (uploadErr) {
                                     logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway');
@@ -1023,7 +1063,6 @@ export const makeMessagesRecvSocket = (config) => {
                         }
                         catch (err) {
                             logger.error({ err, isPreKeyError }, 'Failed to handle retry, attempting basic retry');
-                            // Still attempt retry even if pre-key upload failed
                             try {
                                 const encNode = getBinaryNodeChild(node, 'enc');
                                 await sendRetryRequest(node, !encNode);