@prototypevip/baileys 0.0.8 → 0.1.0

package/lib/AntiBan/topologyThrottler.js

@@ -0,0 +1,339 @@
+/**
+ * Topology Throttler — Network topology-based anti-ban enforcement
+ *
+ * WhatsApp bans based on NETWORK TOPOLOGY, not just message timing:
+ * - How fast you expand your contact graph
+ * - Cold-contact ratio (strangers vs known contacts)
+ * - Reply reciprocity
+ * - Group-source clustering (mass-DMing group members)
+ *
+ * This module enforces graph expansion limits and scores contact risk
+ * before each send, acting as the primary enforcement layer for high-risk
+ * cold outreach.
+ *
+ * Key insight: A 30% reply rate is the minimum to unlock more cold sends.
+ * Below that, WhatsApp's ML models flag you as a spammer.
+ */
+const TIME_CONSTANTS = {
+    MS_PER_HOUR: 3600000,
+    MS_PER_DAY: 86400000,
+    MS_PER_24H: 86400000,
+    REPLY_WINDOW_DAYS: 7,
+};
+const DEFAULT_CONFIG = {
+    maxNewContactsPerHour: 5,
+    maxNewContactsPerDay: 20,
+    minReplyRatioForNewContacts: 0.3,
+    maxSameGroupContacts: 10,
+    maxContactsFromSameSource: 8,
+    blockOnLimitReached: true,
+    cooldownMs: TIME_CONSTANTS.MS_PER_HOUR,
+    riskConfig: {
+        firstContactPenalty: 40,
+        noReplyPenalty: 20,
+        noMutualGroupsPenalty: 15,
+        recentContactBonus: -20,
+        repliedBeforeBonus: -30,
+        delayThreshold: 40,
+        abortThreshold: 75,
+    },
+};
+const DEFAULT_RISK_CONFIG = {
+    firstContactPenalty: 40,
+    noReplyPenalty: 20,
+    noMutualGroupsPenalty: 15,
+    recentContactBonus: -20,
+    repliedBeforeBonus: -30,
+    delayThreshold: 40,
+    abortThreshold: 75,
+};
+export class TopologyThrottler {
+    config;
+    riskConfig;
+    contacts = new Map();
+    limits;
+    sourceGroupCounts = new Map();
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.riskConfig = { ...DEFAULT_RISK_CONFIG, ...this.config.riskConfig };
+        this.limits = {
+            newContactsThisHour: 0,
+            newContactsToday: 0,
+            lastHourResetAt: Date.now(),
+            lastDayResetAt: Date.now(),
+        };
+    }
+    /**
+     * Assess contact risk before sending.
+     * This is the main check — call before every send to a new/unknown contact.
+     */
+    assessContact(jid, context) {
+        this.resetLimitsIfNeeded();
+        const record = this.contacts.get(jid);
+        const now = Date.now();
+        let score = 0;
+        const reasons = [];
+        // First contact penalty
+        if (!record) {
+            score += this.riskConfig.firstContactPenalty;
+            reasons.push('first_contact');
+        }
+        else {
+            // Has record — check reply history
+            if (record.replyTimestamps.length === 0 && record.sendTimestamps.length > 0) {
+                score += this.riskConfig.noReplyPenalty;
+                reasons.push('no_reply_history');
+            }
+        }
+        // No mutual groups penalty
+        if (!context.knownGroups || context.knownGroups.length === 0) {
+            score += this.riskConfig.noMutualGroupsPenalty;
+            reasons.push('no_mutual_groups');
+        }
+        // Recent contact bonus
+        if (context.lastContactAt && (now - context.lastContactAt) < TIME_CONSTANTS.MS_PER_24H) {
+            score += this.riskConfig.recentContactBonus;
+            reasons.push('recent_contact');
+        }
+        // Replied before bonus
+        if (context.hasReplied || (record && record.replyTimestamps.length > 0)) {
+            score += this.riskConfig.repliedBeforeBonus;
+            reasons.push('has_replied');
+        }
+        // Clamp score to 0-100
+        score = Math.max(0, Math.min(100, score));
+        // Determine risk level
+        let risk;
+        let recommendation;
+        let suggestedDelayMs;
+        if (score >= this.riskConfig.abortThreshold) {
+            risk = 'CRITICAL';
+            recommendation = 'abort';
+            reasons.push('risk_too_high');
+        }
+        else if (score >= this.riskConfig.delayThreshold) {
+            risk = score >= 60 ? 'HIGH' : 'MEDIUM';
+            recommendation = 'delay';
+            // Exponential delay based on score
+            const delayMinutes = Math.floor((score - this.riskConfig.delayThreshold) / 10);
+            suggestedDelayMs = delayMinutes * 60000;
+            reasons.push('recommend_delay');
+        }
+        else {
+            risk = score >= 30 ? 'MEDIUM' : 'LOW';
+            recommendation = 'send';
+        }
+        return {
+            jid,
+            risk,
+            score,
+            reasons,
+            recommendation,
+            suggestedDelayMs,
+        };
+    }
+    /**
+     * Record a sent message to this contact.
+     */
+    recordSent(jid, sourceGroup) {
+        this.resetLimitsIfNeeded();
+        const now = Date.now();
+        let record = this.contacts.get(jid);
+        if (!record) {
+            // New contact — increment limits
+            record = {
+                firstContactAt: now,
+                sendTimestamps: [],
+                replyTimestamps: [],
+                blocked: false,
+                sourceGroup,
+            };
+            this.contacts.set(jid, record);
+            this.limits.newContactsThisHour++;
+            this.limits.newContactsToday++;
+            // Track source group
+            if (sourceGroup) {
+                const count = this.sourceGroupCounts.get(sourceGroup) || 0;
+                this.sourceGroupCounts.set(sourceGroup, count + 1);
+            }
+        }
+        // Add send timestamp (keep sliding window)
+        record.sendTimestamps.push(now);
+        this.cleanupTimestamps(record.sendTimestamps, TIME_CONSTANTS.REPLY_WINDOW_DAYS * TIME_CONSTANTS.MS_PER_DAY);
+    }
+    /**
+     * Record a reply from this contact.
+     */
+    recordReplied(jid) {
+        const record = this.contacts.get(jid);
+        if (!record)
+            return;
+        const now = Date.now();
+        record.replyTimestamps.push(now);
+        this.cleanupTimestamps(record.replyTimestamps, TIME_CONSTANTS.REPLY_WINDOW_DAYS * TIME_CONSTANTS.MS_PER_DAY);
+    }
+    /**
+     * Record that this contact blocked you.
+     */
+    recordBlocked(jid) {
+        const record = this.contacts.get(jid);
+        if (!record)
+            return;
+        record.blocked = true;
+    }
+    /**
+     * Check if topology limits allow sending to a new contact.
+     * Returns whether allowed and reason/retry time if blocked.
+     */
+    canSendToNewContact() {
+        this.resetLimitsIfNeeded();
+        const now = Date.now();
+        // Check cooldown
+        if (this.limits.limitHitAt) {
+            const cooldownEndsAt = this.limits.limitHitAt + this.config.cooldownMs;
+            if (now < cooldownEndsAt) {
+                const retryAfterMs = cooldownEndsAt - now;
+                return {
+                    allowed: false,
+                    reason: `Cooldown active — limit hit recently`,
+                    retryAfterMs,
+                };
+            }
+            else {
+                // Cooldown expired
+                delete this.limits.limitHitAt;
+            }
+        }
+        // Check hourly limit
+        if (this.limits.newContactsThisHour >= this.config.maxNewContactsPerHour) {
+            this.limits.limitHitAt = now;
+            const retryAfterMs = (this.limits.lastHourResetAt + TIME_CONSTANTS.MS_PER_HOUR) - now;
+            return {
+                allowed: false,
+                reason: `Hourly new contact limit reached (${this.config.maxNewContactsPerHour})`,
+                retryAfterMs: Math.max(0, retryAfterMs),
+            };
+        }
+        // Check daily limit
+        if (this.limits.newContactsToday >= this.config.maxNewContactsPerDay) {
+            this.limits.limitHitAt = now;
+            const retryAfterMs = (this.limits.lastDayResetAt + TIME_CONSTANTS.MS_PER_DAY) - now;
+            return {
+                allowed: false,
+                reason: `Daily new contact limit reached (${this.config.maxNewContactsPerDay})`,
+                retryAfterMs: Math.max(0, retryAfterMs),
+            };
+        }
+        // Check reply ratio requirement
+        const replyRatio = this.calculateReplyRatio();
+        if (replyRatio !== null && replyRatio < this.config.minReplyRatioForNewContacts) {
+            // Poor reply ratio — need to improve engagement before more cold sends
+            return {
+                allowed: false,
+                reason: `Reply ratio too low (${Math.round(replyRatio * 100)}% < ${Math.round(this.config.minReplyRatioForNewContacts * 100)}%)`,
+                retryAfterMs: TIME_CONSTANTS.MS_PER_HOUR, // arbitrary — user needs to improve engagement
+            };
+        }
+        return { allowed: true };
+    }
+    /**
+     * Get topology statistics.
+     */
+    getTopologyStats() {
+        this.resetLimitsIfNeeded();
+        const replyRatio = this.calculateReplyRatio();
+        const blockedRatio = this.calculateBlockedRatio();
+        // Get top 5 source group hotspots
+        const hotspots = Array.from(this.sourceGroupCounts.entries())
+            .map(([sourceGroup, count]) => ({ sourceGroup, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 5);
+        return {
+            newContactsThisHour: this.limits.newContactsThisHour,
+            newContactsToday: this.limits.newContactsToday,
+            replyRatio,
+            blockedRatio,
+            hotspots,
+        };
+    }
+    /**
+     * Export state for persistence.
+     */
+    exportState() {
+        return {
+            contacts: Array.from(this.contacts.entries()),
+            limits: { ...this.limits },
+            sourceGroupCounts: Array.from(this.sourceGroupCounts.entries()),
+        };
+    }
+    /**
+     * Import state from persistence.
+     */
+    importState(state) {
+        if (state.contacts) {
+            this.contacts = new Map(state.contacts);
+        }
+        if (state.limits) {
+            this.limits = { ...state.limits };
+        }
+        if (state.sourceGroupCounts) {
+            this.sourceGroupCounts = new Map(state.sourceGroupCounts);
+        }
+    }
+    // Private helpers
+    resetLimitsIfNeeded() {
+        const now = Date.now();
+        // Reset hourly counter
+        if (now - this.limits.lastHourResetAt >= TIME_CONSTANTS.MS_PER_HOUR) {
+            this.limits.newContactsThisHour = 0;
+            this.limits.lastHourResetAt = now;
+        }
+        // Reset daily counter
+        if (now - this.limits.lastDayResetAt >= TIME_CONSTANTS.MS_PER_DAY) {
+            this.limits.newContactsToday = 0;
+            this.limits.lastDayResetAt = now;
+            // Clear source group counts daily
+            this.sourceGroupCounts.clear();
+        }
+    }
+    calculateReplyRatio() {
+        const now = Date.now();
+        const windowMs = TIME_CONSTANTS.REPLY_WINDOW_DAYS * TIME_CONSTANTS.MS_PER_DAY;
+        let totalSent = 0;
+        let totalReplies = 0;
+        for (const record of this.contacts.values()) {
+            // Count sends in window
+            const recentSends = record.sendTimestamps.filter(t => now - t < windowMs);
+            totalSent += recentSends.length;
+            // Count replies in window
+            const recentReplies = record.replyTimestamps.filter(t => now - t < windowMs);
+            totalReplies += recentReplies.length;
+        }
+        if (totalSent === 0)
+            return null; // No data yet
+        return totalReplies / totalSent;
+    }
+    calculateBlockedRatio() {
+        const totalContacts = this.contacts.size;
+        if (totalContacts === 0)
+            return null;
+        let blockedCount = 0;
+        for (const record of this.contacts.values()) {
+            if (record.blocked)
+                blockedCount++;
+        }
+        return blockedCount / totalContacts;
+    }
+    cleanupTimestamps(timestamps, maxAgeMs) {
+        const now = Date.now();
+        const cutoff = now - maxAgeMs;
+        // Remove old timestamps (in-place filter)
+        let writeIdx = 0;
+        for (let readIdx = 0; readIdx < timestamps.length; readIdx++) {
+            if (timestamps[readIdx] >= cutoff) {
+                timestamps[writeIdx++] = timestamps[readIdx];
+            }
+        }
+        timestamps.length = writeIdx;
+    }
+}

package/lib/AntiBan/warmup.js

@@ -0,0 +1,140 @@
+/**
+ * WarmUp — Gradual activity increase for new/reconnected numbers
+ *
+ * New numbers or numbers reconnecting after a break are under extra scrutiny.
+ * This module enforces a gradual ramp-up of messaging activity.
+ *
+ * WhatsApp flags:
+ * - New numbers sending many messages immediately
+ * - Numbers going from 0 to 100 messages/day overnight
+ * - Sudden pattern changes after period of inactivity
+ */
+/** Generate a random growth factor in [1.5, 2.2] to avoid cross-account clustering */
+function randomGrowthFactor() {
+    return Math.round((1.5 + Math.random() * 0.7) * 100) / 100;
+}
+const DEFAULT_CONFIG = {
+    warmUpDays: 7,
+    day1Limit: 20,
+    growthFactor: randomGrowthFactor(), // intentionally non-deterministic
+    inactivityThresholdHours: 72,
+};
+export class WarmUp {
+    config;
+    state;
+    constructor(config = {}, existingState) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.state = existingState || this.freshState();
+    }
+    /**
+     * Get the current daily message limit based on warm-up phase
+     */
+    getDailyLimit() {
+        if (this.state.graduated)
+            return Infinity;
+        const day = this.getCurrentDay();
+        if (day >= this.config.warmUpDays) {
+            this.state.graduated = true;
+            return Infinity;
+        }
+        return Math.round(this.config.day1Limit * Math.pow(this.config.growthFactor, day));
+    }
+    /**
+     * Check if a message can be sent (within warm-up limits)
+     */
+    canSend() {
+        this.checkInactivity();
+        if (this.state.graduated)
+            return true;
+        const day = this.getCurrentDay();
+        const todayCount = this.state.dailyCounts[day] || 0;
+        return todayCount < this.getDailyLimit();
+    }
+    /**
+     * Record a sent message
+     */
+    record() {
+        const now = Date.now();
+        const day = this.getCurrentDay();
+        while (this.state.dailyCounts.length <= day) {
+            this.state.dailyCounts.push(0);
+        }
+        this.state.dailyCounts[day]++;
+        this.state.lastActiveAt = now;
+    }
+    /**
+     * Get current warm-up status
+     */
+    getStatus() {
+        const day = this.getCurrentDay();
+        const todaySent = this.state.dailyCounts[day] || 0;
+        const limit = this.getDailyLimit();
+        return {
+            phase: this.state.graduated ? 'graduated' : 'warming',
+            day: Math.min(day + 1, this.config.warmUpDays),
+            totalDays: this.config.warmUpDays,
+            todayLimit: limit === Infinity ? -1 : limit,
+            todaySent,
+            progress: this.state.graduated ? 100 : Math.round((day / this.config.warmUpDays) * 100),
+        };
+    }
+    /**
+     * Export state for persistence
+     */
+    exportState() {
+        const day = this.getCurrentDay();
+        const todaySent = this.state.dailyCounts[day] || 0;
+        const todayDate = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+        return {
+            ...this.state,
+            todaySentCount: todaySent,
+            todayDate,
+        };
+    }
+    /**
+     * Import state from persistence
+     */
+    importState(state) {
+        this.state = { ...state };
+        // BUG FIX 1: Restore today's send count from persisted state
+        // If todayDate matches current date, restore the count to prevent
+        // post-crash burst (issue: warmup day counter survives but send history lost)
+        if (state.todayDate && state.todaySentCount !== undefined) {
+            const todayDate = new Date().toISOString().split('T')[0];
+            if (state.todayDate === todayDate) {
+                const day = this.getCurrentDay();
+                // Restore the persisted count if higher than current
+                while (this.state.dailyCounts.length <= day) {
+                    this.state.dailyCounts.push(0);
+                }
+                this.state.dailyCounts[day] = Math.max(this.state.dailyCounts[day] || 0, state.todaySentCount);
+            }
+        }
+    }
+    /**
+     * Reset warm-up (e.g., after detected ban risk)
+     */
+    reset() {
+        this.state = this.freshState();
+    }
+    getCurrentDay() {
+        return Math.floor((Date.now() - this.state.startedAt) / 86400000);
+    }
+    checkInactivity() {
+        const hoursSinceActive = (Date.now() - this.state.lastActiveAt) / 3600000;
+        if (hoursSinceActive > this.config.inactivityThresholdHours && this.state.graduated) {
+            // Re-enter warm-up after extended inactivity
+            this.state = this.freshState();
+            this.state.graduated = false;
+        }
+    }
+    freshState() {
+        const now = Date.now();
+        return {
+            startedAt: now,
+            lastActiveAt: now,
+            dailyCounts: [],
+            graduated: false,
+        };
+    }
+}

