baileys-antiban 3.6.1 → 3.8.0

package/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.8.0] - 2026-04-28
+
+### Added
+- **Stealth Connect** — Gradual presence ramp to reduce ban signals. Inspired by GOWA's `--presence-on-connect=unavailable` flag. Bots that instantly snap online and start blasting messages look suspicious. New helpers:
+  - `getStealthSocketConfig({ os?: string })` — returns socket config with `markOnlineOnConnect: false` and sensible browser defaults.
+  - `rampPresenceAfterConnect(sock, { minDelayMs?, maxDelayMs?, targetState? })` — waits 30-90s (configurable), then transitions presence to `available` (or custom state). Call after socket connects. Returns a promise.
+- Use together: connect silently, ramp presence gradually when ready to act.
+
+## [3.7.0] - 2026-04-27
+
+### Added
+- `LidResolver.learnFromGroupMetadata(participants)` — ingest LID↔PN mappings from Baileys group metadata. Supports v6 (`id: '@s.whatsapp.net', lid: '@lid'`) and v7 (`id: '@lid', phoneNumber: '@s.whatsapp.net'`) participant formats.
+- `JidCanonicalizer.learnFromGroupMetadata(participants)` — passthrough to `LidResolver.learnFromGroupMetadata()`.
+
+### Fixed
+- Confirmed compatibility with Baileys v7.0.0-rc.9 LID migration. `resolveCanonical()` correctly falls back to original JID when LID→PN mapping is unknown (no throw).
+
+### Notes
+- Default `enabled: false` unchanged — opt-in as always.
+- Group metadata learning is the recommended way to pre-populate LID mappings for auction groups where `getCachedGroupMetadata()` is called anyway.
+
 ## [3.6.1] - 2026-04-26
 
 ### Changed

package/README.md

