@prototypevip/baileys 0.0.5 → 0.0.7

package/lib/AntiBan/banRecoveryOrchestrator.js

@@ -0,0 +1,284 @@
+/**
+ * BanRecoveryOrchestrator — Structured recovery after ban/restriction events
+ *
+ * When WhatsApp restricts your account, the worst thing to do is immediately
+ * resume normal activity. This module provides a evidence-based recovery protocol:
+ *
+ * - Timelocked (reachout_restricted): 24h pause, resume at 10% rate, ramp 15%/week
+ * - Rate-overlimit (429): 4h pause, resume at 25% rate, ramp 25%/week
+ * - Soft-ban (repeated disconnects): 48h pause, resume at 5% rate, ramp 10%/week
+ * - Hard-ban (loggedOut): account is dead, signal for replacement
+ *
+ * Based on observed recovery times from community reports. Not guaranteed —
+ * WA's enforcement is non-deterministic. Treat as best-effort guidance.
+ */
+const DEFAULT_PLANS = {
+    timelock: {
+        eventType: 'timelock',
+        pauseDurationMs: 24 * 60 * 60 * 1000, // 24 hours
+        resumeRateMultiplier: 0.10, // 10% of normal
+        weeklyRampPercent: 15, // +15% per week
+        estimatedRecoveryDays: 14,
+        description: 'WA reachout timelock — 24h pause then slow ramp',
+    },
+    rate_overlimit: {
+        eventType: 'rate_overlimit',
+        pauseDurationMs: 4 * 60 * 60 * 1000, // 4 hours
+        resumeRateMultiplier: 0.25, // 25% of normal
+        weeklyRampPercent: 25, // +25% per week
+        estimatedRecoveryDays: 7,
+        description: 'Rate limit hit — 4h pause then moderate ramp',
+    },
+    soft_ban: {
+        eventType: 'soft_ban',
+        pauseDurationMs: 48 * 60 * 60 * 1000, // 48 hours
+        resumeRateMultiplier: 0.05, // 5% of normal
+        weeklyRampPercent: 10, // +10% per week
+        estimatedRecoveryDays: 21,
+        description: 'Soft ban detected — 48h pause then very slow ramp',
+    },
+    hard_ban: {
+        eventType: 'hard_ban',
+        pauseDurationMs: Infinity,
+        resumeRateMultiplier: 0,
+        weeklyRampPercent: 0,
+        estimatedRecoveryDays: Infinity,
+        description: 'Hard ban — number is dead, replace SIM',
+    },
+};
+export class BanRecoveryOrchestrator {
+    config;
+    state;
+    plans;
+    constructor(config = {}) {
+        this.config = {
+            plans: config.plans || {},
+            onPhaseChange: config.onPhaseChange || (() => { }),
+            onHardBan: config.onHardBan || (() => { }),
+            maxRecoveryWeeks: config.maxRecoveryWeeks ?? 8,
+        };
+        // Merge custom plans with defaults
+        this.plans = { ...DEFAULT_PLANS };
+        if (config.plans) {
+            for (const eventType in config.plans) {
+                const customPlan = config.plans[eventType];
+                if (customPlan) {
+                    this.plans[eventType] = {
+                        ...this.plans[eventType],
+                        ...customPlan,
+                    };
+                }
+            }
+        }
+        this.state = {
+            active: false,
+            phase: 'graduated',
+            currentRateMultiplier: 1.0,
+            weeksSinceResume: 0,
+            banCount30d: 0,
+        };
+    }
+    /**
+     * Record a ban event and start recovery protocol
+     */
+    recordBanEvent(eventType) {
+        const now = Date.now();
+        const plan = this.plans[eventType];
+        // Update ban count (reset if >30 days since last ban)
+        if (this.state.lastBanAt) {
+            const daysSinceLastBan = (now - this.state.lastBanAt) / (86400000);
+            if (daysSinceLastBan > 30) {
+                this.state.banCount30d = 0;
+            }
+        }
+        this.state.banCount30d++;
+        this.state.lastBanAt = now;
+        // Upgrade to hard_ban if 3+ bans in 30 days (unless already hard_ban)
+        if (this.state.banCount30d >= 3 && eventType !== 'hard_ban') {
+            eventType = 'hard_ban';
+        }
+        this.state.active = true;
+        this.state.eventType = eventType;
+        this.state.banDetectedAt = now;
+        this.state.pauseUntil = plan.pauseDurationMs === Infinity ? Infinity : now + plan.pauseDurationMs;
+        this.state.currentRateMultiplier = plan.resumeRateMultiplier;
+        this.state.weeksSinceResume = 0;
+        this.state.phase = eventType === 'hard_ban' ? 'dead' : 'paused';
+        this.config.onPhaseChange(this.state.phase, plan);
+        if (eventType === 'hard_ban') {
+            this.config.onHardBan();
+        }
+        return this.getStatus();
+    }
+    /**
+     * Get current recovery status (call before sending to check rate)
+     */
+    getStatus() {
+        if (!this.state.active || !this.state.eventType) {
+            return {
+                phase: 'graduated',
+                rateMultiplier: 1.0,
+                recommendation: 'No active recovery — operating normally',
+                shouldReplaceNumber: false,
+            };
+        }
+        const now = Date.now();
+        const plan = this.plans[this.state.eventType];
+        // Check if pause period has ended
+        if (this.state.phase === 'paused' && this.state.pauseUntil !== undefined && this.state.pauseUntil !== Infinity && now >= this.state.pauseUntil) {
+            this.state.phase = 'recovering';
+            this.config.onPhaseChange(this.state.phase, plan);
+        }
+        // Check if we've exceeded max recovery weeks (give up)
+        if (this.state.phase === 'recovering' || this.state.phase === 'ramping') {
+            if (this.state.weeksSinceResume >= this.config.maxRecoveryWeeks) {
+                this.state.phase = 'dead';
+                this.config.onPhaseChange(this.state.phase, plan);
+                this.config.onHardBan();
+            }
+        }
+        const shouldReplaceNumber = this.state.phase === 'dead' || this.state.banCount30d >= 3;
+        let recommendation;
+        switch (this.state.phase) {
+            case 'dead':
+                recommendation = 'Account is permanently restricted. Replace number and start fresh.';
+                break;
+            case 'paused':
+                if (this.state.pauseUntil === Infinity) {
+                    recommendation = 'Account is dead. Do not attempt to send messages.';
+                }
+                else {
+                    const remainingMs = this.state.pauseUntil - now;
+                    const remainingHours = Math.ceil(remainingMs / 3600000);
+                    recommendation = `Pause period active. Wait ${remainingHours}h before resuming. ${plan.description}`;
+                }
+                break;
+            case 'recovering':
+                recommendation = `Recovery phase. Operating at ${Math.round(this.state.currentRateMultiplier * 100)}% capacity. Ramp: ${plan.weeklyRampPercent}%/week.`;
+                break;
+            case 'ramping':
+                recommendation = `Ramping phase. Operating at ${Math.round(this.state.currentRateMultiplier * 100)}% capacity. Ramp: ${plan.weeklyRampPercent}%/week.`;
+                break;
+            case 'graduated':
+                recommendation = 'Recovery complete. Operating at full capacity.';
+                break;
+        }
+        const pauseRemainingMs = this.state.pauseUntil !== undefined && this.state.pauseUntil !== Infinity && now < this.state.pauseUntil
+            ? this.state.pauseUntil - now
+            : undefined;
+        let estimatedFullRecoveryDate;
+        if (this.state.phase === 'recovering' || this.state.phase === 'ramping') {
+            const rateToGain = 1.0 - this.state.currentRateMultiplier;
+            const weeksNeeded = Math.ceil((rateToGain / (plan.weeklyRampPercent / 100)) * (1 / this.state.currentRateMultiplier));
+            estimatedFullRecoveryDate = now + weeksNeeded * 7 * 86400000;
+        }
+        return {
+            phase: this.state.phase,
+            rateMultiplier: this.state.currentRateMultiplier,
+            pauseRemainingMs,
+            estimatedFullRecoveryDate,
+            recommendation,
+            shouldReplaceNumber,
+        };
+    }
+    /**
+     * Current rate multiplier — multiply your normal limits by this
+     */
+    getRateMultiplier() {
+        return this.state.currentRateMultiplier;
+    }
+    /**
+     * Should be called daily/weekly to advance the ramp
+     */
+    tick() {
+        if (!this.state.active || !this.state.eventType) {
+            return;
+        }
+        const now = Date.now();
+        const plan = this.plans[this.state.eventType];
+        // Transition from paused to recovering
+        if (this.state.phase === 'paused' && this.state.pauseUntil !== undefined && this.state.pauseUntil !== Infinity && now >= this.state.pauseUntil) {
+            this.state.phase = 'recovering';
+            this.config.onPhaseChange(this.state.phase, plan);
+        }
+        // Advance the ramp if in recovering/ramping phase
+        if (this.state.phase === 'recovering' || this.state.phase === 'ramping') {
+            this.state.weeksSinceResume++;
+            // Check if exceeded max recovery weeks
+            if (this.state.weeksSinceResume >= this.config.maxRecoveryWeeks) {
+                this.state.phase = 'dead';
+                this.state.currentRateMultiplier = 0;
+                this.config.onPhaseChange(this.state.phase, plan);
+                this.config.onHardBan();
+                return;
+            }
+            // Apply weekly ramp
+            const rampMultiplier = 1 + (plan.weeklyRampPercent / 100);
+            const newMultiplier = this.state.currentRateMultiplier * rampMultiplier;
+            if (newMultiplier >= 1.0) {
+                // Graduated
+                this.state.currentRateMultiplier = 1.0;
+                this.state.phase = 'graduated';
+                this.state.active = false;
+                this.config.onPhaseChange(this.state.phase, plan);
+            }
+            else {
+                // Still ramping
+                this.state.currentRateMultiplier = newMultiplier;
+                this.state.phase = 'ramping';
+            }
+        }
+    }
+    /**
+     * Classify a raw error into a BanEventType
+     */
+    static classifyError(err) {
+        if (!err)
+            return null;
+        const errorStr = String(err).toLowerCase();
+        const errorMsg = err.message?.toLowerCase() || '';
+        const errorCode = err.code || '';
+        // Timelock patterns
+        if (errorStr.includes('reachout') ||
+            errorStr.includes('account_reachout_restricted') ||
+            errorMsg.includes('reachout') ||
+            errorCode === 463 ||
+            errorCode === '463') {
+            return 'timelock';
+        }
+        // Rate overlimit patterns
+        if (errorStr.includes('rate-overlimit') ||
+            errorStr.includes('rate_overlimit') ||
+            errorStr.includes('429') ||
+            errorCode === 429 ||
+            errorCode === '429') {
+            return 'rate_overlimit';
+        }
+        // Hard ban patterns
+        if (errorStr.includes('loggedout') ||
+            errorStr.includes('logged_out') ||
+            errorStr.includes('logged out') ||
+            errorMsg.includes('loggedout') ||
+            errorCode === 401 ||
+            errorCode === '401') {
+            return 'hard_ban';
+        }
+        // Note: soft_ban detection requires context (multiple disconnects)
+        // and should be determined by the caller using HealthMonitor
+        return null;
+    }
+    /**
+     * Serializable state for persistence
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Restore from persisted state
+     */
+    static fromState(state, config) {
+        const orchestrator = new BanRecoveryOrchestrator(config);
+        orchestrator.state = { ...state };
+        return orchestrator;
+    }
+}