package/lib/AntiBan/webhooks.js

@@ -0,0 +1,80 @@
+/**
+ * Webhook Alerts — Get notified on Telegram/Discord/Slack when risk changes
+ */
+const DEFAULT_CONFIG = {
+    urls: [],
+    minRiskLevel: 'medium',
+    cooldownMs: 300000,
+    includeStats: true,
+};
+export class WebhookAlerts {
+    config;
+    lastAlertTime = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Send alert if risk level warrants it
+     */
+    async alert(data) {
+        const riskOrder = ['low', 'medium', 'high', 'critical'];
+        if (riskOrder.indexOf(data.risk) < riskOrder.indexOf(this.config.minRiskLevel)) {
+            return; // Below threshold
+        }
+        const now = Date.now();
+        if (now - this.lastAlertTime < this.config.cooldownMs) {
+            return; // Cooldown active
+        }
+        this.lastAlertTime = now;
+        const payload = {
+            source: 'baileys-antiban',
+            timestamp: new Date().toISOString(),
+            ...data,
+        };
+        // Send to generic webhook URLs
+        for (const url of this.config.urls) {
+            this.postWebhook(url, payload).catch(() => { });
+        }
+        // Telegram
+        if (this.config.telegram) {
+            const emoji = { low: '🟢', medium: '🟡', high: '🟠', critical: '🔴' }[data.risk] || '⚪';
+            const text = `${emoji} *baileys-antiban Alert*\n\nRisk: *${data.risk.toUpperCase()}* (score: ${data.score})\n${data.recommendation}\n\nReasons:\n${data.reasons.map(r => `• ${r}`).join('\n')}`;
+            this.postWebhook(`https://api.telegram.org/bot${this.config.telegram.botToken}/sendMessage`, { chat_id: this.config.telegram.chatId, text, parse_mode: 'Markdown' }).catch(() => { });
+        }
+        // Discord
+        if (this.config.discord) {
+            const color = { low: 0x00ff00, medium: 0xffff00, high: 0xff8800, critical: 0xff0000 }[data.risk] || 0;
+            this.postWebhook(this.config.discord.webhookUrl, {
+                embeds: [{
+                        title: '🛡️ baileys-antiban Alert',
+                        color,
+                        fields: [
+                            { name: 'Risk', value: data.risk.toUpperCase(), inline: true },
+                            { name: 'Score', value: String(data.score), inline: true },
+                            { name: 'Recommendation', value: data.recommendation },
+                            { name: 'Reasons', value: data.reasons.join('\n') },
+                        ],
+                        timestamp: new Date().toISOString(),
+                    }],
+            }).catch(() => { });
+        }
+    }
+    async postWebhook(url, payload) {
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.config.headers,
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok) {
+                console.error(`[baileys-antiban] Webhook failed: ${response.status}`);
+            }
+        }
+        catch (err) {
+            console.error(`[baileys-antiban] Webhook error:`, err);
+        }
+    }
+}