@systemzero/baileys 1.0.5 → 1.0.7

package/lib/Utils/messages.js

@@ -8,7 +8,7 @@ import { WAMessageStatus, WAProto, ButtonHeaderType, ButtonType, CarouselCardTyp
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser, isLidUser, isPnUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
-import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData, getStream, toBuffer, getImageProcessingLibrary } from './messages-media.js';
+import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData, getStream, toBuffer, getImageProcessingLibrary, transcodeAudioToOpus } from './messages-media.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -77,9 +77,32 @@ export const prepareWAMessageMedia = async (message, options) => {
     }
 if (!uploadData.mimetype) {
     uploadData.mimetype = MIMETYPE_MAP[mediaType];
-} else if (mediaType === 'audio' && uploadData.mimetype === 'audio/ogg; codecs=opus') {
-    uploadData.mimetype = 'audio/mpeg';
 }
+// ptt: true → transcodifica de verdade pra opus/ogg mono 16kHz.
+// Antes, isso só trocava o RÓTULO do mimetype sem mudar os bytes reais,
+// o que fazia o WhatsApp mostrar "algo errado com o arquivo de áudio"
+// pra qualquer entrada que não já fosse opus puro.
+//
+// IMPORTANTE: não confia no `mimetype` que o CALLER declarou (a pessoa
+// pode escrever 'audio/ogg' mesmo passando um mp3/m4a de origem) — só
+// confia na extensão real do arquivo/URL de origem.
+let pttTranscodedPath;
+if (mediaType === 'audio' && uploadData.ptt === true) {
+    const mediaUrl = typeof uploadData.media === 'string'
+        ? uploadData.media
+        : uploadData.media?.url?.toString?.() || '';
+    const sourceLooksLikeOpus = /\.(opus|ogg)(\?|$)/i.test(mediaUrl);
+
+    if (!sourceLooksLikeOpus) {
+        const sourceForTranscode = Buffer.isBuffer(uploadData.media)
+            ? uploadData.media
+            : (typeof uploadData.media === 'string' ? uploadData.media : mediaUrl);
+        pttTranscodedPath = await transcodeAudioToOpus(sourceForTranscode);
+        uploadData.media = { url: pttTranscodedPath };
+    }
+    uploadData.mimetype = 'audio/ogg; codecs=opus';
+}
+
     if (cacheableKey) {
         const mediaBuff = await options.mediaCache.get(cacheableKey);
         if (mediaBuff) {
@@ -118,6 +141,10 @@ if (!uploadData.mimetype) {
         if (obj.stickerMessage) {
             obj.stickerMessage.stickerSentTs = Date.now();
         }
+        // lottie: stickerSentTs também no stickerMessage interno
+        if (obj.lottieStickerMessage?.message?.stickerMessage) {
+            obj.lottieStickerMessage.message.stickerMessage.stickerSentTs = Date.now();
+        }
         if (cacheableKey) {
             logger?.debug({ cacheableKey }, 'set cache');
             await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
@@ -126,10 +153,10 @@ if (!uploadData.mimetype) {
     }
     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;
+    const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true && typeof uploadData.waveform === 'undefined';
     const requiresPlaybackSpeed = mediaType === 'audio' && uploadData.ptt === true;
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
-    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
+    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation || requiresWaveformProcessing;
     const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
         logger,
         saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
@@ -188,6 +215,9 @@ if (!uploadData.mimetype) {
             if (originalFilePath) {
                 await fs.unlink(originalFilePath);
             }
+            if (pttTranscodedPath) {
+                await fs.unlink(pttTranscodedPath);
+            }
             logger?.debug('removed tmp files');
         }
         catch (error) {
@@ -472,6 +502,70 @@ const prepareNativeFlowButtons = (message) => {
             } else if (hasOptionalProperty(button, 'sections') && !!button.sections) {
                 return { name: 'single_select', buttonParamsJson: JSON.stringify({ title: buttonText || '📋 Select', sections: button.sections, icon: buttonIcon }) };
             }
+            // ── Botões estendidos (vanzxy) ──────────────────────────────────────
+            else if (hasOptionalProperty(button, 'reminder') && !!button.reminder) {
+                return { name: 'cta_reminder', buttonParamsJson: JSON.stringify({ display_text: buttonText || '⏰ Remind me', id: button.id || button.reminder, icon: buttonIcon }) };
+            }
+            else if (hasOptionalProperty(button, 'cancelReminder') && !!button.cancelReminder) {
+                return { name: 'cta_cancel_reminder', buttonParamsJson: JSON.stringify({ display_text: buttonText || '🔕 Cancel reminder', id: button.id || button.cancelReminder, icon: buttonIcon }) };
+            }
+            else if (hasOptionalProperty(button, 'address') && !!button.address) {
+                return { name: 'address_message', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📍 Send address', id: button.id || 'address_message' }) };
+            }
+            else if (hasOptionalProperty(button, 'location') && button.location === true) {
+                return { name: 'send_location', buttonParamsJson: JSON.stringify({}) };
+            }
+            else if (hasOptionalProperty(button, 'catalog') && !!button.catalog) {
+                return { name: 'catalog_message', buttonParamsJson: JSON.stringify({ business_phone_number: button.catalog.bizJid || button.catalog, display_text: buttonText || '🛍️ View catalog', id: button.id || 'catalog_message' }) };
+            }
+            else if (hasOptionalProperty(button, 'products') && !!button.products) {
+                return { name: 'mpm', buttonParamsJson: JSON.stringify({ business_phone_number: button.bizJid || button.products.bizJid, product_ids: Array.isArray(button.products) ? button.products : button.products.ids }) };
+            }
+            else if (hasOptionalProperty(button, 'otp') && !!button.otp) {
+                return { name: 'otp_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || 'Copy code', code: button.otp }) };
+            }
+            else if (hasOptionalProperty(button, 'oneTapOtp') && !!button.oneTapOtp) {
+                return { name: 'authentication_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || 'Autofill', code: button.oneTapOtp }) };
+            }
+            else if (hasOptionalProperty(button, 'phoneNumber') && !!button.phoneNumber) {
+                return { name: 'call_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📞 Call', phone_number: button.phoneNumber }) };
+            }
+            else if (hasOptionalProperty(button, 'urlBtn') && !!button.urlBtn) {
+                return { name: 'url_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || '🌐 Open', url: button.urlBtn }) };
+            }
+            else if (hasOptionalProperty(button, 'card') && !!button.card) {
+                return { name: 'card_message', buttonParamsJson: JSON.stringify(button.card) };
+            }
+            else if (hasOptionalProperty(button, 'orderDetails') && !!button.orderDetails) {
+                return { name: 'order_details', buttonParamsJson: JSON.stringify(button.orderDetails) };
+            }
+            else if (hasOptionalProperty(button, 'orderStatus') && !!button.orderStatus) {
+                return { name: 'order_status', buttonParamsJson: JSON.stringify(button.orderStatus) };
+            }
+            else if (hasOptionalProperty(button, 'trackOrder') && !!button.trackOrder) {
+                return { name: 'track_order', buttonParamsJson: JSON.stringify({ id: button.id || button.trackOrder, display_text: buttonText || '🚚 Track order' }) };
+            }
+            else if (hasOptionalProperty(button, 'reorder') && !!button.reorder) {
+                return { name: 'reorder', buttonParamsJson: JSON.stringify({ id: button.id || button.reorder, display_text: buttonText || '🔁 Reorder' }) };
+            }
+            else if (hasOptionalProperty(button, 'cancelOrder') && !!button.cancelOrder) {
+                return { name: 'cancel_order', buttonParamsJson: JSON.stringify({ id: button.id || button.cancelOrder, display_text: buttonText || '❌ Cancel order' }) };
+            }
+            else if (hasOptionalProperty(button, 'clearChat') && button.clearChat === true) {
+                return { name: 'clear_chat', buttonParamsJson: JSON.stringify({}) };
+            }
+            else if (hasOptionalProperty(button, 'screen') && !!button.screen) {
+                return { name: 'navigateToScreen', buttonParamsJson: JSON.stringify({ screen_name: button.screen, data: button.data || {} }) };
+            }
+            else if (hasOptionalProperty(button, 'flow') && !!button.flow) {
+                return { name: 'flow_action', buttonParamsJson: JSON.stringify({ flow_message_version: button.flow.version || '3', flow_id: button.flow.id, flow_cta: buttonText || button.flow.cta || 'Continue', flow_action: button.flow.action || 'navigate', flow_action_payload: button.flow.actionPayload || { screen: button.flow.screen || 'WELCOME', data: button.flow.data || {} } }) };
+            }
+            else if (hasOptionalProperty(button, 'voiceCall') && !!button.voiceCall) {
+                return { name: 'voice_call', buttonParamsJson: JSON.stringify({ display_text: buttonText || '📞 Voice call', id: button.id || button.voiceCall }) };
+            }
+            else if (hasOptionalProperty(button, 'videoCall') && !!button.videoCall) {
+                return { name: 'video_call_button', buttonParamsJson: JSON.stringify({ display_text: buttonText || '🎥 Video call', id: button.id || button.videoCall }) };
+            }
             return button;
         }),
         messageParamsJson: JSON.stringify(messageParamsJson)
@@ -936,7 +1030,12 @@ export const generateWAMessageContent = async (message, options) => {
         const key = m[messageType];
         if (key && 'contextInfo' in key && !!key.contextInfo) key.contextInfo.isGroupStatus = message.groupStatus;
         else if (key) key.contextInfo = { isGroupStatus: message.groupStatus };
-        m = { groupStatusMessageV2: { message: m } };
+        // Fix: audio PTT usa groupStatusMessage (v1) — V2 causa tela preta em versões antigas do WA
+        if (messageType === 'audioMessage') {
+            m = { groupStatusMessage: { message: m } };
+        } else {
+            m = { groupStatusMessageV2: { message: m } };
+        }
         delete message.groupStatus;
     }
     // ── spoiler ───────────────────────────────────────────────────────────────
@@ -961,6 +1060,12 @@ export const generateWAMessageContent = async (message, options) => {
     }
     // ── isLottie ──────────────────────────────────────────────────────────────
     if (hasOptionalProperty(message, 'isLottie') && !!message.isLottie) {
+        // marca o stickerMessage interno com isLottie: true para o WA renderizar como premium
+        if (m.stickerMessage) {
+            m.stickerMessage.isLottie = true;
+            m.stickerMessage.isAnimated = m.stickerMessage.isAnimated ?? false;
+            m.stickerMessage.isAiSticker = false;
+        }
         m = { lottieStickerMessage: { message: m } };
     }
     // ── viewOnceV2 / viewOnceV2Extension ──────────────────────────────────────
@@ -1094,7 +1199,8 @@ export const normalizeMessageContent = (content) => {
             message?.documentWithCaptionMessage ||
             message?.viewOnceMessageV2 ||
             message?.viewOnceMessageV2Extension ||
-            message?.editedMessage);
+            message?.editedMessage ||
+            message?.lottieStickerMessage);
     }
 };
 export const extractMessageContent = (content) => {

package/lib/Utils/payment-detection.js

@@ -0,0 +1,212 @@
+/**
+ * Detecção de mensagens de pagamento — incluindo cobranças STEALTH
+ * (ocultas para admins, indecifráveis pelo bot).
+ *
+ * @author Dev Gui (original), integrado na lib para System Zero. By Josué </>
+ */
+
+const MAX_PAYMENT_SCAN_DEPTH = 8;
+
+const PAYMENT_MESSAGE_KEYS = new Set([
+    'paymentInviteMessage',
+    'requestPaymentMessage',
+    'sendPaymentMessage',
+    'cancelPaymentRequestMessage',
+    'declinePaymentRequestMessage',
+]);
+
+function canScanObject(value) {
+    return value && typeof value === 'object' && !(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value);
+}
+
+function hasPaymentMessageKey(value, depth = 0, seenObjects = new WeakSet()) {
+    if (!canScanObject(value) || depth > MAX_PAYMENT_SCAN_DEPTH || seenObjects.has(value)) {
+        return false;
+    }
+
+    seenObjects.add(value);
+
+    for (const [key, childValue] of Object.entries(value)) {
+        if (key === 'quotedMessage') continue;
+
+        if (PAYMENT_MESSAGE_KEYS.has(key) && canScanObject(childValue)) {
+            return true;
+        }
+
+        if (hasPaymentMessageKey(childValue, depth + 1, seenObjects)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/** Verifica se a webMessage contém uma mensagem de pagamento — visível ou stealth. */
+export function hasPaymentMessage(webMessage) {
+    return hasPaymentMessageKey(webMessage?.message);
+}
+
+function findQuotedPaymentContext(value, depth = 0, seenObjects = new WeakSet()) {
+    if (!canScanObject(value) || depth > MAX_PAYMENT_SCAN_DEPTH || seenObjects.has(value)) {
+        return null;
+    }
+
+    seenObjects.add(value);
+
+    const contextInfo = value.contextInfo;
+
+    if (
+        canScanObject(contextInfo) &&
+        typeof contextInfo.participant === 'string' &&
+        canScanObject(contextInfo.quotedMessage) &&
+        hasPaymentMessageKey(contextInfo.quotedMessage)
+    ) {
+        return {
+            participant: contextInfo.participant,
+            stanzaId: typeof contextInfo.stanzaId === 'string' ? contextInfo.stanzaId : undefined,
+        };
+    }
+
+    for (const [key, childValue] of Object.entries(value)) {
+        if (key === 'quotedMessage') continue;
+        const found = findQuotedPaymentContext(childValue, depth + 1, seenObjects);
+        if (found) return found;
+    }
+
+    return null;
+}
+
+/**
+ * Lê a marcação (quoted) de uma mensagem de pagamento — inclusive as enviadas
+ * de forma oculta para admins — e devolve o autor original e o id da
+ * mensagem citada. Ignora citações aninhadas para não atribuir o pagamento errado.
+ */
+export function getQuotedPaymentContext(webMessage) {
+    return findQuotedPaymentContext(webMessage?.message);
+}
+
+// ─── Registro de envelopes (corroboração anti-forja) ──────────────────────
+
+const ENVELOPE_TTL_MS = 60 * 60 * 1000; // 1 hora
+const MAX_ENTRIES_PER_GROUP = 1000;
+
+// registry: Map<groupJid, Map<msgId, {participant, contentState, stealth, ts}>>
+const registry = new Map();
+
+const NON_CONTENT_KEYS = new Set(['messageContextInfo', 'senderKeyDistributionMessage']);
+
+function hasReadableContent(message) {
+    if (!message || typeof message !== 'object') return false;
+    return Object.keys(message).some((key) => !NON_CONTENT_KEYS.has(key));
+}
+
+function pruneGroup(groupMap) {
+    const now = Date.now();
+
+    for (const [id, entry] of groupMap) {
+        if (now - entry.ts > ENVELOPE_TTL_MS) {
+            groupMap.delete(id);
+        }
+    }
+
+    while (groupMap.size > MAX_ENTRIES_PER_GROUP) {
+        const oldestKey = groupMap.keys().next().value;
+        if (oldestKey === undefined) break;
+        groupMap.delete(oldestKey);
+    }
+}
+
+/**
+ * Registra o envelope de uma mensagem de grupo. `isPayment` é calculado pelo
+ * chamador (que já roda a detecção de pagamento) para evitar import cíclico.
+ */
+export function recordMessageEnvelope(webMessage, isPayment) {
+    const remoteJid = webMessage?.key?.remoteJid;
+    const id = webMessage?.key?.id;
+    const participant = webMessage?.key?.participant;
+
+    if (!remoteJid?.endsWith('@g.us') || !id || !participant) return;
+
+    let groupMap = registry.get(remoteJid);
+    if (!groupMap) {
+        groupMap = new Map();
+        registry.set(remoteJid, groupMap);
+    }
+
+    const contentState = isPayment ? 'payment' : hasReadableContent(webMessage?.message) ? 'other' : 'unreadable';
+
+    groupMap.set(id, {
+        participant,
+        contentState,
+        stealth: Boolean(webMessage?.stealthMeta),
+        ts: Date.now(),
+    });
+
+    pruneGroup(groupMap);
+}
+
+/**
+ * Decide se uma marcação de pagamento é confiável o bastante para punir o autor.
+ *
+ * - corroborated: o bot recebeu a mensagem original, do MESMO autor, e ela era
+ *   pagamento OU foi indecifrável (consistente com o truque stealth). Pode punir.
+ * - contradicted: o bot recebeu a mensagem, mas de OUTRO autor, ou ela era
+ *   conteúdo legível que não era pagamento. É forja. Nunca punir.
+ * - nenhum dos dois: o bot não viu a mensagem original. Sem corroboração, não pune.
+ */
+export function verifyQuotedAuthor({ groupJid, stanzaId, participant }) {
+    if (!stanzaId) return { corroborated: false, contradicted: false };
+
+    const entry = registry.get(groupJid)?.get(stanzaId);
+    if (!entry) return { corroborated: false, contradicted: false };
+
+    if (entry.participant !== participant) {
+        return { corroborated: false, contradicted: true };
+    }
+
+    if (entry.contentState === 'other') {
+        return { corroborated: false, contradicted: true };
+    }
+
+    return { corroborated: true, contradicted: false };
+}
+
+/** Apenas para testes: limpa o registro. */
+export function __clearEnvelopeRegistry() {
+    registry.clear();
+}
+
+// ─── Extração de valor monetário ───────────────────────────────────────────
+
+/**
+ * Extrai o valor monetário de um requestPaymentMessage / sendPaymentMessage.
+ * Retorna { value, currencyCode } ou null se não encontrar.
+ */
+export function extractPaymentAmount(webMessage) {
+    try {
+        const msg =
+            webMessage?.message?.requestPaymentMessage ||
+            webMessage?.message?.sendPaymentMessage ||
+            webMessage?.message?.paymentInviteMessage;
+
+        if (!msg) return null;
+
+        if (msg.amount && msg.amount.value !== undefined) {
+            const raw = typeof msg.amount.value === 'object' ? msg.amount.value.low ?? 0 : Number(msg.amount.value);
+            const offset = msg.amount.offset || 100;
+            return {
+                value: raw / offset,
+                currencyCode: msg.amount.currencyCode || msg.currencyCodeIso4217 || '???',
+            };
+        }
+
+        if (msg.amount1000 !== undefined) {
+            const raw = typeof msg.amount1000 === 'object' ? msg.amount1000.low ?? 0 : Number(msg.amount1000);
+            return { value: raw / 1000, currencyCode: msg.currencyCodeIso4217 || '???' };
+        }
+
+        return null;
+    } catch {
+        return null;
+    }
+}

package/lib/Utils/payment-guard.d.ts

@@ -0,0 +1,15 @@
+export interface PaymentGuardHooks {
+    isPaymentMessage: (webMessage: any) => boolean;
+    recordEnvelope?: (webMessage: any, isPayment: boolean) => void;
+    onDetect: (detection: {
+        type: 'direct' | 'edited' | 'undecryptable';
+        remoteJid: string;
+        participant?: string;
+        messageId?: string;
+        isPreKeyError?: boolean;
+        errorMessage?: string;
+    }) => void;
+    treatDecryptFailureAsSuspicious?: boolean;
+}
+
+export declare const bindPaymentGuard: (sock: any, hooks: PaymentGuardHooks) => () => void;

package/lib/Utils/payment-guard.js

@@ -0,0 +1,142 @@
+// lib/Utils/payment-guard.js
+//
+// Encanamento genérico para detecção de mensagens de pagamento "stealth"
+// (ocultas/editadas). A LIB não decide o que é payment — isso é lógica do
+// seu bot. Aqui só garantimos que NENHUM caminho de entrada fica sem cobrir:
+//
+//   1) Mensagem direta normal      -> 'messages.upsert'
+//   2) Mensagem EDITADA depois     -> 'messages.update' (protocolMessage MESSAGE_EDIT)
+//   3) Mensagem que falhou decrypt -> 'messages.decrypt-failed' (emitido pela lib)
+//
+// Limite real (sem prometer o impossível): uma mensagem que falha no decrypt
+// (PreKey/CIPHERTEXT) nunca foi lida pelo bot — não existe forma de "ver" que
+// é payment. O que dá pra garantir é que isso nunca passe em silêncio: o
+// evento é sempre emitido, e cabe ao seu detector decidir o que fazer com a
+// falta de conteúdo (ex: tratar como suspeito, igual ao 'unreadable' que você
+// já usa no seu messageEnvelopeRegistry).
+//
+// Você injeta sua própria lógica (paymentMessage.js, messageEnvelopeRegistry.js
+// etc. do seu bot) via callbacks — a lib não importa nada do seu projeto.
+
+/**
+ * @typedef {Object} PaymentGuardHooks
+ * @property {(webMessage: any) => boolean} isPaymentMessage
+ *   Função que decide se um webMessage (ou webMessage sintético de edição)
+ *   é uma mensagem de pagamento. Normalmente seu `hasPaymentMessage`.
+ * @property {(webMessage: any, isPayment: boolean) => void} [recordEnvelope]
+ *   Chamado para TODA mensagem de grupo vista (payment ou não), inclusive
+ *   falhas de decrypt (com `webMessage.message === null`). Normalmente seu
+ *   `recordMessageEnvelope`.
+ * @property {(detection: PaymentDetection) => void} onDetect
+ *   Chamado sempre que uma detecção (direta, editada ou indecifrável
+ *   suspeita) acontece.
+ * @property {boolean} [treatDecryptFailureAsSuspicious=true]
+ */
+
+/**
+ * @typedef {Object} PaymentDetection
+ * @property {'direct'|'edited'|'undecryptable'} type
+ * @property {string} remoteJid
+ * @property {string|undefined} participant
+ * @property {string|undefined} messageId
+ * @property {boolean} [isPreKeyError]
+ * @property {string} [errorMessage]
+ */
+
+const extractEditedContent = (updateEntry) => updateEntry?.update?.message?.editedMessage?.message || null;
+
+/**
+ * Liga o guard completo num socket Baileys. Chame uma vez, logo após criar o sock.
+ *
+ * @param {import('../Socket/index.js').WASocket} sock
+ * @param {PaymentGuardHooks} hooks
+ * @returns {() => void} função de cleanup que remove todos os listeners
+ */
+export const bindPaymentGuard = (sock, hooks) => {
+    const {
+        isPaymentMessage,
+        recordEnvelope = () => {},
+        onDetect = () => {},
+        treatDecryptFailureAsSuspicious = true,
+    } = hooks || {};
+
+    if (typeof isPaymentMessage !== 'function') {
+        throw new Error('bindPaymentGuard: hooks.isPaymentMessage é obrigatório');
+    }
+
+    // ── 1) Mensagens diretas ────────────────────────────────────────────────
+    const onUpsert = ({ messages }) => {
+        for (const webMessage of messages || []) {
+            const remoteJid = webMessage?.key?.remoteJid;
+            if (!remoteJid?.endsWith('@g.us')) continue;
+
+            const isPayment = isPaymentMessage(webMessage);
+            recordEnvelope(webMessage, isPayment);
+
+            if (isPayment) {
+                onDetect({
+                    type: 'direct',
+                    remoteJid,
+                    participant: webMessage.key?.participant,
+                    messageId: webMessage.key?.id,
+                });
+            }
+        }
+    };
+
+    // ── 2) Mensagens editadas (golpe de edição pós-envio) ───────────────────
+    const onUpdate = (updates) => {
+        for (const u of updates || []) {
+            const editedContent = extractEditedContent(u);
+            if (!editedContent) continue;
+
+            const remoteJid = u.key?.remoteJid;
+            if (!remoteJid?.endsWith('@g.us')) continue;
+
+            const syntheticWebMessage = { message: editedContent, key: u.key };
+            const isPayment = isPaymentMessage(syntheticWebMessage);
+            recordEnvelope(syntheticWebMessage, isPayment);
+
+            if (isPayment) {
+                onDetect({
+                    type: 'edited',
+                    remoteJid,
+                    participant: u.key?.participant,
+                    messageId: u.key?.id,
+                });
+            }
+        }
+    };
+
+    // ── 3) Falha de decrypt (PreKey / CIPHERTEXT) ───────────────────────────
+    const onDecryptFailed = (failInfo) => {
+        const remoteJid = failInfo?.remoteJid;
+        if (!remoteJid?.endsWith('@g.us')) return;
+
+        recordEnvelope(
+            { key: { remoteJid, id: failInfo.messageId, participant: failInfo.participant }, message: null },
+            false
+        );
+
+        if (treatDecryptFailureAsSuspicious) {
+            onDetect({
+                type: 'undecryptable',
+                remoteJid,
+                participant: failInfo.participant,
+                messageId: failInfo.messageId,
+                isPreKeyError: failInfo.isPreKeyError,
+                errorMessage: failInfo.errorMessage,
+            });
+        }
+    };
+
+    sock.ev.on('messages.upsert', onUpsert);
+    sock.ev.on('messages.update', onUpdate);
+    sock.ev.on('messages.decrypt-failed', onDecryptFailed);
+
+    return function unbindPaymentGuard() {
+        sock.ev.off('messages.upsert', onUpsert);
+        sock.ev.off('messages.update', onUpdate);
+        sock.ev.off('messages.decrypt-failed', onDecryptFailed);
+    };
+};

package/lib/Utils/resolve-lid-phone.js

@@ -0,0 +1,30 @@
+// lib/Utils/resolve-lid-phone.js
+// Garante a resolução de telefone real a partir de um @lid em grupo.
+//
+// O sharedLidPhoneCache só sabe o par LID<->telefone se a lib já tiver visto
+// esse mapeamento em algum evento. A fonte mais confiável é a própria
+// metadata do grupo (groupMetadata), onde o WhatsApp já entrega o par pronto
+// pra cada participante. Esta função força esse fetch + registro no cache.
+
+import { sharedLidPhoneCache } from '../WABinary/index.js';
+
+/**
+ * @param {import('../Socket/index.js').WASocket} sock
+ * @param {string} groupJid
+ * @param {string} lid - o @lid que você quer resolver pro telefone real
+ * @returns {Promise<string|undefined>} o JID de telefone (@s.whatsapp.net), ou undefined se não achar
+ */
+export const resolveLidPhoneFromGroup = async (sock, groupJid, lid) => {
+    // já está no cache? não precisa nem buscar metadata de novo
+    const cached = sharedLidPhoneCache.getPhoneForLid(lid);
+    if (cached) return cached;
+
+    try {
+        const metadata = await sock.groupMetadata(groupJid);
+        // o fetch já alimenta o sharedLidPhoneCache (fix aplicado em groups.js),
+        // então só precisamos ler de volta depois do fetch
+        return sharedLidPhoneCache.getPhoneForLid(lid);
+    } catch {
+        return undefined;
+    }
+};