@@ -599,6 +599,21 @@ npx baileys-antiban warmup --simulate 7 --preset moderate
 npx baileys-antiban reset --state ./antiban-state.json
 ```
 
+### Stealth Connect (v3.8.0)
+
+Bots that instantly snap online and start blasting messages look suspicious. Stealth connect delays presence ramp to look more human.
+
+```typescript
+import { makeWASocket } from '@whiskeysockets/baileys';
+import { getStealthSocketConfig, rampPresenceAfterConnect } from 'baileys-antiban';
+
+const config = getStealthSocketConfig({ os: 'My Custom App' });
+const sock = makeWASocket({ ...config, auth: state });
+
+// Wait 30-90s, then go available (or fire-and-forget)
+await rampPresenceAfterConnect(sock, { minDelayMs: 45000, maxDelayMs: 120000 });
+```
+
 ## Quick Start (Legacy)
 
 ### Option 1: Wrap Your Socket (Easiest)

package/dist/index.d.ts

@@ -36,3 +36,5 @@ export { generateFingerprint, applyFingerprint, type DeviceFingerprint, type Dev
 export { credsSnapshot, type CredsSnapshot, type CredsSnapshotConfig, } from './credsSnapshot.js';
 export { readReceiptVariance, type ReadReceiptVariance, type ReadReceiptVarianceConfig, } from './readReceiptVariance.js';
 export { proxyRotator, type ProxyEndpoint, type ProxyRotatorConfig, type ProxyRotatorStats, type ProxyRotatorHandle, } from './proxyRotator.js';
+export { generateSessionFingerprint, applySessionFingerprint, getMessageSendJitter, getTypingJitter, getRetryJitter, getVoiceNoteMetadata, getBatteryState, createStealthFingerprint, type SessionFingerprint, type SessionFingerprintConfig, } from './sessionFingerprint.js';
+export { getStealthSocketConfig, rampPresenceAfterConnect, } from './stealthConnect.js';

package/dist/index.js

@@ -49,3 +49,7 @@ export { credsSnapshot, } from './credsSnapshot.js';
 export { readReceiptVariance, } from './readReceiptVariance.js';
 // v3.5 new modules
 export { proxyRotator, } from './proxyRotator.js';
+// v3.6 new modules (Obscura-inspired)
+export { generateSessionFingerprint, applySessionFingerprint, getMessageSendJitter, getTypingJitter, getRetryJitter, getVoiceNoteMetadata, getBatteryState, createStealthFingerprint, } from './sessionFingerprint.js';
+// v3.8 new modules
+export { getStealthSocketConfig, rampPresenceAfterConnect, } from './stealthConnect.js';

package/dist/jidCanonicalizer.d.ts

@@ -80,6 +80,21 @@ export declare class JidCanonicalizer {
         messages: Array<any>;
         type?: string;
     }): void;
+    /**
+     * Learn LID↔PN mappings from group metadata participants.
+     * Call after fetchGroupMetadata() to pre-populate the resolver map.
+     * No-op if canonicalization is disabled.
+     *
+     * @param participants - Group metadata participants array from Baileys
+     * @returns Number of new mappings learned (0 if disabled)
+     */
+    learnFromGroupMetadata(participants: Array<{
+        id: string;
+        lid?: string;
+        phoneNumber?: string;
+        phone?: string;
+        number?: string;
+    }>): number;
     /**
      * Called by wrapper on messages.update event. Learns from sent-message refs.
      */

package/dist/jidCanonicalizer.js

@@ -149,6 +149,20 @@ export class JidCanonicalizer {
             this.learnFromMessage(msg);
         }
     }
+    /**
+     * Learn LID↔PN mappings from group metadata participants.
+     * Call after fetchGroupMetadata() to pre-populate the resolver map.
+     * No-op if canonicalization is disabled.
+     *
+     * @param participants - Group metadata participants array from Baileys
+     * @returns Number of new mappings learned (0 if disabled)
+     */
+    learnFromGroupMetadata(participants) {
+        if (!this.config.enabled || !this.config.learnFromEvents) {
+            return 0;
+        }
+        return this.lidResolver.learnFromGroupMetadata(participants);
+    }
     /**
      * Called by wrapper on messages.update event. Learns from sent-message refs.
      */

package/dist/lidResolver.d.ts

@@ -71,6 +71,22 @@ export declare class LidResolver {
      * Full mapping for inspection
      */
     getMapping(jid: string): LidMapping | null;
+    /**
+     * Learn LID↔PN mappings from group metadata participants.
+     * Call this after fetchGroupMetadata() to pre-populate the map.
+     * Supports both {id: '@lid', phoneNumber: '@s.whatsapp.net'} and
+     * {id: '@s.whatsapp.net', lid: '@lid'} participant formats (v7 + v6 shapes).
+     *
+     * @param participants - Group metadata participants array from Baileys
+     * @returns Number of new mappings learned
+     */
+    learnFromGroupMetadata(participants: Array<{
+        id: string;
+        lid?: string;
+        phoneNumber?: string;
+        phone?: string;
+        number?: string;
+    }>): number;
     /**
      * Seed from persistence (called automatically in constructor if persistence provided)
      */

package/dist/lidResolver.js

@@ -178,6 +178,38 @@ export class LidResolver {
         }
         return null;
     }
+    /**
+     * Learn LID↔PN mappings from group metadata participants.
+     * Call this after fetchGroupMetadata() to pre-populate the map.
+     * Supports both {id: '@lid', phoneNumber: '@s.whatsapp.net'} and
+     * {id: '@s.whatsapp.net', lid: '@lid'} participant formats (v7 + v6 shapes).
+     *
+     * @param participants - Group metadata participants array from Baileys
+     * @returns Number of new mappings learned
+     */
+    learnFromGroupMetadata(participants) {
+        let learned = 0;
+        for (const p of participants) {
+            const domain = p.id.split('@')[1] || '';
+            if (domain === 'lid' && (p.phoneNumber || p.phone || p.number)) {
+                const pn = p.phoneNumber || (p.phone ? `${p.phone}@s.whatsapp.net` : null) || (p.number ? `${p.number}@s.whatsapp.net` : null);
+                if (pn) {
+                    const prevSize = this.lidToPn.size;
+                    this.learn({ lid: p.id, pn });
+                    if (this.lidToPn.size > prevSize)
+                        learned++;
+                }
+            }
+            else if (domain === 's.whatsapp.net' && p.lid) {
+                const lid = p.lid.endsWith('@lid') ? p.lid : `${p.lid}@lid`;
+                const prevSize = this.lidToPn.size;
+                this.learn({ lid, pn: p.id });
+                if (this.lidToPn.size > prevSize)
+                    learned++;
+            }
+        }
+        return learned;
+    }
     /**
      * Seed from persistence (called automatically in constructor if persistence provided)
      */

package/dist/sessionFingerprint.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Session Fingerprint Randomization (Obscura-inspired)
+ *
+ * Per-session fingerprint randomization to prevent device tracking.
+ * Scavenged patterns from Obscura headless browser's stealth mode.
+ *
+ * Key principles from Obscura:
+ * 1. Per-session randomization (not per-request)
+ * 2. Consistent within session (same session = same fingerprint)
+ * 3. Feature-flag pattern for optional anti-detection
+ * 4. Emulation of real device profiles (not synthetic values)
+ *
+ * Browser fingerprint → WhatsApp signal mapping:
+ * - TLS fingerprint → WA protocol version
+ * - Canvas noise → message timing jitter
+ * - Audio fingerprint → voice note metadata
+ * - GPU info → device model/brand
+ * - Battery → connection state variation
+ * - User agent → WA client version
+ *
+ * @author Kobus Wentzel <kobie@pop.co.za>
+ * @license MIT
+ */
+import { type DeviceFingerprint } from './deviceFingerprint.js';
+export interface SessionFingerprintConfig {
+    /** Master switch for enhanced fingerprinting */
+    enabled?: boolean;
+    /** Device profile randomization (from deviceFingerprint.ts) */
+    deviceProfile?: {
+        randomizeAppVersion?: boolean;
+        randomizeOsVersion?: boolean;
+        randomizeDeviceModel?: boolean;
+        appVersionPool?: number[][];
+        osVersionPool?: string[];
+        deviceModelPool?: string[];
+    };
+    /** Network timing variance (anti-pattern detection) */
+    networkTiming?: {
+        /** Add jitter to message send timing (ms) */
+        sendJitterMs?: [number, number];
+        /** Add jitter to typing indicators (ms) */
+        typingJitterMs?: [number, number];
+        /** Vary connection retry backoff */
+        retryJitterMs?: [number, number];
+    };
+    /** Voice note metadata randomization */
+    voiceNote?: {
+        /** Vary waveform pattern slightly */
+        randomizeWaveform?: boolean;
+        /** Vary duration by small amount (ms) */
+        durationJitterMs?: number;
+        /** Randomize sample rate from pool */
+        sampleRatePool?: number[];
+    };
+    /** Connection state variance */
+    connectionState?: {
+        /** Vary idle timeout */
+        idleTimeoutJitterMs?: [number, number];
+        /** Vary keepalive interval */
+        keepaliveJitterMs?: [number, number];
+        /** Randomize battery state reported */
+        randomizeBattery?: boolean;
+        /** Battery level pool (0-100) */
+        batteryLevelPool?: number[];
+    };
+    /** Protocol version variance */
+    protocolVersion?: {
+        /** Randomize protocol sub-version */
+        randomizeSubVersion?: boolean;
+        /** Protocol version pool (e.g., different patch versions) */
+        versionPool?: string[];
+    };
+    /** Seed for deterministic randomization (testing/debugging) */
+    seed?: string;
+}
+export interface SessionFingerprint {
+    /** Core device profile */
+    device: DeviceFingerprint;
+    /** Network timing variances (stable per session) */
+    networkTiming: {
+        sendJitterMs: number;
+        typingJitterMs: number;
+        retryJitterMs: number;
+    };
+    /** Voice note profile */
+    voiceNote: {
+        waveformSeed: number;
+        durationJitterMs: number;
+        sampleRate: number;
+    };
+    /** Connection state profile */
+    connectionState: {
+        idleTimeoutMs: number;
+        keepaliveMs: number;
+        batteryLevel: number;
+        batteryCharging: boolean;
+    };
+    /** Protocol version */
+    protocolVersion: string;
+    /** Session identifier (stable for this fingerprint) */
+    sessionId: string;
+    /** Timestamp when fingerprint was generated */
+    createdAt: number;
+}
+/**
+ * Generate a comprehensive session fingerprint.
+ * Call once per session (socket initialization).
+ *
+ * Obscura pattern: consistent per session, randomized across sessions.
+ */
+export declare function generateSessionFingerprint(config?: SessionFingerprintConfig, sessionId?: string): SessionFingerprint;
+/**
+ * Apply session fingerprint to Baileys socket config.
+ *
+ * Usage:
+ *   const fingerprint = generateSessionFingerprint({ enabled: true });
+ *   const sock = makeWASocket(applySessionFingerprint(config, fingerprint));
+ */
+export declare function applySessionFingerprint(socketConfig: any, fingerprint: SessionFingerprint): any;
+/**
+ * Get timing jitter for message send (helper for presenceChoreographer/rateLimiter)
+ *
+ * Usage in beforeSend():
+ *   const jitter = getMessageSendJitter(fingerprint);
+ *   await sleep(baseDelay + jitter);
+ */
+export declare function getMessageSendJitter(fingerprint: SessionFingerprint): number;
+/**
+ * Get typing indicator jitter (helper for presenceChoreographer)
+ */
+export declare function getTypingJitter(fingerprint: SessionFingerprint): number;
+/**
+ * Get retry backoff jitter (helper for reconnectThrottle)
+ */
+export declare function getRetryJitter(fingerprint: SessionFingerprint): number;
+/**
+ * Get voice note metadata (helper for voice message encoding)
+ *
+ * Returns suggested sample rate and duration adjustment based on session fingerprint.
+ */
+export declare function getVoiceNoteMetadata(fingerprint: SessionFingerprint): {
+    sampleRate: number;
+    durationJitterMs: number;
+    waveformSeed: number;
+};
+/**
+ * Get battery state (helper for presence/connection state signals)
+ */
+export declare function getBatteryState(fingerprint: SessionFingerprint): {
+    level: number;
+    charging: boolean;
+};
+/**
+ * Create a session fingerprint preset (Obscura-inspired feature flag pattern)
+ */
+export declare function createStealthFingerprint(sessionId?: string): SessionFingerprint;

package/dist/sessionFingerprint.js

@@ -0,0 +1,248 @@
+/**
+ * Session Fingerprint Randomization (Obscura-inspired)
+ *
+ * Per-session fingerprint randomization to prevent device tracking.
+ * Scavenged patterns from Obscura headless browser's stealth mode.
+ *
+ * Key principles from Obscura:
+ * 1. Per-session randomization (not per-request)
+ * 2. Consistent within session (same session = same fingerprint)
+ * 3. Feature-flag pattern for optional anti-detection
+ * 4. Emulation of real device profiles (not synthetic values)
+ *
+ * Browser fingerprint → WhatsApp signal mapping:
+ * - TLS fingerprint → WA protocol version
+ * - Canvas noise → message timing jitter
+ * - Audio fingerprint → voice note metadata
+ * - GPU info → device model/brand
+ * - Battery → connection state variation
+ * - User agent → WA client version
+ *
+ * @author Kobus Wentzel <kobie@pop.co.za>
+ * @license MIT
+ */
+import { generateFingerprint } from './deviceFingerprint.js';
+/**
+ * Simple deterministic PRNG using mulberry32
+ * Same as deviceFingerprint.ts for consistency
+ */
+class SeededRandom {
+    state;
+    constructor(seed) {
+        let hash = 0;
+        for (let i = 0; i < seed.length; i++) {
+            hash = (hash << 5) - hash + seed.charCodeAt(i);
+            hash = hash & hash;
+        }
+        this.state = Math.abs(hash) || 1;
+    }
+    next() {
+        let t = (this.state += 0x6d2b79f5);
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    }
+    range(min, max) {
+        return Math.floor(this.next() * (max - min + 1)) + min;
+    }
+    rangeFloat(min, max) {
+        return this.next() * (max - min) + min;
+    }
+    pick(array) {
+        return array[Math.floor(this.next() * array.length)];
+    }
+    boolean(probability = 0.5) {
+        return this.next() < probability;
+    }
+}
+// Default configuration values (conservative, realistic)
+const DEFAULT_SEND_JITTER_MS = [50, 300];
+const DEFAULT_TYPING_JITTER_MS = [30, 150];
+const DEFAULT_RETRY_JITTER_MS = [100, 500];
+const DEFAULT_DURATION_JITTER_MS = 200;
+const DEFAULT_SAMPLE_RATE_POOL = [8000, 16000, 44100, 48000];
+const DEFAULT_IDLE_TIMEOUT_JITTER_MS = [25000, 35000];
+const DEFAULT_KEEPALIVE_JITTER_MS = [15000, 25000];
+const DEFAULT_BATTERY_LEVEL_POOL = [20, 35, 50, 65, 80, 95, 100];
+const DEFAULT_PROTOCOL_VERSION_POOL = ['2.24.5', '2.24.4', '2.24.3'];
+/**
+ * Generate a comprehensive session fingerprint.
+ * Call once per session (socket initialization).
+ *
+ * Obscura pattern: consistent per session, randomized across sessions.
+ */
+export function generateSessionFingerprint(config = {}, sessionId) {
+    const { enabled = true, deviceProfile = {}, networkTiming = {}, voiceNote = {}, connectionState = {}, protocolVersion = {}, seed, } = config;
+    const finalSessionId = sessionId || `session-${Date.now()}-${Math.random()}`;
+    const rng = new SeededRandom(seed || finalSessionId);
+    // Generate base device fingerprint (delegates to deviceFingerprint.ts)
+    const device = generateFingerprint({
+        enabled,
+        randomizeAppVersion: deviceProfile.randomizeAppVersion ?? true,
+        randomizeOsVersion: deviceProfile.randomizeOsVersion ?? true,
+        randomizeDeviceModel: deviceProfile.randomizeDeviceModel ?? true,
+        seed: seed || finalSessionId,
+        appVersionPool: deviceProfile.appVersionPool,
+        osVersionPool: deviceProfile.osVersionPool,
+        deviceModelPool: deviceProfile.deviceModelPool,
+    }, finalSessionId);
+    // Network timing variances (Obscura: prevent timing pattern detection)
+    const sendJitterRange = networkTiming.sendJitterMs || DEFAULT_SEND_JITTER_MS;
+    const typingJitterRange = networkTiming.typingJitterMs || DEFAULT_TYPING_JITTER_MS;
+    const retryJitterRange = networkTiming.retryJitterMs || DEFAULT_RETRY_JITTER_MS;
+    const networkTimingProfile = enabled
+        ? {
+            sendJitterMs: rng.range(sendJitterRange[0], sendJitterRange[1]),
+            typingJitterMs: rng.range(typingJitterRange[0], typingJitterRange[1]),
+            retryJitterMs: rng.range(retryJitterRange[0], retryJitterRange[1]),
+        }
+        : {
+            sendJitterMs: 0,
+            typingJitterMs: 0,
+            retryJitterMs: 0,
+        };
+    // Voice note profile (Obscura: audio fingerprint variance)
+    const sampleRatePool = voiceNote.sampleRatePool || DEFAULT_SAMPLE_RATE_POOL;
+    const voiceNoteProfile = {
+        waveformSeed: enabled ? rng.range(0, 2147483647) : 0,
+        durationJitterMs: enabled && voiceNote.randomizeWaveform !== false
+            ? rng.range(0, voiceNote.durationJitterMs || DEFAULT_DURATION_JITTER_MS)
+            : 0,
+        sampleRate: enabled ? rng.pick(sampleRatePool) : sampleRatePool[0],
+    };
+    // Connection state profile (Obscura: battery/network state variance)
+    const idleTimeoutRange = connectionState.idleTimeoutJitterMs || DEFAULT_IDLE_TIMEOUT_JITTER_MS;
+    const keepaliveRange = connectionState.keepaliveJitterMs || DEFAULT_KEEPALIVE_JITTER_MS;
+    const batteryLevelPool = connectionState.batteryLevelPool || DEFAULT_BATTERY_LEVEL_POOL;
+    const connectionStateProfile = {
+        idleTimeoutMs: enabled
+            ? rng.range(idleTimeoutRange[0], idleTimeoutRange[1])
+            : 30000,
+        keepaliveMs: enabled
+            ? rng.range(keepaliveRange[0], keepaliveRange[1])
+            : 20000,
+        batteryLevel: enabled && connectionState.randomizeBattery !== false
+            ? rng.pick(batteryLevelPool)
+            : 100,
+        batteryCharging: enabled ? rng.boolean(0.3) : false, // 30% charging probability
+    };
+    // Protocol version (Obscura: TLS fingerprint variance → WA protocol variance)
+    const versionPool = protocolVersion.versionPool || DEFAULT_PROTOCOL_VERSION_POOL;
+    const protocolVersionStr = enabled && protocolVersion.randomizeSubVersion !== false
+        ? rng.pick(versionPool)
+        : versionPool[0];
+    return {
+        device,
+        networkTiming: networkTimingProfile,
+        voiceNote: voiceNoteProfile,
+        connectionState: connectionStateProfile,
+        protocolVersion: protocolVersionStr,
+        sessionId: finalSessionId,
+        createdAt: Date.now(),
+    };
+}
+/**
+ * Apply session fingerprint to Baileys socket config.
+ *
+ * Usage:
+ *   const fingerprint = generateSessionFingerprint({ enabled: true });
+ *   const sock = makeWASocket(applySessionFingerprint(config, fingerprint));
+ */
+export function applySessionFingerprint(socketConfig, fingerprint) {
+    const config = { ...socketConfig };
+    // Apply device profile (appVersion, browser tuple)
+    config.version = fingerprint.device.appVersion;
+    config.browser = [
+        fingerprint.device.deviceModel,
+        fingerprint.device.osVersion,
+        `WhatsApp/${fingerprint.device.appVersion.join('.')}`,
+    ];
+    // Apply connection timeouts if fields exist
+    if ('connectTimeoutMs' in config || config.connectTimeoutMs !== undefined) {
+        // Add idle timeout jitter to connection config
+        config.connectTimeoutMs = fingerprint.connectionState.idleTimeoutMs;
+    }
+    // Apply keepalive if supported
+    if ('keepAliveIntervalMs' in config || config.keepAliveIntervalMs !== undefined) {
+        config.keepAliveIntervalMs = fingerprint.connectionState.keepaliveMs;
+    }
+    // Store fingerprint for runtime access (helpers can read this)
+    config.__sessionFingerprint = fingerprint;
+    return config;
+}
+/**
+ * Get timing jitter for message send (helper for presenceChoreographer/rateLimiter)
+ *
+ * Usage in beforeSend():
+ *   const jitter = getMessageSendJitter(fingerprint);
+ *   await sleep(baseDelay + jitter);
+ */
+export function getMessageSendJitter(fingerprint) {
+    // Return a random value within ±50% of the session's base jitter
+    // This adds per-message variance while staying within session profile
+    const base = fingerprint.networkTiming.sendJitterMs;
+    return Math.floor(base * 0.5 + Math.random() * base * 0.5);
+}
+/**
+ * Get typing indicator jitter (helper for presenceChoreographer)
+ */
+export function getTypingJitter(fingerprint) {
+    const base = fingerprint.networkTiming.typingJitterMs;
+    return Math.floor(base * 0.5 + Math.random() * base * 0.5);
+}
+/**
+ * Get retry backoff jitter (helper for reconnectThrottle)
+ */
+export function getRetryJitter(fingerprint) {
+    const base = fingerprint.networkTiming.retryJitterMs;
+    return Math.floor(base * 0.5 + Math.random() * base * 0.5);
+}
+/**
+ * Get voice note metadata (helper for voice message encoding)
+ *
+ * Returns suggested sample rate and duration adjustment based on session fingerprint.
+ */
+export function getVoiceNoteMetadata(fingerprint) {
+    return {
+        sampleRate: fingerprint.voiceNote.sampleRate,
+        durationJitterMs: fingerprint.voiceNote.durationJitterMs,
+        waveformSeed: fingerprint.voiceNote.waveformSeed,
+    };
+}
+/**
+ * Get battery state (helper for presence/connection state signals)
+ */
+export function getBatteryState(fingerprint) {
+    return {
+        level: fingerprint.connectionState.batteryLevel,
+        charging: fingerprint.connectionState.batteryCharging,
+    };
+}
+/**
+ * Create a session fingerprint preset (Obscura-inspired feature flag pattern)
+ */
+export function createStealthFingerprint(sessionId) {
+    return generateSessionFingerprint({
+        enabled: true,
+        deviceProfile: {
+            randomizeAppVersion: true,
+            randomizeOsVersion: true,
+            randomizeDeviceModel: true,
+        },
+        networkTiming: {
+            sendJitterMs: [100, 500],
+            typingJitterMs: [50, 200],
+            retryJitterMs: [200, 800],
+        },
+        voiceNote: {
+            randomizeWaveform: true,
+            durationJitterMs: 300,
+        },
+        connectionState: {
+            randomizeBattery: true,
+        },
+        protocolVersion: {
+            randomizeSubVersion: true,
+        },
+    }, sessionId);
+}

package/dist/stealthConnect.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Stealth Connect — Gradual presence ramp to reduce ban signals
+ *
+ * Inspired by GOWA's --presence-on-connect=unavailable flag. Bots that
+ * instantly snap online and start blasting messages look suspicious.
+ * This helper connects without advertising "online" presence, then
+ * gradually ramps to "available" after a randomized delay.
+ *
+ * Usage:
+ *   const config = getStealthSocketConfig({ os: 'My Custom App' });
+ *   const sock = makeWASocket({ ...config, ...otherOptions });
+ *   await rampPresenceAfterConnect(sock, { minDelayMs: 45000, maxDelayMs: 120000 });
+ */
+/**
+ * Returns socket configuration for stealth connect.
+ * Sets markOnlineOnConnect=false and provides sensible browser defaults.
+ *
+ * @param opts.os - Optional custom OS name for device fingerprint (default: 'Baileys')
+ * @returns Partial socket config to merge into makeWASocket options
+ */
+export declare function getStealthSocketConfig(opts?: {
+    os?: string;
+}): any;
+/**
+ * Ramps presence from unavailable to available after a randomized delay.
+ * Call this after socket connects. Returns a promise that resolves once
+ * presence is set. Can be awaited or fire-and-forget.
+ *
+ * @param sock - Baileys socket instance (must have sendPresenceUpdate method)
+ * @param opts.minDelayMs - Minimum delay in ms (default: 30000 = 30s)
+ * @param opts.maxDelayMs - Maximum delay in ms (default: 90000 = 90s)
+ * @param opts.targetState - Presence state to set after delay (default: 'available')
+ * @returns Promise that resolves when presence is updated
+ */
+export declare function rampPresenceAfterConnect(sock: any, opts?: {
+    minDelayMs?: number;
+    maxDelayMs?: number;
+    targetState?: 'available' | 'unavailable' | 'composing' | 'recording' | 'paused';
+}): Promise<void>;

package/dist/stealthConnect.js

@@ -0,0 +1,48 @@
+/**
+ * Stealth Connect — Gradual presence ramp to reduce ban signals
+ *
+ * Inspired by GOWA's --presence-on-connect=unavailable flag. Bots that
+ * instantly snap online and start blasting messages look suspicious.
+ * This helper connects without advertising "online" presence, then
+ * gradually ramps to "available" after a randomized delay.
+ *
+ * Usage:
+ *   const config = getStealthSocketConfig({ os: 'My Custom App' });
+ *   const sock = makeWASocket({ ...config, ...otherOptions });
+ *   await rampPresenceAfterConnect(sock, { minDelayMs: 45000, maxDelayMs: 120000 });
+ */
+/**
+ * Returns socket configuration for stealth connect.
+ * Sets markOnlineOnConnect=false and provides sensible browser defaults.
+ *
+ * @param opts.os - Optional custom OS name for device fingerprint (default: 'Baileys')
+ * @returns Partial socket config to merge into makeWASocket options
+ */
+export function getStealthSocketConfig(opts) {
+    return {
+        markOnlineOnConnect: false,
+        browser: ['Ubuntu', 'Chrome', '20.0.04'],
+        ...(opts?.os && { defaultQueryTimeoutMs: undefined }), // placeholder — actual os field lives in auth
+    };
+}
+/**
+ * Ramps presence from unavailable to available after a randomized delay.
+ * Call this after socket connects. Returns a promise that resolves once
+ * presence is set. Can be awaited or fire-and-forget.
+ *
+ * @param sock - Baileys socket instance (must have sendPresenceUpdate method)
+ * @param opts.minDelayMs - Minimum delay in ms (default: 30000 = 30s)
+ * @param opts.maxDelayMs - Maximum delay in ms (default: 90000 = 90s)
+ * @param opts.targetState - Presence state to set after delay (default: 'available')
+ * @returns Promise that resolves when presence is updated
+ */
+export async function rampPresenceAfterConnect(sock, opts) {
+    const minDelayMs = opts?.minDelayMs ?? 30000;
+    const maxDelayMs = opts?.maxDelayMs ?? 90000;
+    const targetState = opts?.targetState ?? 'available';
+    // Random delay in [minDelayMs, maxDelayMs]
+    const delayMs = Math.floor(Math.random() * (maxDelayMs - minDelayMs + 1)) + minDelayMs;
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    // Send presence update (undefined = broadcast to all conversations)
+    await sock.sendPresenceUpdate(targetState, undefined);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baileys-antiban",
-  "version": "3.6.1",
+  "version": "3.8.0",
   "description": "Anti-ban middleware for Baileys WhatsApp bots. Rate limiting, warmup, health monitor, LID resolver, disconnect classifier. Free Whapi.Cloud alternative.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",