@nexustechpro/baileys 1.0.2 → 1.0.3

package/lib/Socket/socket.js

@@ -4,96 +4,79 @@ import { URL } from "url"
 import { promisify } from "util"
 import { proto } from "../../WAProto/index.js"
 import {
-  DEF_CALLBACK_PREFIX,
-  DEF_TAG_PREFIX,
-  INITIAL_PREKEY_COUNT,
-  MIN_PREKEY_COUNT,
-  MIN_UPLOAD_INTERVAL,
-  NOISE_WA_HEADER,
-  UPLOAD_TIMEOUT,
+  DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, INITIAL_PREKEY_COUNT, MIN_PREKEY_COUNT,
+  MIN_UPLOAD_INTERVAL, NOISE_WA_HEADER, UPLOAD_TIMEOUT
 } from "../Defaults/index.js"
 import { DisconnectReason } from "../Types/index.js"
 import {
-  addTransactionCapability,
-  aesEncryptCTR,
-  bindWaitForConnectionUpdate,
-  bytesToCrockford,
-  configureSuccessfulPairing,
-  Curve,
-  derivePairingCodeKey,
-  generateLoginNode,
-  generateMdTagPrefix,
-  generateRegistrationNode,
-  getCodeFromWSError,
-  getErrorCodeFromStreamError,
-  getNextPreKeysNode,
-  makeEventBuffer,
-  makeNoiseHandler,
-  promiseTimeout,
+  addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, bytesToCrockford,
+  configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix,
+  generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode,
+  makeEventBuffer, makeNoiseHandler, promiseTimeout
 } from "../Utils/index.js"
 import { getPlatformId } from "../Utils/browser-utils.js"
 import {
-  assertNodeErrorFree,
-  binaryNodeToString,
-  encodeBinaryNode,
-  getBinaryNodeChild,
-  getBinaryNodeChildren,
-  isLidUser,
-  jidDecode,
-  jidEncode,
-  S_WHATSAPP_NET,
+  assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getBinaryNodeChild,
+  getBinaryNodeChildren, isLidUser, jidDecode, jidEncode, S_WHATSAPP_NET
 } from "../WABinary/index.js"
 import { BinaryInfo } from "../WAM/BinaryInfo.js"
 import { USyncQuery, USyncUser } from "../WAUSync/index.js"
 import { WebSocketClient } from "./Client/index.js"
-/**
- * Connects to WA servers and performs:
- * - simple queries (no retry mechanism, wait for connection establishment)
- * - listen to messages and emit events
- * - query phone connection
- */
+
 export const makeSocket = (config) => {
   const {
-    waWebSocketUrl,
-    connectTimeoutMs,
-    logger,
-    keepAliveIntervalMs,
-    browser,
-    auth: authState,
-    printQRInTerminal,
-    defaultQueryTimeoutMs,
-    transactionOpts,
-    qrTimeout,
-    makeSignalRepository,
+    waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser,
+    auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts,
+    qrTimeout, makeSignalRepository
   } = config
+
   const publicWAMBuffer = new BinaryInfo()
   const uqTagId = generateMdTagPrefix()
+  let epoch = 1
   const generateMessageTag = () => `${uqTagId}${epoch++}`
+
   if (printQRInTerminal) {
-    console.warn(
-      "⚠️ The printQRInTerminal option has been deprecated. You will no longer receive QR codes in the terminal automatically. Please listen to the connection.update event yourself and handle the QR your way. You can remove this message by removing this opttion. This message will be removed in a future version.",
-    )
+    logger?.warn("printQRInTerminal deprecated - handle QR via connection.update event")
   }
+
   const url = typeof waWebSocketUrl === "string" ? new URL(waWebSocketUrl) : waWebSocketUrl
   if (config.mobile || url.protocol === "tcp:") {
-    throw new Boom("Mobile API is not supported anymore", { statusCode: DisconnectReason.loggedOut })
+    throw new Boom("Mobile API not supported", { statusCode: DisconnectReason.loggedOut })
   }
   if (url.protocol === "wss" && authState?.creds?.routingInfo) {
     url.searchParams.append("ED", authState.creds.routingInfo.toString("base64url"))
   }
-  /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
+
   const ephemeralKeyPair = Curve.generateKeyPair()
-  /** WA noise protocol wrapper */
   const noise = makeNoiseHandler({
     keyPair: ephemeralKeyPair,
     NOISE_HEADER: NOISE_WA_HEADER,
     logger,
-    routingInfo: authState?.creds?.routingInfo,
+    routingInfo: authState?.creds?.routingInfo
   })
+
   const ws = new WebSocketClient(url, config)
   ws.connect()
+
+  const ev = makeEventBuffer(logger)
+  const { creds } = authState
+  const keys = addTransactionCapability(authState.keys, logger, transactionOpts)
+  const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync)
+
+  let lastDateRecv, keepAliveReq, qrTimer, sessionHealthCheck, preKeyMonitorInterval
+  let closed = false, isUploadingPreKeys = false
+  let lastPreKeyCheck = 0, lastUploadTime = 0, uploadPreKeysPromise = null
+  let lastMessageTime = Date.now()
+  let preKeyCheckQueue = []
+  let reconnectAttempts = 0
+  const MAX_RECONNECT_ATTEMPTS = 5
+
+  const PREKEY_CHECK_INTERVAL = 30 * 60 * 1000 // 30 mins
+  const PREKEY_MIN_INTERVAL = 5 * 60 * 1000 // 5 mins
+  const PREKEY_CRITICAL_THRESHOLD = 3
+
   const sendPromise = promisify(ws.send)
-  /** send a raw buffer */
+
   const sendRawMessage = async (data) => {
     if (!ws.isOpen) {
       throw new Boom("Connection Closed", { statusCode: DisconnectReason.connectionClosed })
@@ -108,7 +91,7 @@ export const makeSocket = (config) => {
       }
     })
   }
