@prototypevip/baileys 0.0.5 → 0.0.7

package/lib/AntiBan/wrapper.js

@@ -0,0 +1,456 @@
+/**
+ * Socket Wrapper — Drop-in replacement that wraps sendMessage with anti-ban protection
+ *
+ * Works with both baileys and @oxidezap/baileyrs transports.
+ *
+ * Usage with baileys:
+ *   import makeWASocket from 'baileys';
+ *   import { wrapSocket } from 'baileys-antiban';
+ *
+ *   const sock = makeWASocket({ ... });
+ *   const safeSock = wrapSocket(sock);
+ *
+ * Usage with baileyrs:
+ *   import { makeWASocket } from '@oxidezap/baileyrs';
+ *   import { wrapSocket } from 'baileys-antiban';
+ *
+ *   const sock = makeWASocket({ ... });
+ *   const safeSock = wrapSocket(sock);
+ *
+ *   // Use safeSock.sendMessage() — automatically rate-limited and monitored
+ *   await safeSock.sendMessage(jid, { text: 'Hello!' });
+ *
+ *   // Check health anytime
+ *   console.log(safeSock.antiban.getStats());
+ *
+ * Note: reachoutTimeLock timelock module silently noops on baileyrs until upstream
+ * emits reachoutTimeLock events — confirmed NOT present in baileyrs v0.0.8.
+ * Timelock guard will operate in detection-only mode (relies on 463 errors only).
+ */
+import { AntiBan } from './antiban.js';
+import { DeafSessionDetector } from './sessionStability.js';
+import { GroupOperationGuard } from './groupOperationGuard.js';
+import { LegitimacySignalInjector } from './legitimacySignalInjector.js';
+/**
+ * Wrap a Baileys socket with anti-ban protection.
+ * The returned socket has the same API but sendMessage() is protected.
+ */
+export function wrapSocket(sock, config, warmUpState, wrapOptions) {
+    const antiban = new AntiBan(config, warmUpState);
+    const options = {
+        autoRespondToIncoming: false,
+        ...wrapOptions,
+    };
+    // Deaf session detector — optional, enabled via wrapOptions.deafSession
+    const deafDetector = options.deafSession
+        ? new DeafSessionDetector(options.deafSession)
+        : null;
+    if (deafDetector)
+        deafDetector.attach(sock);
+    // Group operation guard — intercept group methods with rate limiting
+    if (options.groupOpGuard !== false) {
+        const guard = new GroupOperationGuard(options.groupOpGuard || {});
+        const origUpdate = sock.groupParticipantsUpdate?.bind(sock);
+        if (origUpdate) {
+            sock.groupParticipantsUpdate = async (jid, participants, action) => {
+                const op = action === 'add' ? 'add' : action === 'remove' ? 'remove' : 'add';
+                const check = guard.check(op, jid);
+                if (!check.allowed)
+                    throw new Error(check.reason || 'Group operation rate limited');
+                return origUpdate(jid, participants, action);
+            };
+        }
+        const origCreate = sock.groupCreate?.bind(sock);
+        if (origCreate) {
+            sock.groupCreate = async (subject, participants) => {
+                const check = guard.check('create', subject);
+                if (!check.allowed)
+                    throw new Error(check.reason || 'Group creation rate limited');
+                return origCreate(subject, participants);
+            };
+        }
+    }
+    // Legitimacy signal injector — wrap sendMessage for typo injection
+    let legitimacyInjector = null;
+    if (options.legitimacySignals !== false) {
+        legitimacyInjector = new LegitimacySignalInjector(typeof options.legitimacySignals === 'object' ? options.legitimacySignals : {});
+    }
+    // Hook into Baileys events for health monitoring
+    // Prefer ev.process() (Baileys ≥ late 2022) for batched event handling
+    // Fall back to ev.on() for older versions
+    if (typeof sock.ev.process === 'function') {
+        sock.ev.process(async (events) => {
+            // Handle connection updates
+            if (events['connection.update']) {
+                const update = events['connection.update'];
+                if (update.connection === 'close') {
+                    const reason = update.lastDisconnect?.error?.output?.statusCode || 'unknown';
+                    antiban.onDisconnect(reason);
+                    antiban.destroy(); // Clean up all timers
+                    deafDetector?.onDisconnect();
+                    deafDetector?.destroy();
+                    // Fleet event: detect ban-like disconnect codes
+                    if (options.fleetEventStore) {
+                        const banCodes = [401, 403, 428, 515]; // 401=logged out, 403=forbidden, 428=banned, 515=restart required
+                        if (typeof reason === 'number' && banCodes.includes(reason)) {
+                            void options.fleetEventStore.emit('ban', { statusCode: reason });
+                        }
+                    }
+                }
+                if (update.connection === 'open') {
+                    antiban.onReconnect();
+                    deafDetector?.onConnect();
+                    // Fleet event: recovery from previous ban/warn
+                    if (options.fleetEventStore) {
+                        const health = antiban.getStats().health;
+                        if (health.risk === 'low') {
+                            void options.fleetEventStore.emit('recovery', { risk: health.risk });
+                        }
+                    }
+                }
+                // Reachout timelock detection
+                if (update.reachoutTimeLock) {
+                    antiban.timelock.onTimelockUpdate({
+                        isActive: update.reachoutTimeLock.isActive,
+                        timeEnforcementEnds: update.reachoutTimeLock.timeEnforcementEnds,
+                        enforcementType: update.reachoutTimeLock.enforcementType,
+                    });
+                    // Fleet event: timelock
+                    if (options.fleetEventStore && update.reachoutTimeLock.isActive) {
+                        void options.fleetEventStore.emit('timelock', {
+                            enforcementType: update.reachoutTimeLock.enforcementType,
+                            endsAt: update.reachoutTimeLock.timeEnforcementEnds,
+                        });
+                    }
+                }
+            }
+            // Catch 463 errors from message updates + track retries + learn LID mappings
+            if (events['messages.update']) {
+                const updates = events['messages.update'];
+                deafDetector?.onMessageActivity();
+                for (const update of updates) {
+                    // 463 error detection
+                    if (update?.update?.messageStubParameters) {
+                        const params = Array.isArray(update.update.messageStubParameters)
+                            ? update.update.messageStubParameters
+                            : [];
+                        if (params.includes(463) || params.includes('463')) {
+                            antiban.timelock.record463Error();
+                            // Fleet event: rate limit detected
+                            if (options.fleetEventStore) {
+                                void options.fleetEventStore.emit('rate_limit', { error: '463' });
+                            }
+                        }
+                    }
+                    // Retry tracking
+                    antiban.retryTracker.onMessageUpdate(update);
+                    // Delivery receipt tracking
+                    const status = update?.update?.status;
+                    const msgId = update?.key?.id;
+                    // status 3 = DELIVERY_ACK (double tick), status 4 = READ
+                    if (msgId && (status === 3 || status === 4)) {
+                        antiban.onDeliveryReceipt(msgId);
+                    }
+                }
+                // LID canonicalizer learning
+                antiban.jidCanonicalizer?.onMessageUpdate(updates);
+            }
+            // Register known chats from incoming messages + handle reply suggestions + learn LID mappings
+            if (events['messages.upsert']) {
+                const { messages } = events['messages.upsert'];
+                deafDetector?.onMessageActivity();
+                // Learn LID mappings FIRST (before any other processing)
+                antiban.jidCanonicalizer?.onIncomingEvent(events['messages.upsert']);
+                for (const msg of messages || []) {
+                    const jid = msg.key?.remoteJid;
+                    if (!jid)
+                        continue;
+                    // Register known chat
+                    antiban.timelock.registerKnownChat(jid);
+                    // Skip self messages
+                    const isSelf = msg.key?.fromMe || false;
+                    if (isSelf)
+                        continue;
+                    // Extract message text
+                    const msgText = msg.message?.conversation ||
+                        msg.message?.extendedTextMessage?.text ||
+                        msg.message?.imageMessage?.caption ||
+                        msg.message?.videoMessage?.caption ||
+                        '';
+                    // Handle incoming message (updates reply ratio + contact graph)
+                    const replySuggestion = antiban.onIncomingMessage(jid, msgText);
+                    // Auto-respond if enabled and suggested
+                    if (options.autoRespondToIncoming && replySuggestion.shouldReply && replySuggestion.suggestedText) {
+                        // Random delay 3-15s
+                        const replyDelay = Math.floor(Math.random() * 12000) + 3000;
+                        setTimeout(async () => {
+                            try {
+                                await sock.sendMessage(jid, { text: replySuggestion.suggestedText });
+                            }
+                            catch (error) {
+                                // Silently fail — auto-reply is best-effort
+                            }
+                        }, replyDelay);
+                    }
+                }
+            }
+        });
+    }
+    else {
+        // Fallback to ev.on() for older Baileys versions
+        sock.ev.on('connection.update', (update) => {
+            if (update.connection === 'close') {
+                const reason = update.lastDisconnect?.error?.output?.statusCode || 'unknown';
+                antiban.onDisconnect(reason);
+                antiban.destroy(); // Clean up all timers
+                deafDetector?.onDisconnect();
+                deafDetector?.destroy();
+                // Fleet event: detect ban-like disconnect codes
+                if (options.fleetEventStore) {
+                    const banCodes = [401, 403, 428, 515]; // 401=logged out, 403=forbidden, 428=banned, 515=restart required
+                    if (typeof reason === 'number' && banCodes.includes(reason)) {
+                        void options.fleetEventStore.emit('ban', { statusCode: reason });
+                    }
+                }
+            }
+            if (update.connection === 'open') {
+                antiban.onReconnect();
+                deafDetector?.onConnect();
+                // Fleet event: recovery from previous ban/warn
+                if (options.fleetEventStore) {
+                    const health = antiban.getStats().health;
+                    if (health.risk === 'low') {
+                        void options.fleetEventStore.emit('recovery', { risk: health.risk });
+                    }
+                }
+            }
+            // Reachout timelock detection
+            if (update.reachoutTimeLock) {
+                antiban.timelock.onTimelockUpdate({
+                    isActive: update.reachoutTimeLock.isActive,
+                    timeEnforcementEnds: update.reachoutTimeLock.timeEnforcementEnds,
+                    enforcementType: update.reachoutTimeLock.enforcementType,
+                });
+                // Fleet event: timelock
+                if (options.fleetEventStore && update.reachoutTimeLock.isActive) {
+                    void options.fleetEventStore.emit('timelock', {
+                        enforcementType: update.reachoutTimeLock.enforcementType,
+                        endsAt: update.reachoutTimeLock.timeEnforcementEnds,
+                    });
+                }
+            }
+        });
+        // Catch 463 errors from message updates + track retries + learn LID mappings
+        sock.ev.on('messages.update', (updates) => {
+            deafDetector?.onMessageActivity();
+            for (const update of updates) {
+                // 463 error detection
+                if (update?.update?.messageStubParameters) {
+                    const params = update.update.messageStubParameters;
+                    if (params.includes(463) || params.includes('463')) {
+                        antiban.timelock.record463Error();
+                        // Fleet event: rate limit detected
+                        if (options.fleetEventStore) {
+                            void options.fleetEventStore.emit('rate_limit', { error: '463' });
+                        }
+                    }
+                }
+                // Retry tracking
+                antiban.retryTracker.onMessageUpdate(update);
+                // Delivery receipt tracking
+                const status = update?.update?.status;
+                const msgId = update?.key?.id;
+                // status 3 = DELIVERY_ACK (double tick), status 4 = READ
+                if (msgId && (status === 3 || status === 4)) {
+                    antiban.onDeliveryReceipt(msgId);
+                }
+            }
+            // LID canonicalizer learning
+            antiban.jidCanonicalizer?.onMessageUpdate(updates);
+        });
+        // Register known chats from incoming messages + handle reply suggestions + learn LID mappings
+        sock.ev.on('messages.upsert', (upsert) => {
+            const { messages } = upsert;
+            deafDetector?.onMessageActivity();
+            // Learn LID mappings FIRST (before any other processing)
+            antiban.jidCanonicalizer?.onIncomingEvent(upsert);
+            for (const msg of messages || []) {
+                const jid = msg.key?.remoteJid;
+                if (!jid)
+                    continue;
+                // Register known chat
+                antiban.timelock.registerKnownChat(jid);
+                // Skip self messages
+                const isSelf = msg.key?.fromMe || false;
+                if (isSelf)
+                    continue;
+                // Extract message text
+                const msgText = msg.message?.conversation ||
+                    msg.message?.extendedTextMessage?.text ||
+                    msg.message?.imageMessage?.caption ||
+                    msg.message?.videoMessage?.caption ||
+                    '';
+                // Handle incoming message (updates reply ratio + contact graph)
+                const replySuggestion = antiban.onIncomingMessage(jid, msgText);
+                // Auto-respond if enabled and suggested
+                if (options.autoRespondToIncoming && replySuggestion.shouldReply && replySuggestion.suggestedText) {
+                    // Random delay 3-15s
+                    const replyDelay = Math.floor(Math.random() * 12000) + 3000;
+                    setTimeout(async () => {
+                        try {
+                            await sock.sendMessage(jid, { text: replySuggestion.suggestedText });
+                        }
+                        catch (error) {
+                            // Silently fail — auto-reply is best-effort
+                        }
+                    }, replyDelay);
+                }
+            }
+        });
+    }
+    // Create proxy that intercepts sendMessage
+    const originalSendMessage = sock.sendMessage.bind(sock);
+    // Serializes beforeSend→afterSend so rate limiter accounting is accurate
+    // under concurrent sends. Without this, all concurrent callers read the same
+    // committed state before any afterSend records, bypassing per-minute limits.
+    let sendLock = Promise.resolve();
+    const wrappedSendMessage = async (jid, content, options) => {
+        /**
+         * LID/PN Canonicalization — Normalize JID to canonical form
+         *
+         * This mitigates the LID/PN race that causes "Bad MAC / No Session / Invalid PreKey"
+         * errors (Baileys #1769, our PR #2372). When a message event arrives under one form
+         * (e.g. LID) but the crypto session was established under another (e.g. PN), decryption
+         * fails. By normalizing all outbound targets to a single form, we reduce this race.
+         *
+         * This is middleware-layer mitigation only. Root fix requires PR #2372 merged upstream.
+         */
+        const canonicalJid = antiban.jidCanonicalizer?.canonicalizeTarget(jid) || jid;
+        // Extract text content for rate limiter analysis
+        let text = content?.text || content?.caption || content?.image?.caption || '';
+        // Check for typo injection (only for text messages)
+        let typoResult = null;
+        if (legitimacyInjector && content?.text && typeof content.text === 'string' && content.text.length > 10) {
+            typoResult = legitimacyInjector.shouldInjectTypo(content.text);
+        }
+        // Chain this send onto the previous — each waits for the prior send's
+        // afterSend to commit before running its own beforeSend check.
+        const sendResult = sendLock.then(async () => {
+            // Circuit breaker check (before antiban.beforeSend)
+            if (options.circuitBreaker) {
+                if (!options.circuitBreaker.canSend(canonicalJid)) {
+                    throw new Error('[baileys-antiban] circuit-breaker: send blocked for ' + canonicalJid);
+                }
+            }
+            const decision = await antiban.beforeSend(canonicalJid, text);
+            if (!decision.allowed) {
+                throw new Error(`[baileys-antiban] Message blocked: ${decision.reason}`);
+            }
+            // Apply delay from rate limiter
+            if (decision.delayMs > 0) {
+                await new Promise(resolve => setTimeout(resolve, decision.delayMs));
+            }
+            // Apply circuit breaker jitter for broadcast messages
+            if (options.circuitBreaker) {
+                const isBroadcast = canonicalJid.endsWith('@broadcast') || canonicalJid.endsWith('@newsletter');
+                const jitter = options.circuitBreaker.getJitter(isBroadcast);
+                if (jitter > 0) {
+                    await new Promise(resolve => setTimeout(resolve, jitter));
+                }
+            }
+            // Send message (using canonical JID)
+            // If typo injection is active, send typo first, then correction
+            try {
+                let result;
+                if (typoResult) {
+                    // Send typo version first
+                    const typoContent = { ...content, text: typoResult.typoText };
+                    await originalSendMessage(canonicalJid, typoContent, options);
+                    // Wait for correction delay
+                    await new Promise(r => setTimeout(r, typoResult.correctionDelay));
+                    // Send corrected version
+                    const correctionContent = { ...content, text: typoResult.correctionText };
+                    result = await originalSendMessage(canonicalJid, correctionContent, options);
+                }
+                else {
+                    // Normal send
+                    result = await originalSendMessage(canonicalJid, content, options);
+                }
+                // Pass msgId to afterSend for delivery tracking
+                const msgId = result?.key?.id;
+                antiban.afterSend(canonicalJid, text, msgId);
+                antiban.timelock.registerKnownChat(canonicalJid);
+                // Clear retry tracking on successful send
+                if (msgId) {
+                    antiban.retryTracker.clear(msgId);
+                }
+                // Circuit breaker success
+                if (options.circuitBreaker) {
+                    options.circuitBreaker.recordSuccess(canonicalJid);
+                }
+                return result;
+            }
+            catch (error) {
+                // Circuit breaker failure
+                if (options.circuitBreaker) {
+                    options.circuitBreaker.recordFailure(canonicalJid);
+                }
+                // Baileys PR #2587: partial-encrypt Boom now carries structured data:
+                //   error.data.failed[]   — per-recipient { jid, error } failures
+                //   error.data.firstCause — most likely root cause string
+                // Extract for richer health-monitor diagnostics vs plain error.message.
+                const boomData = error?.data;
+                if (boomData?.failed?.length) {
+                    const cause = boomData.firstCause ?? 'unknown';
+                    const failedJids = boomData.failed.map((f) => f.jid).join(', ');
+                    antiban.afterSendFailed(`encrypt-all-failed firstCause=${cause} jids=[${failedJids}]`);
+                }
+                else {
+                    antiban.afterSendFailed(error instanceof Error ? error.message : String(error));
+                }
+                throw error;
+            }
+        });
+        // Advance the lock regardless of success/failure so the chain never stalls
+        sendLock = sendResult.then(() => { }, () => { });
+        return sendResult;
+    };
+    // Return enhanced socket
+    const wrapped = Object.create(sock);
+    wrapped.sendMessage = wrappedSendMessage;
+    wrapped.antiban = antiban;
+    // Expose destroy method directly so consumers can call it manually if needed
+    wrapped.antiban.destroy = antiban.destroy.bind(antiban);
+    return wrapped;
+}
+/**
+ * Helper function to create a wrapped socket with device fingerprint applied.
+ *
+ * This combines device fingerprint generation, socket creation, and wrapping
+ * into a single call.
+ *
+ * Usage:
+ *   import makeWASocket from 'baileys';
+ *   import { wrapSocketWithFingerprint } from 'baileys-antiban';
+ *
+ *   const wrapped = wrapSocketWithFingerprint(makeWASocket, socketConfig, {
+ *     fingerprintSeed: 'stable-seed-123',
+ *     groupOpGuard: {},
+ *     legitimacySignals: {}
+ *   });
+ *
+ * @param makeWASocket - Baileys makeWASocket factory function
+ * @param socketConfig - Base socket configuration
+ * @param wrapOptions - Combined wrapper options + fingerprintSeed
+ */
+export function wrapSocketWithFingerprint(makeWASocket, socketConfig, wrapOptions) {
+    // Import fingerprint functions dynamically to avoid circular deps
+    const { generateFingerprint, applyFingerprint } = require('./deviceFingerprint.js');
+    const seed = wrapOptions?.fingerprintSeed ||
+        socketConfig.auth?.creds?.me?.id ||
+        String(Date.now());
+    const fp = generateFingerprint({ seed });
+    const config = applyFingerprint(socketConfig, fp);
+    const sock = makeWASocket(config);
+    return wrapSocket(sock, undefined, undefined, wrapOptions);
+}