package/lib/AntiBan/contactGraph.js

@@ -0,0 +1,236 @@
+/**
+ * Contact Graph Warmer — Requires 1:1 handshake before group/bulk sends
+ *
+ * WhatsApp's ML models weight "social graph distance" heavily. Accounts that
+ * message strangers (contacts who never replied) have higher ban risk.
+ *
+ * This module:
+ * - Tracks contact state: stranger → handshake_sent → handshake_complete → known
+ * - Blocks sends to strangers unless handshake completed
+ * - Enforces group lurk period (don't send immediately after joining)
+ * - Caps daily new-contact messaging (prevent spray-and-pray patterns)
+ * - Auto-registers inbound senders as "known contacts"
+ *
+ * Research: 2025 ban waves correlated with accounts joining groups + spamming
+ * instantly. 12-24h lurk period significantly reduced bans.
+ */
+const DEFAULT_CONFIG = {
+    enabled: false,
+    requireHandshakeBeforeGroupSend: true,
+    handshakeMinDelayMs: 3600000, // 1 hour
+    groupLurkPeriodMs: 43200000, // 12 hours
+    maxStrangerMessagesPerDay: 5,
+    autoRegisterOnIncoming: true,
+};
+export class ContactGraphWarmer {
+    config;
+    contacts = new Map();
+    groups = new Map();
+    strangerMessagesToday = 0;
+    lastStrangerResetDay = this.getCurrentDay();
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Check if message can be sent to this contact/group.
+     * Returns { allowed: false, needsHandshake: true } if handshake required.
+     */
+    canMessage(jid) {
+        if (!this.config.enabled) {
+            return { allowed: true };
+        }
+        // Reset daily stranger counter at UTC midnight
+        const currentDay = this.getCurrentDay();
+        if (currentDay !== this.lastStrangerResetDay) {
+            this.strangerMessagesToday = 0;
+            this.lastStrangerResetDay = currentDay;
+        }
+        // Handle groups
+        if (this.isGroup(jid)) {
+            return this.checkGroupMessage(jid);
+        }
+        // Handle individual contacts
+        return this.checkIndividualMessage(jid);
+    }
+    /**
+     * Mark handshake as sent to this contact.
+     */
+    markHandshakeSent(jid) {
+        if (!this.config.enabled)
+            return;
+        if (this.isGroup(jid))
+            return;
+        const record = this.contacts.get(jid) || { state: 'stranger' };
+        record.state = 'handshake_sent';
+        record.handshakeSentAt = Date.now();
+        this.contacts.set(jid, record);
+    }
+    /**
+     * Mark handshake as complete with this contact.
+     */
+    markHandshakeComplete(jid) {
+        if (!this.config.enabled)
+            return;
+        if (this.isGroup(jid))
+            return;
+        const record = this.contacts.get(jid) || { state: 'stranger' };
+        record.state = 'handshake_complete';
+        this.contacts.set(jid, record);
+    }
+    /**
+     * Register a contact as known (skip handshake requirement).
+     */
+    registerKnownContact(jid) {
+        if (!this.config.enabled)
+            return;
+        if (this.isGroup(jid))
+            return;
+        const record = this.contacts.get(jid) || { state: 'stranger' };
+        record.state = 'known';
+        this.contacts.set(jid, record);
+    }
+    /**
+     * Register a group join event.
+     */
+    registerGroupJoin(groupJid) {
+        if (!this.config.enabled)
+            return;
+        if (!this.isGroup(groupJid))
+            return;
+        this.groups.set(groupJid, { joinedAt: Date.now() });
+    }
+    /**
+     * Get contact state.
+     */
+    getContactState(jid) {
+        if (this.isGroup(jid))
+            return 'known'; // Groups don't have handshake states
+        return this.contacts.get(jid)?.state || 'stranger';
+    }
+    /**
+     * Handle incoming message — auto-register if enabled.
+     */
+    onIncomingMessage(jid) {
+        if (!this.config.enabled)
+            return;
+        if (this.isGroup(jid))
+            return;
+        if (this.config.autoRegisterOnIncoming) {
+            this.registerKnownContact(jid);
+        }
+    }
+    /**
+     * Get statistics.
+     */
+    getStats() {
+        const knownContacts = Array.from(this.contacts.values()).filter(c => c.state === 'known').length;
+        const pendingHandshakes = Array.from(this.contacts.values()).filter(c => c.state === 'handshake_sent').length;
+        const groupsJoined = Array.from(this.groups.entries()).map(([groupJid, record]) => ({
+            groupJid,
+            joinedAt: record.joinedAt,
+            firstSendUnlocksAt: record.joinedAt + this.config.groupLurkPeriodMs,
+        }));
+        return {
+            knownContacts,
+            pendingHandshakes,
+            strangersToday: this.strangerMessagesToday,
+            groupsJoined,
+        };
+    }
+    /**
+     * Reset all state.
+     */
+    reset() {
+        this.contacts.clear();
+        this.groups.clear();
+        this.strangerMessagesToday = 0;
+        this.lastStrangerResetDay = this.getCurrentDay();
+    }
+    /**
+     * Export state for persistence.
+     */
+    exportState() {
+        return {
+            contacts: Array.from(this.contacts.entries()),
+            groups: Array.from(this.groups.entries()),
+            strangerMessagesToday: this.strangerMessagesToday,
+            lastStrangerResetDay: this.lastStrangerResetDay,
+        };
+    }
+    /**
+     * Restore state from persistence.
+     */
+    restoreState(state) {
+        if (state?.contacts && Array.isArray(state.contacts)) {
+            this.contacts = new Map(state.contacts);
+        }
+        if (state?.groups && Array.isArray(state.groups)) {
+            this.groups = new Map(state.groups);
+        }
+        if (typeof state?.strangerMessagesToday === 'number') {
+            this.strangerMessagesToday = state.strangerMessagesToday;
+        }
+        if (typeof state?.lastStrangerResetDay === 'number') {
+            this.lastStrangerResetDay = state.lastStrangerResetDay;
+        }
+    }
+    // Private helpers
+    isGroup(jid) {
+        return jid.endsWith('@g.us');
+    }
+    getCurrentDay() {
+        return Math.floor(Date.now() / 86400000);
+    }
+    checkGroupMessage(groupJid) {
+        const record = this.groups.get(groupJid);
+        if (!record) {
+            // Group not registered — allow (assume old membership)
+            return { allowed: true };
+        }
+        const lurkEndsAt = record.joinedAt + this.config.groupLurkPeriodMs;
+        if (Date.now() < lurkEndsAt) {
+            const minutesLeft = Math.ceil((lurkEndsAt - Date.now()) / 60000);
+            return {
+                allowed: false,
+                reason: `Group lurk period not elapsed — wait ${minutesLeft} minutes`,
+            };
+        }
+        return { allowed: true };
+    }
+    checkIndividualMessage(jid) {
+        const record = this.contacts.get(jid);
+        // Unknown contact (stranger)
+        if (!record || record.state === 'stranger') {
+            if (this.config.requireHandshakeBeforeGroupSend) {
+                // Check daily stranger quota
+                if (this.strangerMessagesToday >= this.config.maxStrangerMessagesPerDay) {
+                    return {
+                        allowed: false,
+                        reason: `Daily new-contact limit reached (${this.config.maxStrangerMessagesPerDay})`,
+                        needsHandshake: true,
+                    };
+                }
+                // Allow but increment counter
+                this.strangerMessagesToday++;
+            }
+            return { allowed: true, needsHandshake: true };
+        }
+        // Handshake sent — check delay
+        if (record.state === 'handshake_sent') {
+            if (!record.handshakeSentAt) {
+                // No timestamp — shouldn't happen, but allow
+                return { allowed: true };
+            }
+            const elapsed = Date.now() - record.handshakeSentAt;
+            if (elapsed < this.config.handshakeMinDelayMs) {
+                const minutesLeft = Math.ceil((this.config.handshakeMinDelayMs - elapsed) / 60000);
+                return {
+                    allowed: false,
+                    reason: `Handshake too recent — wait ${minutesLeft} minutes`,
+                };
+            }
+        }
+        // handshake_complete or known — allow
+        return { allowed: true };
+    }
+}

