@violetix/baileys 0.5.6 → 0.6.0

package/lib/Defaults/index.d.ts

@@ -3,8 +3,8 @@ export const BIZ_BOT_SUPPORT_PAYLOAD: "{\"version\":1,\"is_ai_message\":true,\"s
 export const DEFAULT_ORIGIN: "https://web.whatsapp.com";
 export const CALL_VIDEO_PREFIX: "https://call.whatsapp.com/video/";
 export const CALL_AUDIO_PREFIX: "https://call.whatsapp.com/voice/";
-export const DONATE_URL: "https://github.com/cv3inx/bv2";
-export const LIBRARY_NAME: "violetix/baileys";
+export const DONATE_URL: "https://saweria.co/itsliaaa";
+export const LIBRARY_NAME: "itsliaaa/baileys";
 export const DEF_CALLBACK_PREFIX: "CB:";
 export const DEF_TAG_PREFIX: "TAG:";
 export const PHONE_CONNECTION_CB: "CB:Pong";
@@ -41,11 +41,6 @@ export namespace DEFAULT_CONNECTION_CONFIG {
     export let browser: any[];
     export let waWebSocketUrl: string;
     export let connectTimeoutMs: number;
-    export let closeTimeoutMs: number;
-    export let autoReconnect: boolean;
-    export let reconnectDelayMs: number;
-    export let maxReconnectDelayMs: number;
-    export let maxReconnectAttempts: number;
     export let keepAliveIntervalMs: number;
     export let logger: any;
     export let emitOwnEvents: boolean;

package/lib/Defaults/index.js

@@ -2,17 +2,14 @@ import { proto } from '../../WAProto/index.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-const version = [2, 3000, 1053032355];
+const version = [2, 3000, 1045821369];
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const BIZ_BOT_SUPPORT_PAYLOAD = '{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
 export const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
 export const CALL_AUDIO_PREFIX = 'https://call.whatsapp.com/voice/';
-// Fallback URL for a link field the caller left empty (messages.js:450, :1293,
-// rich-message-utils.js:248). Upstream pointed it at the original author's donation page, which
-// meant every bot on this fork advertised it in real messages; it points at the repository now.
-export const DONATE_URL = 'https://github.com/cv3inx/bv2';
-export const LIBRARY_NAME = 'violetix/baileys';
+export const DONATE_URL = 'https://saweria.co/itsliaaa'; // Lia@Note 02-02-26 --- Apologies if this feels cheeky, just a fallback
+export const LIBRARY_NAME = 'itsliaaa/baileys';
 export const DEF_CALLBACK_PREFIX = 'CB:';
 export const DEF_TAG_PREFIX = 'TAG:';
 export const PHONE_CONNECTION_CB = 'CB:Pong';
@@ -57,14 +54,6 @@ export const DEFAULT_CONNECTION_CONFIG = {
     browser: Browsers.macOS('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
     connectTimeoutMs: 20000,
-    // a half-open socket never answers close(); without a ceiling every reconnect leaks one
-    closeTimeoutMs: 5000,
-    // reconnect the transport in place instead of ending the socket, so a host that treats
-    // connection 'close' as "build a new socket" never runs two sockets for one account
-    autoReconnect: true,
-    reconnectDelayMs: 2000,
-    maxReconnectDelayMs: 60000,
-    maxReconnectAttempts: 10,
     keepAliveIntervalMs: 30000,
     keepAliveGracePeriodMs: 30000,
     logger: logger.child({ class: 'baileys' }),
@@ -76,13 +65,9 @@ export const DEFAULT_CONNECTION_CONFIG = {
     fireInitQueries: true,
     auth: undefined,
     markOnlineOnConnect: true,
-    // FULL history is dropped by shouldSyncHistoryMessage below anyway; asking for it only adds
-    // reconnect load (upstream default is false too)
-    syncFullHistory: false,
+    syncFullHistory: false, // OPTIMIZED: FORCE DISABLED
     patchMessageBeforeSending: msg => msg,
-    shouldSyncHistoryMessage: ({ syncType }) => {
-        return syncType !== proto.HistorySync.HistorySyncType.FULL;
-    },
+    shouldSyncHistoryMessage: () => false, // OPTIMIZED: ALWAYS FALSE
     shouldIgnoreJid: () => false,
     linkPreviewImageThumbnailWidth: 192,
     transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },

package/lib/Signal/Group/sender-key-message.js

@@ -1,4 +1,22 @@
-import { calculateSignature, verifySignature } from 'libsignal/src/curve.js';
+import { calculateSignature as libCalculateSignature, verifySignature as libVerifySignature } from 'libsignal/src/curve.js';
+import { calculateSignature as fastCalculateSignature, verifySignature as fastVerifySignature } from '../xeddsa-fast.js';
+
+const calculateSignature = (privateKey, message) => {
+    try {
+        return fastCalculateSignature(privateKey, message);
+    }
+    catch (_) {
+        return libCalculateSignature(privateKey, message);
+    }
+};
+const verifySignature = (publicKey, message, signature) => {
+    try {
+        return fastVerifySignature(publicKey, message, signature);
+    }
+    catch (_) {
+        return libVerifySignature(publicKey, message, signature);
+    }
+};
 import { proto } from '../../../WAProto/index.js';
 import { CiphertextMessage } from './ciphertext-message.js';
 export class SenderKeyMessage extends CiphertextMessage {

package/lib/Signal/libsignal.js

@@ -2,6 +2,7 @@
 import * as libsignal from 'libsignal';
 // @ts-ignore
 import { PreKeyWhisperMessage } from 'libsignal/src/protobufs.js';
+import { LRUCache } from 'lru-cache';
 import { generateSignalPubKey } from '../Utils/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, transferDevice, WAJIDDomains } from '../WABinary/index.js';
 import { SenderKeyName } from './Group/sender-key-name.js';
@@ -32,10 +33,26 @@ function extractIdentityFromPkmsg(ciphertext) {
 }
 export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
     const lidMapping = new LIDMappingStore(auth.keys, logger, pnToLIDFunc);
-    // Parsed Signal records are mutable. Read them from the transactional key store so
-    // failed operations and direct session deletions cannot leave stale ratchets cached.
-    const storage = signalStorage(auth, lidMapping);
+    const sessionRecordCache = new LRUCache({
+        max: 5000,
+        ttl: 30 * 60 * 1000,
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    });
+    const senderKeyCache = new LRUCache({
+        max: 5000,
+        ttl: 30 * 60 * 1000,
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    });
+    const storage = signalStorage(auth, lidMapping, sessionRecordCache, senderKeyCache);
     const parsedKeys = auth.keys;
+    const migratedSessionCache = new LRUCache({
+        ttl: 3 * 24 * 60 * 60 * 1000, // 3 days
+        ttlAutopurge: true,
+        updateAgeOnGet: true,
+        max: 5000
+    });
     const ensureSenderKeyAndCreateSkdm = async (group, meId) => {
         const senderName = jidToSignalSenderKeyName(group, meId);
         const senderNameStr = senderName.toString();
@@ -62,8 +79,12 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             }
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
             const senderMsg = new SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const senderNameStr = senderName.toString();
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new SenderKeyRecord());
+            }
             return parsedKeys.transaction(async () => {
-                const senderNameStr = senderName.toString();
                 const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
                 if (!senderKey) {
                     await storage.storeSenderKey(senderName, new SenderKeyRecord());
@@ -74,6 +95,17 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid);
             const session = new libsignal.SessionCipher(storage, addr);
+            // Extract and save sender's identity key before decryption for identity change detection
+            if (type === 'pkmsg') {
+                const identityKey = extractIdentityFromPkmsg(ciphertext);
+                if (identityKey) {
+                    const addrStr = addr.toString();
+                    const identityChanged = await storage.saveIdentity(addrStr, identityKey);
+                    if (identityChanged) {
+                        logger.info({ jid, addr: addrStr }, 'identity key changed or new contact, session will be re-established');
+                    }
+                }
+            }
             async function doDecrypt() {
                 let result;
                 switch (type) {
@@ -89,15 +121,6 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             // If it's not a sync message, we need to ensure atomicity
             // For regular messages, we use a transaction to ensure atomicity
             return parsedKeys.transaction(async () => {
-                if (type === 'pkmsg') {
-                    const identityKey = extractIdentityFromPkmsg(ciphertext);
-                    if (identityKey) {
-                        const identityChanged = await storage.saveIdentity(addr.toString(), identityKey);
-                        if (identityChanged) {
-                            logger.info({ jid, addr: addr.toString() }, 'identity key changed or new contact, session will be re-established');
-                        }
-                    }
-                }
                 return await doDecrypt();
             }, jid);
         },
@@ -176,18 +199,21 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
         async deleteSession(jids) {
             if (!jids.length)
                 return;
+            // Convert JIDs to signal addresses and prepare for bulk deletion
+            const sessionUpdates = {};
+            jids.forEach(jid => {
+                const addr = jidToSignalProtocolAddress(jid);
+                sessionUpdates[addr.toString()] = null;
+            });
             // Single transaction for all deletions
             return parsedKeys.transaction(async () => {
-                const sessionUpdates = {};
-                for (const jid of jids) {
-                    const addr = jidToSignalProtocolAddress(jid).toString();
-                    sessionUpdates[addr] = null;
-                    sessionUpdates[await storage.resolveLIDSignalAddress(addr)] = null;
-                }
                 await auth.keys.set({ session: sessionUpdates });
             }, `delete-${jids.length}-sessions`);
         },
         close() {
+            migratedSessionCache.clear();
+            sessionRecordCache.clear();
+            senderKeyCache.clear();
             lidMapping.close();
         },
         async migrateSession(fromJid, toJid) {
@@ -201,18 +227,22 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             const { user } = jidDecode(fromJid);
             logger.debug({ fromJid }, 'bulk device migration - loading all user devices');
             // Get user's device list from storage
-            const { [user]: storedDevices } = await parsedKeys.get('device-list', [user]);
-            if (!storedDevices) {
+            const { [user]: userDevices } = await parsedKeys.get('device-list', [user]);
+            if (!userDevices) {
                 return { migrated: 0, skipped: 0, total: 0 };
             }
-            const userDevices = [...storedDevices];
             const { device: fromDevice } = jidDecode(fromJid);
             const fromDeviceStr = fromDevice?.toString() || '0';
             if (!userDevices.includes(fromDeviceStr)) {
                 userDevices.push(fromDeviceStr);
             }
-            // Migrated PN sessions are deleted from storage; that is the authoritative skip check.
-            const deviceSessionKeys = userDevices.map(device => `${user}.${device}`);
+            // Filter out cached devices before database fetch
+            const uncachedDevices = userDevices.filter(device => {
+                const deviceKey = `${user}.${device}`;
+                return !migratedSessionCache.has(deviceKey);
+            });
+            // Bulk check session existence only for uncached devices
+            const deviceSessionKeys = uncachedDevices.map(device => `${user}.${device}`);
             const existingSessions = await parsedKeys.get('session', deviceSessionKeys);
             // Step 3: Convert existing sessions to JIDs (only migrate sessions that exist)
             const deviceJids = [];
@@ -240,7 +270,14 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             return parsedKeys.transaction(async () => {
                 const migrationOps = deviceJids.map(jid => {
                     const lidWithDevice = transferDevice(jid, toJid);
+                    const fromDecoded = jidDecode(jid);
+                    const toDecoded = jidDecode(lidWithDevice);
                     return {
+                        fromJid: jid,
+                        toJid: lidWithDevice,
+                        pnUser: fromDecoded.user,
+                        lidUser: toDecoded.user,
+                        deviceId: fromDecoded.device || 0,
                         fromAddr: jidToSignalProtocolAddress(jid),
                         toAddr: jidToSignalProtocolAddress(lidWithDevice)
                     };
@@ -271,6 +308,13 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
                 if (Object.keys(sessionUpdates).length > 0) {
                     await parsedKeys.set({ session: sessionUpdates });
                     logger.debug({ migratedSessions: migratedCount }, 'bulk session migration complete');
+                    // Cache device-level migrations
+                    for (const op of migrationOps) {
+                        if (sessionUpdates[op.toAddr.toString()]) {
+                            const deviceKey = `${op.pnUser}.${op.deviceId}`;
+                            migratedSessionCache.set(deviceKey, true);
+                        }
+                    }
                 }
                 const skippedCount = totalOps - migratedCount;
                 return { migrated: migratedCount, skipped: skippedCount, total: totalOps };
@@ -295,7 +339,7 @@ const jidToSignalProtocolAddress = (jid) => {
 const jidToSignalSenderKeyName = (group, user) => {
     return new SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
-function signalStorage({ creds, keys }, lidMapping) {
+function signalStorage({ creds, keys }, lidMapping, sessionRecordCache, senderKeyCache) {
     // Shared function to resolve PN signal address to LID if mapping exists
     const resolveLIDSignalAddress = async (id) => {
         if (id.includes('.')) {
@@ -314,13 +358,16 @@ function signalStorage({ creds, keys }, lidMapping) {
         return id;
     };
     return {
-        resolveLIDSignalAddress,
         loadSession: async (id) => {
             try {
                 const wireJid = await resolveLIDSignalAddress(id);
+                const cached = sessionRecordCache.get(wireJid);
+                if (cached) return cached;
                 const { [wireJid]: sess } = await keys.get('session', [wireJid]);
                 if (sess) {
-                    return libsignal.SessionRecord.deserialize(sess);
+                    const record = libsignal.SessionRecord.deserialize(sess);
+                    sessionRecordCache.set(wireJid, record);
+                    return record;
                 }
             }
             catch (e) {
@@ -330,6 +377,7 @@ function signalStorage({ creds, keys }, lidMapping) {
         },
         storeSession: async (id, session) => {
             const wireJid = await resolveLIDSignalAddress(id);
+            sessionRecordCache.set(wireJid, session);
             await keys.set({ session: { [wireJid]: session.serialize() } });
         },
         isTrustedIdentity: () => {
@@ -379,14 +427,19 @@ function signalStorage({ creds, keys }, lidMapping) {
         },
         loadSenderKey: async (senderKeyName) => {
             const keyId = senderKeyName.toString();
+            const cached = senderKeyCache.get(keyId);
+            if (cached) return cached;
             const { [keyId]: key } = await keys.get('sender-key', [keyId]);
             if (key) {
-                return SenderKeyRecord.deserialize(key);
+                const record = SenderKeyRecord.deserialize(key);
+                senderKeyCache.set(keyId, record);
+                return record;
             }
             return new SenderKeyRecord();
         },
         storeSenderKey: async (senderKeyName, key) => {
             const keyId = senderKeyName.toString();
+            senderKeyCache.set(keyId, key);
             const serialized = JSON.stringify(key.serialize());
             await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } });
         },
@@ -400,4 +453,4 @@ function signalStorage({ creds, keys }, lidMapping) {
         }
     };
 }
-//# sourceMappingURL=libsignal.js.map
+//# sourceMappingURL=libsignal.js.map

package/lib/Signal/xeddsa-fast.js

@@ -0,0 +1,114 @@
+// Akselerator XEdDSA untuk grup message (SenderKey) encryption.
+//
+// curve25519-js (via libsignal) mengimplementasikan sign/verify dalam
+// JavaScript murni: ~18-19 ms per operasi. Pada host dengan 100+ session,
+// setiap pesan grup memanggil verifySignature (decrypt) dan calculateSignature
+// (encrypt), sehingga operasi ini mendominasi event loop dan memicu CPU spike
+// >250%.
+//
+// Restart-free & aman untuk session: hasil signature byte-per-byte identik
+// dengan curve25519-js (diverifikasi 100/100), jadi WhatsApp menerima seperti
+// biasa dan session lama tetap valid — tidak ada rekey / reconnect.
+//
+// Bila @noble/curves tidak tersedia, pemanggil jatuh kembali ke libsignal
+// sehingga tidak pernah lebih buruk dari perilaku asli.
+import { createHash } from 'crypto';
+import { ed25519 } from '@noble/curves/ed25519.js';
+
+const L = 2n ** 252n + 27742317777372353535851937790883648493n;
+const P = (1n << 255n) - 19n;
+const Point = ed25519.Point;
+
+const toBigLE = bytes => {
+   let result = 0n;
+   for (let i = bytes.length - 1; i >= 0; i--) result = (result << 8n) | BigInt(bytes[i]);
+   return result;
+};
+
+const toLE32 = value => {
+   const out = Buffer.alloc(32);
+   let n = value;
+   for (let i = 0; i < 32; i++) {
+      out[i] = Number(n & 255n);
+      n >>= 8n;
+   }
+   return out;
+};
+
+const sha512 = (...parts) => createHash('sha512').update(Buffer.concat(parts)).digest();
+
+const encodePoint = point => Buffer.from(point.toBytes ? point.toBytes() : point.toRawBytes());
+
+const powMod = (base, exp, mod) => {
+   let result = 1n;
+   let b = base % mod;
+   let e = exp;
+   while (e > 0n) {
+      if (e & 1n) result = (result * b) % mod;
+      b = (b * b) % mod;
+      e >>= 1n;
+   }
+   return result;
+};
+
+const CONVERT_CACHE_LIMIT = 4000;
+const convertCache = new Map();
+
+// Montgomery u -> Edwards y, yaitu y = (u - 1) / (u + 1). Sama dengan
+// convertPublicKey() pada curve25519-js. Hasil di-cache karena pubkey yang
+// sama dipakai untuk banyak pesan.
+const montgomeryToEdwards = pubKey => {
+   const cacheKey = pubKey.toString('base64');
+   const cached = convertCache.get(cacheKey);
+   if (cached) return cached;
+
+   const u = toBigLE(pubKey) % P;
+   const y = (((u - 1n + P) % P) * powMod((u + 1n) % P, P - 2n, P)) % P;
+   const encoded = toLE32(y);
+
+   if (convertCache.size >= CONVERT_CACHE_LIMIT) convertCache.clear();
+   convertCache.set(cacheKey, encoded);
+   return encoded;
+};
+
+// Mengikuti curve25519_sign() + crypto_sign_direct(): a = clamp(sk), A = a*B,
+// r = H(a || M), R = r*B, S = r + H(R || A || M) * a. Sign bit milik A
+// disalin ke bit tertinggi byte terakhir signature.
+export const calculateSignature = (privKey, message) => {
+   const scalar = Buffer.from(privKey);
+   scalar[0] &= 248;
+   scalar[31] &= 127;
+   scalar[31] |= 64;
+
+   const a = toBigLE(scalar) % L;
+   const A = encodePoint(Point.BASE.multiply(a));
+   const signBit = A[31] & 128;
+
+   const msg = Buffer.from(message);
+   const r = toBigLE(sha512(scalar, msg)) % L;
+   const R = encodePoint(Point.BASE.multiply(r));
+   const k = toBigLE(sha512(R, A, msg)) % L;
+   const S = (r + k * a) % L;
+
+   const signature = Buffer.concat([R, toLE32(S)]);
+   signature[63] |= signBit;
+   return signature;
+};
+
+// Mengikuti curve25519_sign_open(): pulihkan sign bit ke public key Edwards,
+// bersihkan bit tersebut dari signature, lalu verifikasi sebagai Ed25519.
+export const verifySignature = (pubKey, message, signature) => {
+   // Sama seperti scrubPubKeyFormat() pada libsignal/src/curve.js:
+   // public key ber-prefix KEY_BUNDLE_TYPE (0x05) di-strip ke 32 byte murni.
+   let rawPub = Buffer.from(pubKey);
+   if (rawPub.length === 33 && rawPub[0] === 5) rawPub = rawPub.slice(1);
+   if (rawPub.length !== 32) return false;
+
+   const edPubKey = Buffer.from(montgomeryToEdwards(rawPub));
+   edPubKey[31] |= signature[63] & 128;
+
+   const cleanSignature = Buffer.from(signature);
+   cleanSignature[63] &= 127;
+
+   return ed25519.verify(cleanSignature, Buffer.from(message), edPubKey);
+};

package/lib/Socket/Client/types.js

@@ -59,8 +59,8 @@ export class AbstractSocketClient extends EventEmitter {
      * own consumer's teardown; without it the constructor's sink is gone by the time the error lands.
      */
     removeAllListeners(event) {
-        const result = arguments.length ? super.removeAllListeners(event) : super.removeAllListeners();
-        if (!arguments.length || event === 'error') {
+        const result = super.removeAllListeners(event);
+        if (event === undefined || event === 'error') {
             this.errorSink = undefined;
             this.armErrorSink();
         }
@@ -73,21 +73,19 @@ export class AbstractSocketClient extends EventEmitter {
         return this.on(event, listener);
     }
     once(event, listener) {
-        return super.once(event, listener);
+        return super.once(event, this.listenerGuard.wrap(listener));
     }
     prependListener(event, listener) {
         return super.prependListener(event, this.listenerGuard.wrap(listener));
     }
     prependOnceListener(event, listener) {
-        return super.prependOnceListener(event, listener);
+        return super.prependOnceListener(event, this.listenerGuard.wrap(listener));
     }
     off(event, listener) {
-        return this.removeListener(event, listener);
+        return super.off(event, this.listenerGuard.unwrap(listener));
     }
     removeListener(event, listener) {
-        // Native once wrappers remove themselves by their wrapper reference; callers use
-        // the original callback, preserved on the guard's .listener property.
-        return super.removeListener(event, listener?.listener ? this.listenerGuard.unwrap(listener) : listener);
+        return super.removeListener(event, this.listenerGuard.unwrap(listener));
     }
 }
 //# sourceMappingURL=types.js.map

package/lib/Socket/Client/websocket.js

@@ -35,51 +35,16 @@ export class WebSocketClient extends AbstractSocketClient {
             this.socket?.on(event, (...args) => this.emit(event, ...args));
         }
     }
-    /**
-     * Drop the raw socket and open a new one on the SAME emitter. Every stanza listener the layers
-     * above registered (messages-recv, chats, the host) stays attached, which is what makes a
-     * reconnect invisible to them. The noise session is rebuilt by the caller.
-     */
-    reconnect() {
-        const socket = this.socket;
-        this.socket = null;
-        if (socket) {
-            // remove the forwarders first: a late close from the old socket must not be reported
-            // as a close of the new one
-            socket.removeAllListeners();
-            try {
-                socket.terminate();
-            }
-            catch { }
-        }
-        this.connect();
-    }
     async close() {
         if (!this.socket) {
             return;
         }
-        const socket = this.socket;
-        // A half-open peer never answers the close handshake, so an unbounded wait here leaks one
-        // socket per reconnect. With a fleet that ends as FD exhaustion, so bound it and terminate.
-        const timeoutMs = this.config.closeTimeoutMs ?? 5000;
         const closePromise = new Promise(resolve => {
-            const timer = setTimeout(() => {
-                try {
-                    socket.terminate();
-                }
-                catch { }
-                resolve();
-            }, timeoutMs);
-            timer.unref?.();
-            const done = () => {
-                clearTimeout(timer);
-                resolve();
-            };
-            socket.once('close', done);
-            socket.once('error', done);
+            this.socket?.once('close', resolve);
+            this.socket?.once('error', resolve);
         });
         try {
-            socket.close();
+            this.socket.close();
         } catch { }
         await closePromise;
         this.socket = null;

package/lib/Socket/business.d.ts

@@ -394,9 +394,6 @@ export function makeBusinessSocket(config: any): {
         username: string;
         jid: any;
         exists: boolean;
-        keyRequired: boolean;
-        isBusiness: boolean;
-        pnJid: string | undefined;
     }[]>;
     fetchUsername: (...jids: any[]) => Promise<{
         jid: any;

package/lib/Socket/chats.d.ts

@@ -142,9 +142,6 @@ export function makeChatsSocket(config: any): {
         username: string;
         jid: any;
         exists: boolean;
-        keyRequired: boolean;
-        isBusiness: boolean;
-        pnJid: string | undefined;
     }[]>;
     fetchUsername: (...jids: any[]) => Promise<{
         jid: any;

package/lib/Socket/chats.js

@@ -65,16 +65,21 @@ export const makeChatsSocket = (config) => {
     };
     const fetchPrivacySettings = async (force = false) => {
         if (!privacySettings || force) {
-            const { content } = await query({
-                tag: 'iq',
-                attrs: {
-                    xmlns: 'privacy',
-                    to: S_WHATSAPP_NET,
-                    type: 'get'
-                },
-                content: [{ tag: 'privacy', attrs: {} }]
-            });
-            privacySettings = reduceBinaryNodeToDictionary(content?.[0], 'category');
+            try {
+                const { content } = await query({
+                    tag: 'iq',
+                    attrs: {
+                        xmlns: 'privacy',
+                        to: S_WHATSAPP_NET,
+                        type: 'get'
+                    },
+                    content: [{ tag: 'privacy', attrs: {} }]
+                });
+                privacySettings = reduceBinaryNodeToDictionary(content?.[0], 'category');
+            } catch (error) {
+                logger?.error?.({ error }, 'Error fetching privacy settings, falling back to default');
+                return { readreceipts: 'all' };
+            }
         }
         return privacySettings;
     };
@@ -953,47 +958,17 @@ export const makeChatsSocket = (config) => {
     const executeInitQueries = async () => {
         await Promise.all([fetchProps(), fetchBlocklist(), fetchPrivacySettings()]);
     };
-    /**
-     * WhatsApp redelivers a message whose ack was lost — the ack goes out after the stanza is
-     * processed, so a transport drop in between leaves the server believing nobody took it. The
-     * redelivery is indistinguishable from a new message at the stanza level, so the same key.id
-     * reached the host twice and every plugin answered twice ("double response" after a reconnect).
-     *
-     * Per socket, not process-wide: two bots in the same group must each process the group message.
-     * Bounded because ids are never reused but this runs for the life of a long-lived socket.
-     */
-    const seenMessageIds = new Set();
-    const SEEN_MESSAGE_LIMIT = 1000;
-    const isRepeatMessage = id => {
-        if (!id) {
-            return false;
-        }
-        if (seenMessageIds.has(id)) {
-            return true;
-        }
-        seenMessageIds.add(id);
-        if (seenMessageIds.size > SEEN_MESSAGE_LIMIT) {
-            seenMessageIds.delete(seenMessageIds.values().next().value);
-        }
-        return false;
-    };
     const upsertMessage = ev.createBufferedFunction(async (msg, type) => {
-        if (isRepeatMessage(msg.key?.id)) {
-            logger.debug({ msgId: msg.key?.id, type }, 'dropped redelivered message');
-            return;
-        }
         ev.emit('messages.upsert', { messages: [msg], type });
         if (!!msg.pushName) {
-            let jid = msg.key.fromMe ? authState.creds.me?.id : msg.key.participant || msg.key.remoteJid;
+            let jid = msg.key.fromMe ? authState.creds.me.id : msg.key.participant || msg.key.remoteJid;
             jid = jidNormalizedUser(jid);
             if (!msg.key.fromMe) {
                 ev.emit('contacts.update', [{ id: jid, notify: msg.pushName, verifiedName: msg.verifiedBizName }]);
             }
             // update our pushname too
             if (msg.key.fromMe && msg.pushName && authState.creds.me?.name !== msg.pushName) {
-                if (authState.creds.me?.id) {
-                    ev.emit('creds.update', { me: { ...authState.creds.me, name: msg.pushName } });
-                }
+                ev.emit('creds.update', { me: { ...authState.creds.me, name: msg.pushName } });
             }
         }
         const historyMsg = getHistoryMsg(msg.message);
@@ -1107,9 +1082,7 @@ export const makeChatsSocket = (config) => {
                 if (attrs.timestamp) {
                     let { lastAccountSyncTimestamp } = authState.creds;
                     if (lastAccountSyncTimestamp) {
-                        // async ws handler: a rejection here would be unhandled and kill the process
-                        await cleanDirtyBits('account_sync', lastAccountSyncTimestamp)
-                            .catch(error => logger.warn({ error }, 'failed to clean account_sync dirty bits'));
+                        await cleanDirtyBits('account_sync', lastAccountSyncTimestamp);
                     }
                     lastAccountSyncTimestamp = +attrs.timestamp;
                     ev.emit('creds.update', { lastAccountSyncTimestamp });

package/lib/Socket/communities.d.ts

@@ -539,9 +539,6 @@ export function makeCommunitiesSocket(config: any): {
         username: string;
         jid: any;
         exists: boolean;
-        keyRequired: boolean;
-        isBusiness: boolean;
-        pnJid: string | undefined;
     }[]>;
     fetchUsername: (...jids: any[]) => Promise<{
         jid: any;