package/lib/Socket/chats.js

@@ -199,6 +199,15 @@ export const makeChatsSocket = (config) => {
     }
   };
 
+  // مهله قصوى لاستعلام اليوزرنيم — واتساب أحياناً مبيردش على الاستعلام ده خالص
+  // لبعض حسابات اليوزرنيم، وبيرجع في المهله الافتراضيه (60 ثانيه)، وده اللي
+  // كان بيسبب تعليق البوت لحد دقيقتين على اي رساله جايه من حساب زي ده
+  const withTimeout = (promise, ms, fallback) =>
+    Promise.race([
+      promise,
+      new Promise((resolve) => setTimeout(() => resolve(fallback), ms)),
+    ]);
+
   const getUsername = async (jid) => {
     const usyncQuery = new USyncQuery()
       .withUsernameProtocol()
@@ -208,10 +217,18 @@ export const makeChatsSocket = (config) => {
     return result?.list?.[0]?.username || null;
   };
 
+  // كام ملي ثانيه أقصى نستنى فيها رد واتساب قبل ما نستسلم ونكمل من غير يوزرنيم
+  const USERNAME_LOOKUP_TIMEOUT_MS = 3500;
+  // مده صلاحيه الكاش السلبي (id-not-found) — بعدها نجرب تاني، لأن الرقم ممكن
+  // يبقى قابل للاكتشاف تاني (المستخدم شال اليوزرنيم مثلاً)
+  const NEGATIVE_CACHE_TTL_MS = 30 * 60 * 1000;
+
   const findUserId = async (pnLid) => {
     const cachedId = USER_ID_CACHE.get(pnLid);
     if (cachedId) {
-      return cachedId;
+      const isNegative = cachedId.phoneNumber === "id-not-found";
+      const isStale = isNegative && Date.now() - (cachedId._cachedAt || 0) > NEGATIVE_CACHE_TTL_MS;
+      if (!isStale) return cachedId;
     }
     const userId = {};
     if (isPnUser(pnLid)) {
@@ -221,6 +238,7 @@ export const makeChatsSocket = (config) => {
       )?.[0]?.lid;
       if (!userId.lid) {
         userId.lid = "id-not-found";
+        userId._cachedAt = Date.now();
         USER_ID_CACHE.set(pnLid, userId);
         return userId;
       }
@@ -234,13 +252,20 @@ export const makeChatsSocket = (config) => {
         // واتساب، لأن رقمه بيبقى مش قابل للاكتشاف. من غير الكاش ده، كل رساله
         // جايه من الحساب ده كانت بتعمل استعلام شبكه كامل تاني من الأول، وده
         // اللي كان بيسبب التأخير/التعليق الملحوظ مع أي حد شايل يوزرنيم.
-        // كمان بنحاول نجيب اليوزرنيم نفسه عشان يتعرض بدل الرقم/الليد الخام.
+        // كمان بنحاول نجيب اليوزرنيم نفسه عشان يتعرض بدل الرقم/الليد الخام،
+        // لكن بمهله قصوى (6 ثواني) عشان لو واتساب مارضاش يرد، مانستناهوش المهله
+        // الكامله (60 ثانيه) اللي كانت بتعلّق البوت.
         userId.phoneNumber = "id-not-found";
         try {
-          userId.username = await getUsername(pnLid);
+          userId.username = await withTimeout(
+            getUsername(pnLid),
+            USERNAME_LOOKUP_TIMEOUT_MS,
+            null,
+          );
         } catch {
           userId.username = null;
         }
+        userId._cachedAt = Date.now();
         USER_ID_CACHE.set(pnLid, userId);
         return userId;
       }
@@ -1144,4 +1169,4 @@ export const makeChatsSocket = (config) => {
     addOrEditQuickReply: addOrEditQuickReply,
     removeQuickReply: removeQuickReply,
   };
-};
+};

package/lib/Socket/groups.js

@@ -452,9 +452,14 @@ export const extractGroupMetadata = (result) => {
             ? id
             : undefined;
         return {
-          id: phone,
+          // لو مفيش رقم ظاهر (حساب يوزرنيم/خاصية إخفاء الرقم)، استخدم الـ
+          // LID بدل ما تسيبها undefined — undefined كانت بتوصل لقايمة
+          // المشاركين اللي بتتبعت لـ getUSyncDevices وتكسر استعلام
+          // الأجهزة للجروب كله، مع إن الاستعلام المباشر بالـ LID بيرجع
+          // فورًا لو استخدمناه صح
+          id: phone || lid,
           lid: lid,
-          jid: phone,
+          jid: phone || lid,
           admin: attrs.type || false,
         };
       },

package/lib/Socket/index.js

@@ -1,14 +1,79 @@
 import { DEFAULT_CONNECTION_CONFIG } from "../Defaults/index.js";
 import { makeCommunitiesSocket } from "./communities.js";
-const makeWASocket = (config) => {
-  delete config.userDevicesCache;
-  const newConfig = { ...DEFAULT_CONNECTION_CONFIG, ...config };
+import { wrapSocket, wrapSocketWithFingerprint } from "../AntiBan/wrapper.js";
+import { resolveConfig, PRESETS } from "../AntiBan/presets.js";
+
+/**
+ * Create a WhatsApp socket.
+ *
+ * Optional anti-ban protection (integrated from baileys-antiban) can be enabled via config.antiBan:
+ *
+ *   // Disabled (default) — normal Baileys behavior
+ *   makeWASocket({ auth, ... })
+ *
+ *   // Enable with safe defaults (conservative preset)
+ *   makeWASocket({ auth, antiBan: true })
+ *
+ *   // Enable with a named preset: 'conservative' | 'moderate' | 'aggressive' | 'high-volume'
+ *   makeWASocket({ auth, antiBan: 'moderate' })
+ *
+ *   // Enable with full custom config (see baileys-antiban README)
+ *   makeWASocket({
+ *     auth,
+ *     antiBan: {
+ *       maxPerMinute: 8,
+ *       maxPerHour: 200,
+ *       warmUp: { enabled: true },
+ *       // ... or nested style still accepted with deprecation warning
+ *     }
+ *   })
+ *
+ * When enabled, the returned socket has the same API plus:
+ *   sock.antiban          — AntiBan instance
+ *   sock.antiban.getStats() — current rate / health / risk stats
+ *
+ * Extra advanced options (optional):
+ *   antiBanWarmUpState   — restore previous warm-up state
+ *   antiBanWrapOptions   — extra wrap options (groupOpGuard, legitimacySignals, etc.)
+ *
+ * You can also use the low-level helpers directly:
+ *   import { wrapSocket, wrapSocketWithFingerprint, PRESETS } from '@prototypevip/baileys'
+ */
+const makeWASocket = (config = {}) => {
+  // Extract anti-ban related options so they don't leak into Baileys internal config
+  const {
+    antiBan,
+    antiBanWarmUpState,
+    antiBanWrapOptions,
+    ...restConfig
+  } = config;
+
+  delete restConfig.userDevicesCache;
+  const newConfig = { ...DEFAULT_CONNECTION_CONFIG, ...restConfig };
+
   let sock;
   const originalGetMessage = newConfig.getMessage;
   newConfig.getMessage = async function (key) {
     return originalGetMessage.call(sock || this, key);
   };
+
   sock = makeCommunitiesSocket(newConfig);
+
+  // Optional anti-ban wrapping
+  if (antiBan) {
+    let antibanConfig;
+    if (antiBan === true) {
+      antibanConfig = resolveConfig(undefined); // conservative defaults
+    } else if (typeof antiBan === "string") {
+      antibanConfig = resolveConfig(antiBan);
+    } else {
+      antibanConfig = antiBan; // user object (supports both flat & nested)
+    }
+    sock = wrapSocket(sock, antibanConfig, antiBanWarmUpState, antiBanWrapOptions);
+  }
+
   return sock;
 };
+
 export default makeWASocket;
+export { wrapSocket, wrapSocketWithFingerprint, PRESETS };