package/lib/AntiBan/contentVariator.js

@@ -0,0 +1,150 @@
+/**
+ * Content Variator — Auto-vary messages to avoid spam detection
+ *
+ * WhatsApp flags identical messages sent to multiple recipients.
+ * This module adds invisible variations so each message is technically unique.
+ */
+const DEFAULT_CONFIG = {
+    zeroWidthChars: true,
+    punctuationVariation: true,
+    emojiPadding: false,
+    synonyms: false,
+};
+// Zero-width characters invisible to users
+const ZERO_WIDTH = [
+    '\u200B', // zero-width space
+    '\u200C', // zero-width non-joiner
+    '\u200D', // zero-width joiner
+    '\uFEFF', // zero-width no-break space
+];
+const SYNONYMS = {
+    'hello': ['hi', 'hey', 'howdy'],
+    'hi': ['hello', 'hey', 'howdy'],
+    'thanks': ['thank you', 'thx', 'cheers'],
+    'please': ['kindly', 'pls'],
+    'great': ['awesome', 'excellent', 'wonderful'],
+    'good': ['great', 'nice', 'fine'],
+    'buy': ['purchase', 'get', 'grab'],
+    'sell': ['offer', 'list'],
+    'price': ['cost', 'amount', 'value'],
+    'available': ['in stock', 'on offer'],
+    'check': ['look at', 'see', 'view'],
+    'join': ['participate', 'enter', 'come to'],
+    'start': ['begin', 'kick off', 'commence'],
+    'end': ['finish', 'close', 'conclude'],
+    'bid': ['offer', 'place a bid'],
+    'win': ['secure', 'take home'],
+    'item': ['lot', 'piece', 'product'],
+};
+export class ContentVariator {
+    config;
+    counter = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Create a unique variation of a message
+     * Each call produces a slightly different version
+     */
+    vary(text) {
+        let result = text;
+        this.counter++;
+        if (this.config.customVariator) {
+            return this.config.customVariator(result, this.counter);
+        }
+        if (this.config.synonyms) {
+            result = this.applySynonyms(result);
+        }
+        if (this.config.zeroWidthChars) {
+            result = this.addZeroWidth(result);
+        }
+        if (this.config.punctuationVariation) {
+            result = this.varyPunctuation(result);
+        }
+        if (this.config.emojiPadding) {
+            result = this.addEmojiPadding(result);
+        }
+        return result;
+    }
+    /**
+     * Create N unique variations of a message
+     */
+    varyBulk(text, count) {
+        const results = [];
+        const seen = new Set();
+        for (let i = 0; i < count; i++) {
+            let variation = this.vary(text);
+            // Ensure uniqueness
+            let attempts = 0;
+            while (seen.has(variation) && attempts < 10) {
+                variation = this.vary(text);
+                attempts++;
+            }
+            seen.add(variation);
+            results.push(variation);
+        }
+        return results;
+    }
+    addZeroWidth(text) {
+        const words = text.split(' ');
+        if (words.length < 2)
+            return text;
+        // Insert 1-2 zero-width chars at random positions between words
+        const positions = this.randomPositions(words.length - 1, Math.min(2, words.length - 1));
+        return words.map((word, i) => {
+            if (positions.includes(i)) {
+                const zwc = ZERO_WIDTH[Math.floor(Math.random() * ZERO_WIDTH.length)];
+                return word + zwc;
+            }
+            return word;
+        }).join(' ');
+    }
+    varyPunctuation(text) {
+        const variations = [
+            // Trailing space variations
+            () => text + ' ',
+            () => text + '  ',
+            // Period variations
+            () => text.endsWith('.') ? text.slice(0, -1) : text + '.',
+            // Nothing
+            () => text,
+            // Capitalize first letter variation
+            () => text.charAt(0) === text.charAt(0).toUpperCase()
+                ? text.charAt(0).toLowerCase() + text.slice(1)
+                : text,
+        ];
+        return variations[this.counter % variations.length]();
+    }
+    addEmojiPadding(text) {
+        const emojis = ['', ' 👍', ' ✅', ' 📌', ' 💬', ' 📢'];
+        return text + emojis[this.counter % emojis.length];
+    }
+    applySynonyms(text) {
+        const words = text.split(/\b/);
+        let replaced = false;
+        return words.map(word => {
+            if (replaced)
+                return word;
+            const lower = word.toLowerCase();
+            const synonymList = SYNONYMS[lower];
+            if (synonymList && Math.random() > 0.5) {
+                replaced = true; // Only replace one word per message
+                const synonym = synonymList[Math.floor(Math.random() * synonymList.length)];
+                // Preserve original casing
+                return word[0] === word[0].toUpperCase()
+                    ? synonym.charAt(0).toUpperCase() + synonym.slice(1)
+                    : synonym;
+            }
+            return word;
+        }).join('');
+    }
+    randomPositions(max, count) {
+        const positions = [];
+        while (positions.length < count) {
+            const pos = Math.floor(Math.random() * max);
+            if (!positions.includes(pos))
+                positions.push(pos);
+        }
+        return positions;
+    }
+}