-  /** send a binary node */
+
   const sendNode = (frame) => {
     if (logger.level === "trace") {
       logger.trace({ xml: binaryNodeToString(frame), msg: "xml send" })
@@ -116,27 +99,15 @@ export const makeSocket = (config) => {
     const buff = encodeBinaryNode(frame)
     return sendRawMessage(buff)
   }
-  /**
-   * Wait for a message with a certain tag to be received
-   * @param msgId the message tag to await
-   * @param timeoutMs timeout after which the promise will reject
-   */
+
   const waitForMessage = async (msgId, timeoutMs = defaultQueryTimeoutMs) => {
-    let onRecv
-    let onErr
+    let onRecv, onErr
     try {
       const result = await promiseTimeout(timeoutMs, (resolve, reject) => {
-        onRecv = (data) => {
-          resolve(data)
-        }
-        onErr = (err) => {
-          reject(
-            err ||
-              new Boom("Connection Closed", {
-                statusCode: DisconnectReason.connectionClosed,
-              }),
-          )
-        }
+        onRecv = (data) => resolve(data)
+        onErr = (err) => reject(err || new Boom("Connection Closed", {
+          statusCode: DisconnectReason.connectionClosed
+        }))
         ws.on(`TAG:${msgId}`, onRecv)
         ws.on("close", onErr)
         ws.on("error", onErr)
@@ -144,7 +115,6 @@ export const makeSocket = (config) => {
       })
       return result
     } catch (error) {
-      // Catch timeout and return undefined instead of throwing
       if (error instanceof Boom && error.output?.statusCode === DisconnectReason.timedOut) {
         logger?.warn?.({ msgId }, "timed out waiting for message")
         return undefined
@@ -158,79 +128,55 @@ export const makeSocket = (config) => {
       }
     }
   }
-  /** send a query, and wait for its response. auto-generates message ID if not provided */
+
   const query = async (node, timeoutMs) => {
-    if (!node.attrs.id) {
-      node.attrs.id = generateMessageTag()
-    }
+    if (!node.attrs.id) node.attrs.id = generateMessageTag()
     const msgId = node.attrs.id
     const result = await promiseTimeout(timeoutMs, async (resolve, reject) => {
       const result = waitForMessage(msgId, timeoutMs).catch(reject)
-      sendNode(node)
-        .then(async () => resolve(await result))
-        .catch(reject)
+      sendNode(node).then(async () => resolve(await result)).catch(reject)
     })
     if (result && "tag" in result) {
       assertNodeErrorFree(result)
     }
     return result
   }
+
   const executeUSyncQuery = async (usyncQuery) => {
     if (usyncQuery.protocols.length === 0) {
       throw new Boom("USyncQuery must have at least one protocol")
     }
-    // todo: validate users, throw WARNING on no valid users
-    // variable below has only validated users
     const validUsers = usyncQuery.users
-    const userNodes = validUsers.map((user) => {
-      return {
-        tag: "user",
-        attrs: {
-          jid: !user.phone ? user.id : undefined,
-        },
-        content: usyncQuery.protocols.map((a) => a.getUserElement(user)).filter((a) => a !== null),
-      }
-    })
-    const listNode = {
-      tag: "list",
-      attrs: {},
-      content: userNodes,
-    }
-    const queryNode = {
-      tag: "query",
-      attrs: {},
-      content: usyncQuery.protocols.map((a) => a.getQueryElement()),
-    }
+    const userNodes = validUsers.map((user) => ({
+      tag: "user",
+      attrs: { jid: !user.phone ? user.id : undefined },
+      content: usyncQuery.protocols.map((a) => a.getUserElement(user)).filter((a) => a !== null)
+    }))
     const iq = {
       tag: "iq",
-      attrs: {
-        to: S_WHATSAPP_NET,
-        type: "get",
-        xmlns: "usync",
-      },
-      content: [
-        {
-          tag: "usync",
-          attrs: {
-            context: usyncQuery.context,
-            mode: usyncQuery.mode,
-            sid: generateMessageTag(),
-            last: "true",
-            index: "0",
-          },
-          content: [queryNode, listNode],
+      attrs: { to: S_WHATSAPP_NET, type: "get", xmlns: "usync" },
+      content: [{
+        tag: "usync",
+        attrs: {
+          context: usyncQuery.context, mode: usyncQuery.mode,
+          sid: generateMessageTag(), last: "true", index: "0"
         },
-      ],
+        content: [
+          { tag: "query", attrs: {}, content: usyncQuery.protocols.map((a) => a.getQueryElement()) },
+          { tag: "list", attrs: {}, content: userNodes }
+        ]
+      }]
     }
     const result = await query(iq)
     return usyncQuery.parseUSyncQueryResult(result)
   }
+
   const onWhatsApp = async (...phoneNumber) => {
     let usyncQuery = new USyncQuery()
     let contactEnabled = false
     for (const jid of phoneNumber) {
       if (isLidUser(jid)) {
-        logger?.warn("LIDs are not supported with onWhatsApp")
+        logger?.warn("LIDs not supported with onWhatsApp")
         continue
       } else {
         if (!contactEnabled) {
@@ -241,15 +187,16 @@ export const makeSocket = (config) => {
         usyncQuery.withUser(new USyncUser().withPhone(phone))
       }
     }
-    if (usyncQuery.users.length === 0) {
-      return [] // return early without forcing an empty query
-    }
+    if (usyncQuery.users.length === 0) return []
     const results = await executeUSyncQuery(usyncQuery)
     if (results) {
-      return results.list.filter((a) => !!a.contact).map(({ contact, id }) => ({ jid: id, exists: contact }))
+      return results.list.filter((a) => !!a.contact).map(({ contact, id }) => ({
+        jid: id, exists: contact
+      }))
     }
   }
-  const pnFromLIDUSync = async (jids) => {
+
+  async function pnFromLIDUSync(jids) {
     const usyncQuery = new USyncQuery().withLIDProtocol().withContext("background")
     for (const jid of jids) {
       if (isLidUser(jid)) {
@@ -259,43 +206,32 @@ export const makeSocket = (config) => {
         usyncQuery.withUser(new USyncUser().withId(jid))
       }
     }
-    if (usyncQuery.users.length === 0) {
-      return [] // return early without forcing an empty query
-    }
+    if (usyncQuery.users.length === 0) return []
     const results = await executeUSyncQuery(usyncQuery)
     if (results) {
       return results.list.filter((a) => !!a.lid).map(({ lid, id }) => ({ pn: id, lid: lid }))
     }
     return []
   }
-  const ev = makeEventBuffer(logger)
-  const { creds } = authState
-  // add transaction capability
-  const keys = addTransactionCapability(authState.keys, logger, transactionOpts)
-  const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync)
-  let lastDateRecv
-  let epoch = 1
-  let preKeyMonitorInterval = null
-  let lastPreKeyCheck = 0
-  let isUploadingPreKeys = false
-  const PREKEY_CHECK_INTERVAL = 2 * 60 * 60 * 1000 // Check every 2 hours
-  const PREKEY_MIN_INTERVAL = 30 * 60 * 1000 // Minimum 30 mins between uploads
-  let keepAliveReq
-  let qrTimer
-  let closed = false
-  /** log & process any unexpected errors */
+
   const onUnexpectedError = (err, msg) => {
     logger.error({ err }, `unexpected error in '${msg}'`)
+    const message = (err && ((err.stack || err.message) || String(err))).toLowerCase()
+    
+    // Trigger critical pre-key check on crypto errors
+    if (message.includes('bad mac') || (message.includes('mac') && message.includes('invalid'))) {
+      triggerPreKeyCheck("bad-mac", "critical")
+    }
+    if (message.includes('session') && message.includes('corrupt')) {
+      triggerPreKeyCheck("session-corruption", "critical")
+    }
   }
-  /** await the next incoming message */
+
   const awaitNextMessage = async (sendMsg) => {
     if (!ws.isOpen) {
-      throw new Boom("Connection Closed", {
-        statusCode: DisconnectReason.connectionClosed,
-      })
+      throw new Boom("Connection Closed", { statusCode: DisconnectReason.connectionClosed })
     }
-    let onOpen
-    let onClose
+    let onOpen, onClose
     const result = promiseTimeout(connectTimeoutMs, (resolve, reject) => {
       onOpen = resolve
       onClose = mapWebSocketError(reject)
@@ -312,11 +248,9 @@ export const makeSocket = (config) => {
     }
     return result
   }
-  /** connection handshake */
+
   const validateConnection = async () => {
-    let helloMsg = {
-      clientHello: { ephemeral: ephemeralKeyPair.public },
-    }
+    let helloMsg = { clientHello: { ephemeral: ephemeralKeyPair.public } }
     helloMsg = proto.HandshakeMessage.fromObject(helloMsg)
     logger.info({ browser, helloMsg }, "connected to WA")
     const init = proto.HandshakeMessage.encode(helloMsg).finish()
@@ -333,67 +267,52 @@ export const makeSocket = (config) => {
       logger.info({ node }, "logging in...")
     }
     const payloadEnc = noise.encrypt(proto.ClientPayload.encode(node).finish())
-    await sendRawMessage(
-      proto.HandshakeMessage.encode({
-        clientFinish: {
-          static: keyEnc,
-          payload: payloadEnc,
-        },
-      }).finish(),
-    )
+    await sendRawMessage(proto.HandshakeMessage.encode({
+      clientFinish: { static: keyEnc, payload: payloadEnc }
+    }).finish())
     noise.finishInit()
     startKeepAliveRequest()
   }
+
   const getAvailablePreKeysOnServer = async () => {
     const result = await query({
       tag: "iq",
-      attrs: {
-        id: generateMessageTag(),
-        xmlns: "encrypt",
-        type: "get",
-        to: S_WHATSAPP_NET,
-      },
-      content: [{ tag: "count", attrs: {} }],
+      attrs: { id: generateMessageTag(), xmlns: "encrypt", type: "get", to: S_WHATSAPP_NET },
+      content: [{ tag: "count", attrs: {} }]
     })
     const countChild = getBinaryNodeChild(result, "count")
     return +countChild.attrs.value
   }
-  // Pre-key upload state management
-  let uploadPreKeysPromise = null
-  let lastUploadTime = 0
-  /** generates and uploads a set of pre-keys to the server */
+
   const uploadPreKeys = async (count = MIN_PREKEY_COUNT, retryCount = 0) => {
-    // Check minimum interval (except for retries)
     if (retryCount === 0) {
       const timeSinceLastUpload = Date.now() - lastUploadTime
       if (timeSinceLastUpload < MIN_UPLOAD_INTERVAL) {
-        logger.debug(`Skipping upload, only ${timeSinceLastUpload}ms since last upload`)
+        logger.debug(`Skipping upload, only ${timeSinceLastUpload}ms since last`)
         return
       }
     }
-    // Prevent multiple concurrent uploads
     if (uploadPreKeysPromise) {
-      logger.debug("Pre-key upload already in progress, waiting for completion")
+      logger.debug("Pre-key upload in progress, waiting")
       await uploadPreKeysPromise
+      return
     }
+    
     const uploadLogic = async () => {
       logger.info({ count, retryCount }, "uploading pre-keys")
-      // Generate and save pre-keys atomically (prevents ID collisions on retry)
       const node = await keys.transaction(async () => {
-        logger.debug({ requestedCount: count }, "generating pre-keys with requested count")
+        logger.debug({ requestedCount: count }, "generating pre-keys")
         const { update, node } = await getNextPreKeysNode({ creds, keys }, count)
-        // Update credentials immediately to prevent duplicate IDs on retry
         ev.emit("creds.update", update)
-        return node // Only return node since update is already used
+        return node
       }, creds?.me?.id || "upload-pre-keys")
-      // Upload to server (outside transaction, can fail without affecting local keys)
+      
       try {
         await query(node)
         logger.info({ count }, "uploaded pre-keys successfully")
         lastUploadTime = Date.now()
       } catch (uploadError) {
-        logger.error({ uploadError: uploadError.toString(), count }, "Failed to upload pre-keys to server")
-        // Exponential backoff retry (max 3 retries)
+        logger.error({ uploadError: uploadError.toString(), count }, "Failed to upload pre-keys")
         if (retryCount < 3) {
           const backoffDelay = Math.min(1000 * Math.pow(2, retryCount), 10000)
           logger.info(`Retrying pre-key upload in ${backoffDelay}ms`)
@@ -403,93 +322,127 @@ export const makeSocket = (config) => {
         throw uploadError
       }
     }
-    // Add timeout protection
+    
     uploadPreKeysPromise = Promise.race([
       uploadLogic(),
       new Promise((_, reject) =>
-        setTimeout(() => reject(new Boom("Pre-key upload timeout", { statusCode: 408 })), UPLOAD_TIMEOUT),
-      ),
+        setTimeout(() => reject(new Boom("Pre-key upload timeout", { statusCode: 408 })), UPLOAD_TIMEOUT)
+      )
     ])
+    
     try {
       await uploadPreKeysPromise
     } finally {
       uploadPreKeysPromise = null
     }
   }
-  // Add after the uploadPreKeys function:
-const smartPreKeyMonitor = async (reason = "scheduled") => {
-  const now = Date.now()
-  const timeSinceLastCheck = now - lastPreKeyCheck
-  
-  // Rate limiting - prevent spam
-  if (timeSinceLastCheck < PREKEY_MIN_INTERVAL && reason !== "critical") {
-    logger.debug({ 
-      timeSinceLastCheck, 
-      reason 
-    }, "Skipping pre-key check - too recent")
-    return
-  }
-  
-  // Prevent concurrent uploads
-  if (isUploadingPreKeys) {
-    logger.debug({ reason }, "Pre-key upload already in progress")
-    return
-  }
-  
-  lastPreKeyCheck = now
-  
-  try {
-    logger.debug({ reason }, "Checking pre-key status")
-    const preKeyCount = await getAvailablePreKeysOnServer()
+
+  const smartPreKeyMonitor = async (reason = "scheduled", priority = "normal") => {
+    const now = Date.now()
+    const timeSinceLastCheck = now - lastPreKeyCheck
     
-    logger.info({ preKeyCount, reason }, "Pre-key check result")
+    if (priority !== "critical") {
+      if (timeSinceLastCheck < PREKEY_MIN_INTERVAL) {
+        logger.debug({ timeSinceLastCheck, reason }, "Skipping pre-key check - too recent")
+        return
+      }
+    }
     
-    // Determine if upload is needed
-    const criticalThreshold = 3
-    const lowThreshold = MIN_PREKEY_COUNT
+    if (isUploadingPreKeys) {
+      logger.debug({ reason, priority }, "Pre-key upload in progress")
+      if (priority === "critical") {
+        preKeyCheckQueue.push({ reason, priority, timestamp: now })
+        logger.info("Critical pre-key check queued")
+      }
+      return
+    }
     
-    if (preKeyCount <= criticalThreshold) {
-      logger.warn({ preKeyCount }, "CRITICAL: Very low pre-keys, uploading immediately")
-      isUploadingPreKeys = true
-      await uploadPreKeys(INITIAL_PREKEY_COUNT) // Upload more when critical
-    } else if (preKeyCount < lowThreshold) {
-      logger.info({ preKeyCount }, "Low pre-keys detected, topping up")
-      isUploadingPreKeys = true
-      await uploadPreKeys(lowThreshold - preKeyCount + 5) // Top up with buffer
-    } else {
-      logger.debug({ preKeyCount }, "Pre-key count is healthy")
+    lastPreKeyCheck = now
+    
+    try {
+      logger.debug({ reason, priority }, "Checking pre-key status")
+      const preKeyCount = await getAvailablePreKeysOnServer()
+      logger.info({ preKeyCount, reason, priority }, "Pre-key check result")
+      
+      let shouldUpload = false, uploadCount = 0
+      
+      if (preKeyCount <= PREKEY_CRITICAL_THRESHOLD) {
+        logger.warn({ preKeyCount }, "🚨 CRITICAL: Very low pre-keys!")
+        shouldUpload = true
+        uploadCount = INITIAL_PREKEY_COUNT
+        priority = "critical"
+      } else if (preKeyCount < MIN_PREKEY_COUNT) {
+        logger.info({ preKeyCount }, "⚠️ Low pre-keys detected")
+        shouldUpload = true
+        uploadCount = Math.max(10, MIN_PREKEY_COUNT - preKeyCount + 5)
+      } else if (priority === "critical") {
+        logger.info({ preKeyCount }, "Uploading pre-keys for critical recovery")
+        shouldUpload = true
+        uploadCount = MIN_PREKEY_COUNT
+      } else {
+        logger.debug({ preKeyCount }, "✅ Pre-key count healthy")
+      }
+      
+      if (shouldUpload) {
+        isUploadingPreKeys = true
+        await uploadPreKeys(uploadCount)
+        if (preKeyCheckQueue.length > 0) {
+          logger.info(`Processing ${preKeyCheckQueue.length} queued checks`)
+          preKeyCheckQueue = []
+        }
+      }
+    } catch (error) {
+      logger.error({ error, reason, priority }, "Pre-key check failed")
+      if (priority === "critical") {
+        setTimeout(() => {
+          smartPreKeyMonitor(reason, "critical").catch(err =>
+            logger.error({ err }, "Critical pre-key retry failed")
+          )
+        }, 10000)
+      }
+    } finally {
+      isUploadingPreKeys = false
     }
-  } catch (error) {
-    logger.error({ error, reason }, "Pre-key check failed")
-  } finally {
-    isUploadingPreKeys = false
   }
-}
 
-// Start background monitor
-const startPreKeyBackgroundMonitor = () => {
-  if (preKeyMonitorInterval) {
-    clearInterval(preKeyMonitorInterval)
-  }
-  
-  preKeyMonitorInterval = setInterval(() => {
-    smartPreKeyMonitor("background-check").catch(err => {
-      logger.error({ err }, "Background pre-key monitor failed")
+  const triggerPreKeyCheck = (event, priority = "normal") => {
+    const triggers = {
+      "signal-error": "critical", "bad-mac": "critical", "session-corruption": "critical",
+      "auth-failure": "critical", "connection-established": "high", "connection-restored": "high",
+      "device-paired": "high", "message-send-error": "normal", "message-received": "normal",
+      "scheduled": "low", "keep-alive": "low"
+    }
+    const effectivePriority = triggers[event] || priority
+    logger.debug({ event, priority: effectivePriority }, "Pre-key check triggered")
+    smartPreKeyMonitor(event, effectivePriority).catch(err => {
+      logger.error({ err, event }, "Triggered pre-key check failed")
     })
-  }, PREKEY_CHECK_INTERVAL)
-  
-  logger.info({ intervalHours: PREKEY_CHECK_INTERVAL / (60 * 60 * 1000) }, 
-    "Started pre-key background monitor")
-}
+  }
+
+  const startPreKeyBackgroundMonitor = () => {
+    if (preKeyMonitorInterval) clearInterval(preKeyMonitorInterval)
+    preKeyMonitorInterval = setInterval(() => {
+      triggerPreKeyCheck("scheduled", "low")
+    }, PREKEY_CHECK_INTERVAL)
+    logger.info({ intervalMinutes: PREKEY_CHECK_INTERVAL / (60 * 1000) }, "Started pre-key monitor")
+  }
+
+  const stopPreKeyBackgroundMonitor = () => {
+    if (preKeyMonitorInterval) {
+      clearInterval(preKeyMonitorInterval)
+      preKeyMonitorInterval = null
+      logger.debug("Stopped pre-key monitor")
+    }
+  }
+
   const verifyCurrentPreKeyExists = async () => {
     const currentPreKeyId = creds.nextPreKeyId - 1
-    if (currentPreKeyId <= 0) {
-      return { exists: false, currentPreKeyId: 0 }
-    }
+    if (currentPreKeyId <= 0) return { exists: false, currentPreKeyId: 0 }
     const preKeys = await keys.get("pre-key", [currentPreKeyId.toString()])
     const exists = !!preKeys[currentPreKeyId.toString()]
     return { exists, currentPreKeyId }
   }
+
   const uploadPreKeysToServerIfRequired = async () => {
     try {
       let count = 0
@@ -498,42 +451,37 @@ const startPreKeyBackgroundMonitor = () => {
       else count = MIN_PREKEY_COUNT
       const { exists: currentPreKeyExists, currentPreKeyId } = await verifyCurrentPreKeyExists()
       logger.info(`${preKeyCount} pre-keys found on server`)
-      logger.info(`Current prekey ID: ${currentPreKeyId}, exists in storage: ${currentPreKeyExists}`)
+      logger.info(`Current prekey ID: ${currentPreKeyId}, exists: ${currentPreKeyExists}`)
       const lowServerCount = preKeyCount <= count
       const missingCurrentPreKey = !currentPreKeyExists && currentPreKeyId > 0
       const shouldUpload = lowServerCount || missingCurrentPreKey
       if (shouldUpload) {
         const reasons = []
         if (lowServerCount) reasons.push(`server count low (${preKeyCount})`)
-        if (missingCurrentPreKey) reasons.push(`current prekey ${currentPreKeyId} missing from storage`)
+        if (missingCurrentPreKey) reasons.push(`current prekey ${currentPreKeyId} missing`)
         logger.info(`Uploading PreKeys due to: ${reasons.join(", ")}`)
         await uploadPreKeys(count)
       } else {
-        logger.info(`PreKey validation passed - Server: ${preKeyCount}, Current prekey ${currentPreKeyId} exists`)
+        logger.info(`PreKey validation passed - Server: ${preKeyCount}, Current ${currentPreKeyId} exists`)
       }
     } catch (error) {
-      logger.error({ error }, "Failed to check/upload pre-keys during initialization")
-      // Don't throw - allow connection to continue even if pre-key check fails
+      logger.error({ error }, "Failed to check/upload pre-keys during init")
     }
   }
+
   const onMessageReceived = (data) => {
     noise.decodeFrame(data, (frame) => {
-      // reset ping timeout
       lastDateRecv = new Date()
-      updateLastMessageTime() // Update session health monitor
-      let anyTriggered = false
-      anyTriggered = ws.emit("frame", frame)
-      // if it's a binary node
+      lastMessageTime = Date.now()
+      reconnectAttempts = 0 // Reset on successful message
+      let anyTriggered = ws.emit("frame", frame)
       if (!(frame instanceof Uint8Array)) {
         const msgId = frame.attrs.id
         if (logger.level === "trace") {
           logger.trace({ xml: binaryNodeToString(frame), msg: "recv xml" })
         }
-        /* Check if this is a response to a message we sent */
         anyTriggered = ws.emit(`${DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered
-        /* Check if this is a response to a message we are expecting */
-        const l0 = frame.tag
-        const l1 = frame.attrs || {}
+        const l0 = frame.tag, l1 = frame.attrs || {}
         const l2 = Array.isArray(frame.content) ? frame.content[0]?.tag : ""
         for (const key of Object.keys(l1)) {
           anyTriggered = ws.emit(`${DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered
@@ -548,48 +496,52 @@ const startPreKeyBackgroundMonitor = () => {
       }
     })
   }
+
   const end = (error) => {
     if (closed) {
       logger.trace({ trace: error?.stack }, "connection already closed")
       return
     }
     closed = true
-    logger.info({ trace: error?.stack }, error ? "connection errored" : "connection closed")
+    
+    // Only log and end if it's a real error, not just Connection Terminated
+    const shouldLogError = error && error.message !== "Connection Terminated"
+    if (shouldLogError) {
+      logger.info({ trace: error?.stack }, "connection errored")
+    } else {
+      logger.debug("connection closed gracefully")
+    }
+    
     clearInterval(keepAliveReq)
-    clearInterval(sessionHealthCheck) // Clear health monitor
+    clearInterval(sessionHealthCheck)
     clearTimeout(qrTimer)
+    stopPreKeyBackgroundMonitor()
+    
     ws.removeAllListeners("close")
     ws.removeAllListeners("open")
     ws.removeAllListeners("message")
-      // Clean up pre-key monitor
-  if (preKeyMonitorInterval) {
-    clearInterval(preKeyMonitorInterval)
-    preKeyMonitorInterval = null
-    logger.debug("Stopped pre-key background monitor")
-  }
+    
     if (!ws.isClosed && !ws.isClosing) {
-      try {
-        ws.close()
-      } catch {}
+      try { ws.close() } catch {}
     }
-    ev.emit("connection.update", {
-      connection: "close",
-      lastDisconnect: {
-        error,
-        date: new Date(),
-      },
-    })
+    
+    // Don't emit if it's just a normal close
+    if (shouldLogError || (error && error.output?.statusCode !== DisconnectReason.connectionClosed)) {
+      ev.emit("connection.update", {
+        connection: "close",
+        lastDisconnect: { error, date: new Date() }
+      })
+    }
+    
     ev.removeAllListeners("connection.update")
   }
+
   const waitForSocketOpen = async () => {
-    if (ws.isOpen) {
-      return
-    }
+    if (ws.isOpen) return
     if (ws.isClosed || ws.isClosing) {
       throw new Boom("Connection Closed", { statusCode: DisconnectReason.connectionClosed })
     }
-    let onOpen
-    let onClose
+    let onOpen, onClose
     await new Promise((resolve, reject) => {
       onOpen = () => resolve(undefined)
       onClose = mapWebSocketError(reject)
@@ -602,180 +554,114 @@ const startPreKeyBackgroundMonitor = () => {
       ws.off("error", onClose)
     })
   }
-  const startKeepAliveRequest = () =>
-    (keepAliveReq = setInterval(() => {
-      if (!lastDateRecv) {
-        lastDateRecv = new Date()
-      }
-      const diff = Date.now() - lastDateRecv.getTime()
-      /*
-            check if it's been a suspicious amount of time since the server responded with our last seen
-            it could be that the network is down
-        */
-      if (diff > keepAliveIntervalMs + 5000) {
-        end(new Boom("Connection was lost", { statusCode: DisconnectReason.connectionLost }))
-      } else if (ws.isOpen) {
-        // if its all good, send a keep alive request
-        query({
+
+  const startKeepAliveRequest = () => {
+  let consecutiveFailedPings = 0
+  const MAX_FAILED_PINGS = 3  // Allow 3 failed pings before giving up
+  
+  keepAliveReq = setInterval(async () => {
+    if (!lastDateRecv) lastDateRecv = new Date()
+    
+    if (ws.isOpen) {
+      try {
+        // Send ping and WAIT for response
+        await query({
           tag: "iq",
-          attrs: {
-            id: generateMessageTag(),
-            to: S_WHATSAPP_NET,
-            type: "get",
-            xmlns: "w:p",
-          },
-          content: [{ tag: "ping", attrs: {} }],
-        }).catch((err) => {
-          logger.error({ trace: err.stack }, "error in sending keep alive")
+          attrs: { id: generateMessageTag(), to: S_WHATSAPP_NET, type: "get", xmlns: "w:p" },
+          content: [{ tag: "ping", attrs: {} }]
         })
-      } else {
-        logger.warn("keep alive called when WS not open")
+        
+        // ✅ Ping succeeded - reset failure counter
+        consecutiveFailedPings = 0
+        logger.debug("Keep-alive ping successful")
+        
+      } catch (err) {
+        // ❌ Ping failed
+        consecutiveFailedPings++
+        logger.warn({ 
+          consecutiveFailures: consecutiveFailedPings, 
+          maxAllowed: MAX_FAILED_PINGS 
+        }, "Keep-alive ping failed")
+        
+        // Only kill connection after multiple consecutive failures
+        if (consecutiveFailedPings >= MAX_FAILED_PINGS) {
+          logger.error("Multiple consecutive ping failures - connection lost")
+          end(new Boom("Connection was lost", { statusCode: DisconnectReason.connectionLost }))
+        }
       }
-    }, keepAliveIntervalMs))
-
-  // The keepalive mechanism above already handles connection health
-  let lastMessageTime = Date.now()
-  let sessionHealthCheck
+    } else {
+      logger.warn("keep alive called when WS not open")
+    }
+  }, keepAliveIntervalMs)
+}
 
   const startSessionHealthMonitor = () => {
     sessionHealthCheck = setInterval(() => {
       const timeSinceLastMsg = Date.now() - lastMessageTime
-      // Increased threshold to 5 minutes (was 90 seconds)
-      const healthCheckIntervalMs = keepAliveIntervalMs * 10 // 5 minutes with default 30s keep-alive
-
-      // Only log warning, don't force disconnect - let keepalive handle it
+      const healthCheckIntervalMs = keepAliveIntervalMs * 10
       if (timeSinceLastMsg > healthCheckIntervalMs && ws.isOpen) {
-        logger.warn(
-          { timeSinceLastMsg, threshold: healthCheckIntervalMs },
-          "Session health check: extended inactivity detected",
-        )
-        // The keepalive mechanism will naturally detect and handle dead connections
+        logger.warn({ timeSinceLastMsg, threshold: healthCheckIntervalMs }, "Extended inactivity detected")
       }
-    }, keepAliveIntervalMs * 4) // Check every ~2 minutes with default 30s keep-alive
+    }, keepAliveIntervalMs * 4)
   }
 
-  const updateLastMessageTime = () => {
-    lastMessageTime = Date.now()
-  }
-  /** i have no idea why this exists. pls enlighten me */
-  const sendPassiveIq = (tag) =>
-    query({
-      tag: "iq",
-      attrs: {
-        to: S_WHATSAPP_NET,
-        xmlns: "passive",
-        type: "set",
-      },
-      content: [{ tag, attrs: {} }],
-    })
-  /** logout & invalidate connection */
+  const sendPassiveIq = (tag) => query({
+    tag: "iq",
+    attrs: { to: S_WHATSAPP_NET, xmlns: "passive", type: "set" },
+    content: [{ tag, attrs: {} }]
+  })
+
   const logout = async (msg) => {
     const jid = authState.creds.me?.id
     if (jid) {
       await sendNode({
         tag: "iq",
-        attrs: {
-          to: S_WHATSAPP_NET,
-          type: "set",
-          id: generateMessageTag(),
-          xmlns: "md",
-        },
-        content: [
-          {
-            tag: "remove-companion-device",
-            attrs: {
-              jid,
-              reason: "user_initiated",
-            },
-          },
-        ],
+        attrs: { to: S_WHATSAPP_NET, type: "set", id: generateMessageTag(), xmlns: "md" },
+        content: [{ tag: "remove-companion-device", attrs: { jid, reason: "user_initiated" } }]
       })
     }
     end(new Boom(msg || "Intentional Logout", { statusCode: DisconnectReason.loggedOut }))
   }
+
   const requestPairingCode = async (phoneNumber, customPairingCode) => {
     const pairingCode = customPairingCode ?? bytesToCrockford(randomBytes(5))
     if (customPairingCode && customPairingCode?.length !== 8) {
       throw new Error("Custom pairing code must be exactly 8 chars")
     }
     authState.creds.pairingCode = pairingCode
-    authState.creds.me = {
-      id: jidEncode(phoneNumber, "s.whatsapp.net"),
-      name: "~",
-    }
+    authState.creds.me = { id: jidEncode(phoneNumber, "s.whatsapp.net"), name: "~" }
     ev.emit("creds.update", authState.creds)
     await sendNode({
       tag: "iq",
-      attrs: {
-        to: S_WHATSAPP_NET,
-        type: "set",
-        id: generateMessageTag(),
-        xmlns: "md",
-      },
-      content: [
-        {
-          tag: "link_code_companion_reg",
-          attrs: {
-            jid: authState.creds.me.id,
-            stage: "companion_hello",
-            should_show_push_notification: "true",
-          },
-          content: [
-            {
-              tag: "link_code_pairing_wrapped_companion_ephemeral_pub",
-              attrs: {},
-              content: await generatePairingKey(),
-            },
-            {
-              tag: "companion_server_auth_key_pub",
-              attrs: {},
-              content: authState.creds.noiseKey.public,
-            },
-            {
-              tag: "companion_platform_id",
-              attrs: {},
-              content: getPlatformId(browser[1]),
-            },
-            {
-              tag: "companion_platform_display",
-              attrs: {},
-              content: `${browser[1]} (${browser[0]})`,
-            },
-            {
-              tag: "link_code_pairing_nonce",
-              attrs: {},
-              content: "0",
-            },
-          ],
-        },
-      ],
+      attrs: { to: S_WHATSAPP_NET, type: "set", id: generateMessageTag(), xmlns: "md" },
+      content: [{
+        tag: "link_code_companion_reg",
+        attrs: { jid: authState.creds.me.id, stage: "companion_hello", should_show_push_notification: "true" },
+        content: [
+          { tag: "link_code_pairing_wrapped_companion_ephemeral_pub", attrs: {}, content: await generatePairingKey() },
+          { tag: "companion_server_auth_key_pub", attrs: {}, content: authState.creds.noiseKey.public },
+          { tag: "companion_platform_id", attrs: {}, content: getPlatformId(browser[1]) },
+          { tag: "companion_platform_display", attrs: {}, content: `${browser[1]} (${browser[0]})` },
+          { tag: "link_code_pairing_nonce", attrs: {}, content: "0" }
+        ]
+      }]
     })
     return authState.creds.pairingCode
   }
+
   async function generatePairingKey() {
-    const salt = randomBytes(32)
-    const randomIv = randomBytes(16)
+    const salt = randomBytes(32), randomIv = randomBytes(16)
     const key = await derivePairingCodeKey(authState.creds.pairingCode, salt)
     const ciphered = aesEncryptCTR(authState.creds.pairingEphemeralKeyPair.public, key, randomIv)
     return Buffer.concat([salt, randomIv, ciphered])
   }
-  const sendWAMBuffer = (wamBuffer) => {
-    return query({
-      tag: "iq",
-      attrs: {
-        to: S_WHATSAPP_NET,
-        id: generateMessageTag(),
-        xmlns: "w:stats",
-      },
-      content: [
-        {
-          tag: "add",
-          attrs: { t: Math.round(Date.now() / 1000) + "" },
-          content: wamBuffer,
-        },
-      ],
-    })
-  }
+
+  const sendWAMBuffer = (wamBuffer) => query({
+    tag: "iq",
+    attrs: { to: S_WHATSAPP_NET, id: generateMessageTag(), xmlns: "w:stats" },
+    content: [{ tag: "add", attrs: { t: Math.round(Date.now() / 1000) + "" }, content: wamBuffer }]
+  })
+
   ws.on("message", onMessageReceived)
   ws.on("open", async () => {
     try {
@@ -785,33 +671,46 @@ const startPreKeyBackgroundMonitor = () => {
       end(err)
     }
   })
-  ws.on("error", mapWebSocketError(end))
-  ws.on("close", () => end(new Boom("Connection Terminated", { statusCode: DisconnectReason.connectionClosed })))
-  // the server terminated the connection
-  ws.on("CB:xmlstreamend", () =>
-    end(new Boom("Connection Terminated by Server", { statusCode: DisconnectReason.connectionClosed })),
-  )
-  // QR gen
-  ws.on("CB:iq,type:set,pair-device", async (stanza) => {
-    const iq = {
-      tag: "iq",
-      attrs: {
-        to: S_WHATSAPP_NET,
-        type: "result",
-        id: stanza.attrs.id,
-      },
+
+  ws.on("error", (err) => {
+    logger.warn({ err: err.message }, "WebSocket error occurred")
+    // Don't immediately end - let other mechanisms handle it
+  })
+
+  ws.on("close", (code, reason) => {
+    logger.debug({ code, reason: reason?.toString() }, "WebSocket closed")
+    // Graceful close, don't throw error
+    if (!closed) {
+      setTimeout(() => {
+        if (!closed && reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+          reconnectAttempts++
+          logger.info({ attempt: reconnectAttempts }, "Attempting to reconnect...")
+          ws.restart().catch(err => logger.error({ err }, "Reconnect failed"))
+        } else if (!closed) {
+          end(new Boom("Connection Terminated", { statusCode: DisconnectReason.connectionClosed }))
+        }
+      }, Math.min(1000 * Math.pow(2, reconnectAttempts), 10000)) // Exponential backoff
+    }
+  })
+
+  ws.on("CB:xmlstreamend", () => {
+    logger.info("Stream ended by server")
+    if (!closed) {
+      end(new Boom("Connection Terminated by Server", { statusCode: DisconnectReason.connectionClosed }))
     }
+  })
+
+  ws.on("CB:iq,type:set,pair-device", async (stanza) => {
+    const iq = { tag: "iq", attrs: { to: S_WHATSAPP_NET, type: "result", id: stanza.attrs.id } }
     await sendNode(iq)
     const pairDeviceNode = getBinaryNodeChild(stanza, "pair-device")
     const refNodes = getBinaryNodeChildren(pairDeviceNode, "ref")
     const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString("base64")
     const identityKeyB64 = Buffer.from(creds.signedIdentityKey.public).toString("base64")
     const advB64 = creds.advSecretKey
-    let qrMs = qrTimeout || 60000 // time to let a QR live
+    let qrMs = qrTimeout || 60000
     const genPairQR = () => {
-      if (!ws.isOpen) {
-        return
-      }
+      if (!ws.isOpen) return
       const refNode = refNodes.shift()
       if (!refNode) {
         end(new Boom("QR refs attempts ended", { statusCode: DisconnectReason.timedOut }))
@@ -821,29 +720,26 @@ const startPreKeyBackgroundMonitor = () => {
       const qr = [ref, noiseKeyB64, identityKeyB64, advB64].join(",")
       ev.emit("connection.update", { qr })
       qrTimer = setTimeout(genPairQR, qrMs)
-      qrMs = qrTimeout || 20000 // shorter subsequent qrs
+      qrMs = qrTimeout || 20000
     }
     genPairQR()
   })
-  // device paired for the first time
-  // if device pairs successfully, the server asks to restart the connection
+
   ws.on("CB:iq,,pair-success", async (stanza) => {
     logger.debug("pair success recv")
     try {
       const { reply, creds: updatedCreds } = configureSuccessfulPairing(stanza, creds)
-      logger.info(
-        { me: updatedCreds.me, platform: updatedCreds.platform },
-        "pairing configured successfully, expect to restart the connection...",
-      )
+      logger.info({ me: updatedCreds.me, platform: updatedCreds.platform }, "pairing configured successfully")
       ev.emit("creds.update", updatedCreds)
       ev.emit("connection.update", { isNewLogin: true, qr: undefined })
+      triggerPreKeyCheck("device-paired", "high")
       await sendNode(reply)
     } catch (error) {
       logger.info({ trace: error.stack }, "error in pairing")
       end(error)
     }
   })
-  // login complete
+
   ws.on("CB:success", async (node) => {
     try {
       await uploadPreKeysToServerIfRequired()
@@ -852,33 +748,21 @@ const startPreKeyBackgroundMonitor = () => {
       logger.warn({ err }, "failed to send initial passive iq")
     }
     logger.info("opened connection to WA")
-    clearTimeout(qrTimer) // will never happen in all likelyhood -- but just in case WA sends success on first try
-      // Immediate check on connect
-  smartPreKeyMonitor("connection-established").catch(err => {
-    logger.warn({ err }, "Initial pre-key check failed")
-  })
-  
-  // Start background monitor
-  startPreKeyBackgroundMonitor()
+    clearTimeout(qrTimer)
+    triggerPreKeyCheck("connection-established", "high")
+    startPreKeyBackgroundMonitor()
     ev.emit("creds.update", { me: { ...authState.creds.me, lid: node.attrs.lid } })
     ev.emit("connection.update", { connection: "open" })
-    // Start monitoring session health after successful connection
     startSessionHealthMonitor()
+    reconnectAttempts = 0
     if (node.attrs.lid && authState.creds.me?.id) {
       const myLID = node.attrs.lid
       process.nextTick(async () => {
         try {
           const myPN = authState.creds.me.id
-          // Store our own LID-PN mapping
           await signalRepository.lidMapping.storeLIDPNMappings([{ lid: myLID, pn: myPN }])
-          // Create device list for our own user (needed for bulk migration)
           const { user, device } = jidDecode(myPN)
-          await authState.keys.set({
-            "device-list": {
-              [user]: [device?.toString() || "0"],
-            },
-          })
-          // migrate our own session
+          await authState.keys.set({ "device-list": { [user]: [device?.toString() || "0"] } })
           await signalRepository.migrateSession(myPN, myLID)
           logger.info({ myPN, myLID }, "Own LID session created successfully")
         } catch (error) {
@@ -887,27 +771,27 @@ const startPreKeyBackgroundMonitor = () => {
       })
     }
   })
+
   ws.on("CB:stream:error", (node) => {
     logger.error({ node }, "stream errored out")
     const { reason, statusCode } = getErrorCodeFromStreamError(node)
     end(new Boom(`Stream Errored (${reason})`, { statusCode, data: node }))
   })
-  // stream fail, possible logout
+
   ws.on("CB:failure", (node) => {
     const reason = +(node.attrs.reason || 500)
     end(new Boom("Connection Failure", { statusCode: reason, data: node.attrs }))
   })
+
   ws.on("CB:ib,,downgrade_webclient", () => {
     end(new Boom("Multi-device beta not joined", { statusCode: DisconnectReason.multideviceMismatch }))
   })
+
   ws.on("CB:ib,,offline_preview", (node) => {
     logger.info("offline preview received", JSON.stringify(node))
-    sendNode({
-      tag: "ib",
-      attrs: {},
-      content: [{ tag: "offline_batch", attrs: { count: "100" } }],
-    })
+    sendNode({ tag: "ib", attrs: {}, content: [{ tag: "offline_batch", attrs: { count: "100" } }] })
   })
+
   ws.on("CB:ib,,edge_routing", (node) => {
     const edgeRoutingNode = getBinaryNodeChild(node, "edge_routing")
     const routingInfo = getBinaryNodeChild(edgeRoutingNode, "routing_info")
@@ -916,17 +800,16 @@ const startPreKeyBackgroundMonitor = () => {
       ev.emit("creds.update", authState.creds)
     }
   })
+
   let didStartBuffer = false
   process.nextTick(() => {
     if (creds.me?.id) {
-      // start buffering important events
-      // if we're logged in
       ev.buffer()
       didStartBuffer = true
     }
     ev.emit("connection.update", { connection: "connecting", receivedPendingNotifications: false, qr: undefined })
   })
-  // called when all offline notifs are handled
+
   ws.on("CB:ib,,offline", (node) => {
     const child = getBinaryNodeChild(node, "offline")
     const offlineNotifs = +(child?.attrs.count || 0)
@@ -937,29 +820,21 @@ const startPreKeyBackgroundMonitor = () => {
     }
     ev.emit("connection.update", { receivedPendingNotifications: true })
   })
-  // update credentials when required
+
   ev.on("creds.update", (update) => {
     const name = update.me?.name
-    // if name has just been received
     if (creds.me?.name !== name) {
       logger.debug({ name }, "updated pushName")
-      sendNode({
-        tag: "presence",
-        attrs: { name: name },
-      }).catch((err) => {
+      sendNode({ tag: "presence", attrs: { name: name } }).catch((err) => {
         logger.warn({ trace: err.stack }, "error in sending presence update on name change")
       })
     }
     Object.assign(creds, update)
   })
 
-  /**
-   * Regenerate pre-keys immediately when Signal protocol errors occur
-   */
   const regeneratePreKeysForRecovery = async () => {
     try {
       logger.info("Initiating aggressive pre-key regeneration for signal recovery")
-      // Upload 15 fresh pre-keys immediately for recovery
       const preKeyNodes = getNextPreKeysNode(authState, MIN_PREKEY_COUNT)
       if (preKeyNodes) {
         await sendNode(preKeyNodes)
@@ -970,7 +845,6 @@ const startPreKeyBackgroundMonitor = () => {
     }
   }
 
-  // Handler for signal session corruption on connection issues
   const handleSignalSessionCorruption = async (reason) => {
     if (reason === "SIGNAL_SESSION_CORRUPTED" || reason === "BAD_MAC_ERROR") {
       logger.warn("Signal session corruption detected - regenerating pre-keys immediately")
@@ -979,52 +853,23 @@ const startPreKeyBackgroundMonitor = () => {
   }
 
   return {
-    type: "md",
-    ws,
-    ev,
-    authState: { creds, keys },
-    signalRepository,
-    get user() {
-      return authState.creds.me
-    },
-    generateMessageTag,
-    query,
-    waitForMessage,
-    waitForSocketOpen,
-    sendRawMessage,
-    sendNode,
-    logout,
-    end,
-    onUnexpectedError,
-    uploadPreKeys,
-    uploadPreKeysToServerIfRequired,
-    requestPairingCode,
-    wamBuffer: publicWAMBuffer,
-    /** Waits for the connection to WA to reach a state */
-    waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
-    sendWAMBuffer,
-    executeUSyncQuery,
-    onWhatsApp,
-    regeneratePreKeysForRecovery,
-    handleSignalSessionCorruption,
+    type: "md", ws, ev, authState: { creds, keys }, signalRepository,
+    get user() { return authState.creds.me },
+    generateMessageTag, query, waitForMessage, waitForSocketOpen, sendRawMessage, sendNode,
+    logout, end, onUnexpectedError, uploadPreKeys, uploadPreKeysToServerIfRequired,
+    requestPairingCode, wamBuffer: publicWAMBuffer,
+    waitForConnectionUpdate: bindWaitForConnectionUpdate(ev), sendWAMBuffer,
+    executeUSyncQuery, onWhatsApp, regeneratePreKeysForRecovery, handleSignalSessionCorruption,
     listener: (eventName) => {
-      if (typeof ev.listenerCount === "function") {
-        return ev.listenerCount(eventName)
-      }
-      if (typeof ev.listeners === "function") {
-        return ev.listeners(eventName)?.length || 0
-      }
+      if (typeof ev.listenerCount === "function") return ev.listenerCount(eventName)
+      if (typeof ev.listeners === "function") return ev.listeners(eventName)?.length || 0
       return 0
-    },
+    }
   }
 }
-/**
- * map the websocket error to the right type
- * so it can be retried by the caller
- * */
+
 function mapWebSocketError(handler) {
   return (error) => {
     handler(new Boom(`WebSocket Error (${error?.message})`, { statusCode: getCodeFromWSError(error), data: error }))
   }
-}
-//# sourceMappingURL=socket.js.map
+}