@systemzero/baileys 1.0.4 → 1.0.6

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;
+    }
+};

package/lib/WABinary/jid-utils.js

@@ -93,4 +93,248 @@ export const transferDevice = (fromJid, toJid) => {
     const { server, user } = jidDecode(toJid);
     return jidEncode(user, server, deviceId);
 };
-//# sourceMappingURL=jid-utils.js.map
+//# sourceMappingURL=jid-utils.js.map
+// ══════════════════════════════════════════════════════════════════════
+//  Sistema LID/JID avançado — integrado da chromestaff-baileys
+//  + suporte a @username (novo recurso WhatsApp)
+// ══════════════════════════════════════════════════════════════════════
+
+// ── LRU Cache leve (sem dependências externas) ────────────────────────
+class SimpleLRU {
+    constructor(maxSize = 2000, ttl = 5 * 60 * 1000) {
+        this.maxSize = maxSize;
+        this.ttl = ttl;
+        this.map = new Map();
+    }
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry) return undefined;
+        if (Date.now() - entry.ts > this.ttl) { this.map.delete(key); return undefined; }
+        this.map.delete(key);
+        this.map.set(key, entry);
+        return entry.value;
+    }
+    set(key, value) {
+        if (this.map.has(key)) this.map.delete(key);
+        this.map.set(key, { value, ts: Date.now() });
+        if (this.map.size > this.maxSize) {
+            const lru = this.map.keys().next().value;
+            if (lru) this.map.delete(lru);
+        }
+    }
+}
+
+const lidToJidCache = new SimpleLRU(2000, 5 * 60 * 1000);
+
+// ── Cache bidirecional LID ↔ JID (singleton do módulo) ───────────────
+const _sharedLidPhoneMap = new Map();
+const SHARED_MAP_MAX_SIZE = 3000;
+
+export const sharedLidPhoneCache = {
+    set(lid, phoneJid) {
+        if (!lid || !phoneJid || typeof lid !== 'string' || typeof phoneJid !== 'string') return;
+        if (!phoneJid.includes('@')) phoneJid = phoneJid + '@s.whatsapp.net';
+        if (_sharedLidPhoneMap.size > SHARED_MAP_MAX_SIZE * 2) {
+            const it = _sharedLidPhoneMap.keys();
+            const toRemove = Math.floor(_sharedLidPhoneMap.size * 0.25);
+            for (let i = 0; i < toRemove; i++) {
+                const k = it.next().value;
+                if (k === undefined) break;
+                _sharedLidPhoneMap.delete(k);
+            }
+        }
+        _sharedLidPhoneMap.set(lid, phoneJid);
+        _sharedLidPhoneMap.set(phoneJid, lid);
+        lidToJidCache.set(lid, phoneJid);
+    },
+    get: (key) => _sharedLidPhoneMap.get(key),
+    getLidForPhone(phoneJid) {
+        if (!phoneJid) return undefined;
+        const val = _sharedLidPhoneMap.get(phoneJid);
+        return val && val.endsWith('@lid') ? val : undefined;
+    },
+    getPhoneForLid(lid) {
+        if (!lid) return undefined;
+        const val = _sharedLidPhoneMap.get(lid);
+        return val && val.endsWith('@s.whatsapp.net') ? val : undefined;
+    },
+    get size() { return _sharedLidPhoneMap.size; }
+};
+
+// ── BOT_MAP estático (Meta AI bots conhecidos) ────────────────────────
+const BOT_MAP_STATIC = new Map([["867051314767696","13135550002"],["1061492271844689","13135550005"],["245886058483988","13135550009"],["3509905702656130","13135550012"],["1059680132034576","13135550013"],["715681030623646","13135550014"],["1644971366323052","13135550015"],["582497970646566","13135550019"],["645459357769306","13135550022"],["294997126699143","13135550023"],["1522631578502677","13135550027"],["719421926276396","13135550030"],["1788488635002167","13135550031"],["24232338603080193","13135550033"],["689289903143209","13135550035"],["871626054177096","13135550039"],["362351902849370","13135550042"],["1744617646041527","13135550043"],["893887762270570","13135550046"],["1155032702135830","13135550047"],["333931965993883","13135550048"],["853748013058752","13135550049"],["1559068611564819","13135550053"],["890487432705716","13135550054"],["240254602395494","13135550055"],["1578420349663261","13135550062"],["322908887140421","13135550065"],["3713961535514771","13135550067"],["997884654811738","13135550070"],["403157239387035","13135550081"],["535242369074963","13135550082"],["946293427247659","13135550083"],["3664707673802291","13135550084"],["1821827464894892","13135550085"],["1760312477828757","13135550086"],["439480398712216","13135550087"],["1876735582800984","13135550088"],["984025089825661","13135550089"],["1001336351558186","13135550090"],["3739346336347061","13135550091"],["3632749426974980","13135550092"],["427864203481615","13135550093"],["1434734570493055","13135550094"],["992873449225921","13135550095"],["813087747426445","13135550096"],["806369104931434","13135550098"],["1220982902403148","13135550099"],["1365893374104393","13135550100"],["686482033622048","13135550200"],["1454999838411253","13135550201"],["718584497008509","13135550202"],["743520384213443","13135550301"],["1147715789823789","13135550302"],["1173034540372201","13135550303"],["974785541030953","13135550304"],["1122200255531507","13135550305"],["899669714813162","13135550306"],["631880108970650","13135550307"],["435816149330026","13135550308"],["1368717161184556","13135550309"],["7849963461784891","13135550310"],["3609617065968984","13135550312"],["356273980574602","13135550313"],["1043447920539760","13135550314"],["1052764336525346","13135550315"],["2631118843732685","13135550316"],["510505411332176","13135550317"],["1945664239227513","13135550318"],["1518594378764656","13135550319"],["1378821579456138","13135550320"],["490214716896013","13135550321"],["1028577858870699","13135550322"],["308915665545959","13135550323"],["845884253678900","13135550324"],["995031308616442","13135550325"],["2787365464763437","13135550326"],["1532790990671645","13135550327"],["302617036180485","13135550328"],["723376723197227","13135550329"],["8393570407377966","13135550330"],["1931159970680725","13135550331"],["401073885688605","13135550332"],["2234478453565422","13135550334"],["814748673882312","13135550335"],["26133635056281592","13135550336"],["1439804456676119","13135550337"],["889851503172161","13135550338"],["1018283232836879","13135550339"],["1012781386779537","13135559000"],["823280953239532","13135559001"],["1597090934573334","13135559002"],["485965054020343","13135559003"],["1033381648363446","13135559004"],["491802010206446","13135559005"],["1017139033184870","13135559006"],["499638325922174","13135559008"],["468946335863664","13135559009"],["1570389776875816","13135559010"],["1004342694328995","13135559011"],["1012240323971229","13135559012"],["392171787222419","13135559013"],["952081212945019","13135559016"],["444507875070178","13135559017"],["1274819440594668","13135559018"],["1397041101147050","13135559019"],["425657699872640","13135559020"],["532292852562549","13135559021"],["705863241720292","13135559022"],["476449815183959","13135559023"],["488071553854222","13135559024"],["468693832665397","13135559025"],["517422564037340","13135559026"],["819805466613825","13135559027"],["1847708235641382","13135559028"],["716282970644228","13135559029"],["521655380527741","13135559030"],["476193631941905","13135559031"],["485600497445562","13135559032"],["440217235683910","13135559033"],["523342446758478","13135559034"],["514784864360240","13135559035"],["505790121814530","13135559036"],["420008964419580","13135559037"],["492141680204555","13135559038"],["388462787271952","13135559039"],["423473920752072","13135559040"],["489574180468229","13135559041"],["432360635854105","13135559042"],["477878201669248","13135559043"],["351656951234045","13135559044"],["430178036732582","13135559045"],["434537312944552","13135559046"],["1240614300631808","13135559047"],["473135945605128","13135559048"],["423669800729310","13135559049"],["3685666705015792","13135559050"],["504196509016638","13135559051"],["346844785189449","13135559052"],["504823088911074","13135559053"],["402669415797083","13135559054"],["490939640234431","13135559055"],["875124128063715","13135559056"],["468788962654605","13135559057"],["562386196354570","13135559058"],["372159285928791","13135559059"],["531017479591050","13135559060"],["1328873881401826","13135559061"],["1608363646390484","13135559062"],["1229628561554232","13135559063"],["348802211530364","13135559064"],["3708535859420184","13135559065"],["415517767742187","13135559066"],["479330341612638","13135559067"],["480785414723083","13135559068"],["387299107507991","13135559069"],["333389813188944","13135559070"],["391794130316996","13135559071"],["457893470576314","13135559072"],["435550496166469","13135559073"],["1620162702100689","13135559074"],["867491058616043","13135559075"],["816224117357759","13135559076"],["334065176362830","13135559077"],["489973170554709","13135559078"],["473060669049665","13135559079"],["1221505815643060","13135559080"],["889000703096359","13135559081"],["475235961979883","13135559082"],["3434445653519934","13135559084"],["524503026827421","13135559085"],["1179639046403856","13135559086"],["471563305859144","13135559087"],["533896609192881","13135559088"],["365443583168041","13135559089"],["836082305329393","13135559090"],["1056787705969916","13135559091"],["503312598958357","13135559092"],["3718606738453460","13135559093"],["826066052850902","13135559094"],["1033611345091888","13135559095"],["3868390816783240","13135559096"],["7462677740498860","13135559097"],["436288576108573","13135559098"],["1047559746718900","13135559099"],["1099299455255491","13135559100"],["1202037301040633","13135559101"],["1720619402074074","13135559102"],["1030422235101467","13135559103"],["827238979523502","13135559104"],["1516443722284921","13135559105"],["1174442747196709","13135559106"],["1653165225503842","13135559107"],["1037648777635013","13135559108"],["551617757299900","13135559109"],["1158813558718726","13135559110"],["2463236450542262","13135559111"],["1550393252501466","13135559112"],["2057065188042796","13135559113"],["506163028760735","13135559114"],["2065249100538481","13135559115"],["1041382867195858","13135559116"],["886500209499603","13135559117"],["1491615624892655","13135559118"],["486563697299617","13135559119"],["1175736513679463","13135559120"],["491811473512352","13165550064"]]);
+
+let BOT_MAP = BOT_MAP_STATIC;
+
+// ── lidToJid — LID → JID via cache + BOT_MAP ─────────────────────────
+export const lidToJid = (jid) => {
+    try {
+        if (!jid || typeof jid !== 'string') return jid;
+        const cached = lidToJidCache.get(jid);
+        if (cached) return cached;
+        let result = jid;
+        if (jid.endsWith('@lid')) {
+            const lidPart = jid.replace('@lid', '');
+            if (BOT_MAP.has(lidPart)) {
+                result = BOT_MAP.get(lidPart) + '@s.whatsapp.net';
+            } else {
+                const phoneFromCache = sharedLidPhoneCache.getPhoneForLid(jid);
+                if (phoneFromCache) result = phoneFromCache;
+            }
+        }
+        if (result !== jid) lidToJidCache.set(jid, result);
+        return result;
+    } catch { return jid; }
+};
+
+// ── resolveJid — resolve LID para JID se necessário ──────────────────
+export const resolveJid = (jid) => {
+    if (typeof jid === 'string' && jid.endsWith('@lid')) return lidToJid(jid);
+    return jid;
+};
+
+// ── normalizeJid — normaliza qualquer formato de JID ─────────────────
+// Recebe: JID, LID, número puro, @username
+// Retorna: JID normalizado (@s.whatsapp.net)
+export const normalizeJid = (jid) => {
+    if (!jid || typeof jid !== 'string') return jid;
+    // @username → converte via onWhatsApp — retorna como está (precisa de resolução online)
+    if (jid.startsWith('@')) return jid;
+    // LID → tenta converter para JID
+    if (jid.endsWith('@lid')) return lidToJid(jid);
+    // Já é JID normalizado
+    if (jid.endsWith('@s.whatsapp.net') || jid.endsWith('@g.us') || jid.endsWith('@newsletter')) return jid;
+    // Número puro → adiciona sufixo
+    if (/^\d+$/.test(jid)) return jid + '@s.whatsapp.net';
+    // c.us → s.whatsapp.net
+    if (jid.endsWith('@c.us')) return jid.replace('@c.us', '@s.whatsapp.net');
+    return jid;
+};
+
+// ── resolveAll — retorna { jid, lid } para qualquer entrada ──────────
+// Sempre devolve os dois formatos quando possível
+export const resolveAll = (jid) => {
+    if (!jid || typeof jid !== 'string') return { jid, lid: undefined };
+    if (jid.endsWith('@lid')) {
+        const resolved = lidToJid(jid);
+        return {
+            jid: resolved !== jid ? resolved : undefined,
+            lid: jid
+        };
+    }
+    if (jid.endsWith('@s.whatsapp.net')) {
+        const lid = sharedLidPhoneCache.getLidForPhone(jid);
+        return { jid, lid };
+    }
+    return { jid: normalizeJid(jid), lid: undefined };
+};
+
+// ── validateJid — valida se um JID é válido ───────────────────────────
+export const validateJid = (jid) => {
+    if (!jid || typeof jid !== 'string') return { isValid: false, error: 'JID is null or not a string' };
+    if (!jid.includes('@')) return { isValid: false, error: 'Missing @ separator' };
+    const [user, server] = jid.split('@');
+    if (!user) return { isValid: false, error: 'Empty user part' };
+    const validServers = ['s.whatsapp.net', 'g.us', 'lid', 'broadcast', 'newsletter', 'c.us', 'bot', 'hosted', 'hosted.lid'];
+    if (!validServers.includes(server)) return { isValid: false, error: `Unknown server: ${server}` };
+    return { isValid: true, error: null };
+};
+
+// ── validateAndCleanJid — valida e limpa JID ─────────────────────────
+export const validateAndCleanJid = (jid) => {
+    if (!jid || typeof jid !== 'string') return jid;
+    if (jid.endsWith('@lid')) return lidToJid(jid);
+    return jid;
+};
+
+// ── validateAndConvertLidToJid — converte LID com validação opcional ──
+export const validateAndConvertLidToJid = async (jid, onWhatsApp) => {
+    try {
+        if (!jid || typeof jid !== 'string') return jid;
+        const convertedJid = lidToJid(jid);
+        if (isLidUser(convertedJid)) return convertedJid;
+        if (!jid.endsWith('@lid') && convertedJid === jid) {
+            if (onWhatsApp) {
+                try {
+                    const validation = await onWhatsApp(convertedJid);
+                    return (validation?.length > 0 && validation[0].exists) ? convertedJid : jid;
+                } catch { return convertedJid; }
+            }
+            return convertedJid;
+        }
+        if (convertedJid !== jid && onWhatsApp) {
+            try {
+                const validation = await onWhatsApp(convertedJid);
+                return (validation?.length > 0 && validation[0].exists) ? convertedJid : jid;
+            } catch { return convertedJid; }
+        }
+        return convertedJid;
+    } catch { return jid; }
+};
+
+// ── lidToJidEnhanced — alias semântico ───────────────────────────────
+export const lidToJidEnhanced = (jid) => lidToJid(jid);
+
+// ── getSenderInfo — extrai JID + LID do remetente de qualquer mensagem
+export const getSenderInfo = (msg) => {
+    if (!msg) return { jid: undefined, lid: undefined, isValid: false };
+    const key     = msg.key || {};
+    const rawJid  = key.participant || key.remoteJid || '';
+    const isGroup = rawJid.endsWith('@g.us');
+    let jid = isGroup ? (key.participant || '') : rawJid;
+    // Normaliza
+    if (jid.endsWith('@lid')) {
+        const resolved = lidToJid(jid);
+        return {
+            lid:     jid,
+            jid:     resolved !== jid ? resolved : undefined,
+            raw:     jid,
+            isGroup,
+            isValid: true
+        };
+    }
+    const lid = sharedLidPhoneCache.getLidForPhone(jid);
+    return { jid, lid, raw: jid, isGroup, isValid: !!jid };
+};
+
+// ── @username suporte ─────────────────────────────────────────────────
+// O WhatsApp permite encontrar usuários pelo @username em vez do número.
+// Retorna o JID de um username via onWhatsApp.
+export const resolveUsername = async (username, onWhatsApp) => {
+    if (!username || !onWhatsApp) return null;
+    const clean = username.startsWith('@') ? username.slice(1) : username;
+    try {
+        // O WhatsApp usa o formato "username@s.whatsapp.net" para busca por username
+        const results = await onWhatsApp(clean + '@s.whatsapp.net');
+        if (results?.length > 0 && results[0].exists) {
+            return results[0].jid;
+        }
+        return null;
+    } catch { return null; }
+};
+
+// ── isUsername — verifica se é um @username do WhatsApp ──────────────
+export const isUsername = (str) => {
+    if (!str || typeof str !== 'string') return false;
+    return /^@[a-zA-Z0-9._]{3,}$/.test(str);
+};
+
+// ── getBotJid — resolve JID de bot IA ────────────────────────────────
+export const getBotJid = (jid) => {
+    try {
+        const sepIdx = typeof jid === 'string' ? jid.indexOf('@') : -1;
+        if (sepIdx < 0) return jid;
+        const server = jid.slice(sepIdx + 1);
+        if (server !== 'bot') return jid;
+        const user = jid.slice(0, sepIdx);
+        const mappedNumber = BOT_MAP.get(user);
+        return mappedNumber ? `${mappedNumber}@s.whatsapp.net` : jid;
+    } catch { return jid; }
+};
+
+// ── setBotMap — substitui o BOT_MAP em runtime ───────────────────────
+export const setBotMap = (mapLike) => {
+    if (!mapLike) return;
+    if (mapLike instanceof Map) { BOT_MAP = mapLike; return; }
+    if (typeof mapLike === 'object') { BOT_MAP = new Map(Object.entries(mapLike)); }
+};