@nexustechpro/baileys 1.0.8 → 1.1.0

package/README.md

@@ -733,42 +733,6 @@ await sock.sendMessage(jid, {
 })
 ```
 
-#### Pin Message
-```javascript
-await sock.sendMessage(jid, {
-    pin: {
-        type: 1, // 0 to remove
-        time: 86400, // 24 hours in seconds
-        key: message.key
-    }
-})
-```
-
-**Pin Time Options:**
-
-| Time | Seconds   |
-|------|-----------|
-| 24h  | 86,400    |
-| 7d   | 604,800   |
-| 30d  | 2,592,000 |
-
-#### Keep Message
-```javascript
-await sock.sendMessage(jid, {
-    keep: message.key,
-    type: 1, // 2 to unpin
-    time: 86400
-})
-```
-
-**Keep Time Options:**
-
-| Time | Seconds   |
-|------|-----------|
-| 24h  | 86,400    |
-| 7d   | 604,800   |
-| 30d  | 2,592,000 |
-
 #### Poll Message
 ```javascript
 await sock.sendMessage(jid, {
@@ -1373,6 +1337,51 @@ await sock.chatModify({ pin: true }, jid)
 await sock.chatModify({ pin: false }, jid)
 ```
 
+
+#### Pin Message
+```javascript
+// Method 1: Using boolean (requires quoted message)
+await sock.sendMessage(jid, { pin: true }, { quoted: message })
+
+// Method 2: Using pin object with message key
+await sock.sendMessage(jid, {
+    pin: {
+        key: message.key  // or stanzaId, id, etc.
+    }
+})
+
+// Unpin message
+await sock.sendMessage(jid, {
+    pin: {
+        key: message.key,
+        unpin: true
+    }
+})
+
+// Alternative unpin syntax
+await sock.sendMessage(jid, { pin: false }, { quoted: message })
+```
+
+#### Keep Message
+```javascript
+await sock.sendMessage(jid, {
+    keep: message.key,
+    type: 1  // 1 to keep, 2 to unkeep
+})
+```
+
+**Pin/Keep Details:**
+
+| Operation | Method | Syntax |
+|-----------|--------|--------|
+| Pin (quoted) | Boolean | `{ pin: true }` with `{ quoted: message }` |
+| Pin (object) | Object | `{ pin: { key: message.key } }` |
+| Unpin (quoted) | Boolean | `{ pin: false }` with `{ quoted: message }` |
+| Unpin (object) | Object | `{ pin: { key: message.key, unpin: true } }` |
+| Keep | Key | `{ keep: message.key, type: 1 }` |
+| Unkeep | Key | `{ keep: message.key, type: 2 }` |
+
+
 ### Delete Chat
 ```javascript
 const lastMsg = await getLastMessageInChat(jid)

package/lib/Defaults/index.js

@@ -107,7 +107,7 @@ export const MEDIA_HKDF_KEY_MAPPING = {
 };
 export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
 export const MIN_PREKEY_COUNT = 5;
-export const INITIAL_PREKEY_COUNT = 812;
+export const INITIAL_PREKEY_COUNT = 95; // Changed from 812 to 95
 export const UPLOAD_TIMEOUT = 30000; // 30 seconds
 export const MIN_UPLOAD_INTERVAL = 5000; // 5 seconds minimum between uploads
 export const DEFAULT_CACHE_TTLS = {

package/lib/Signal/libsignal.js

@@ -104,14 +104,30 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
       }
     },
 
-    deleteSession: jids => jids.length && txn(() => parsedKeys.set({ session: Object.fromEntries(jids.map(j => [jidToAddr(j).toString(), null])) }), `del-${jids.length}`),
+    deleteSession: jids => jids.length && txn(async () => {
+      const sessionAddrs = jids.map(j => jidToAddr(j).toString())
+      // Load batched sessions
+      const batchData = await parsedKeys.get("session", ["_index"])
+      const sessionBatch = batchData?.['_index'] || {}
+      
+      // Remove the specified sessions
+      sessionAddrs.forEach(addr => {
+        delete sessionBatch[addr]
+      })
+      
+      // Store updated batch
+      await parsedKeys.set({ session: { "_index": sessionBatch } })
+    }, `del-${jids.length}`),
 
     migrateSession: async (fromJid, toJid) => {
       if (!fromJid || (!isLidUser(toJid) && !isHostedLidUser(toJid))) return { migrated: 0, skipped: 0, total: 0 }
       if (!isPnUser(fromJid) && !isHostedPnUser(fromJid)) return { migrated: 0, skipped: 0, total: 1 }
       
       const { user } = jidDecode(fromJid)
-      const { [user]: userDevices } = await parsedKeys.get("device-list", [user])
+      // Load device-list from batched storage
+      const batchData = await parsedKeys.get("device-list", ["_index"])
+      const deviceListBatch = batchData?.['_index'] || {}
+      const userDevices = deviceListBatch[user]
       if (!userDevices?.length) return { migrated: 0, skipped: 0, total: 0 }
 
       const { device: fromDevice } = jidDecode(fromJid)
@@ -119,41 +135,43 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
       if (!userDevices.includes(fromDeviceStr)) userDevices.push(fromDeviceStr)
 
       const uncachedDevices = userDevices.filter(d => !migratedCache.has(`${user}.${d}`))
-      const deviceSessionKeys = uncachedDevices.map(d => `${user}.${d}`)
-      const existingSessions = await parsedKeys.get("session", deviceSessionKeys)
-
-      const deviceJids = Object.entries(existingSessions)
-        .filter(([_, s]) => s)
-        .map(([k]) => {
-          const [_, device] = k.split(".")
-          const num = Number.parseInt(device)
-          return num === 0 ? `${user}@s.whatsapp.net` : num === 99 ? `${user}:99@hosted` : `${user}:${num}@s.whatsapp.net`
+      
+      // Load batched sessions
+      const sessionBatchData = await parsedKeys.get("session", ["_index"])
+      const sessionBatch = sessionBatchData?.['_index'] || {}
+      
+      const deviceJids = uncachedDevices
+        .map(d => {
+          const num = Number.parseInt(d)
+          const addrStr = num === 0 ? `${user}.0` : `${user}.${d}`
+          return { addr: addrStr, jid: num === 0 ? `${user}@s.whatsapp.net` : num === 99 ? `${user}:99@hosted` : `${user}:${num}@s.whatsapp.net` }
         })
+        .filter(({ addr }) => sessionBatch[addr])
 
       return txn(async () => {
-        const pnAddrStrs = Array.from(new Set(deviceJids.map(jid => jidToAddr(jid).toString())))
-        const pnSessions = await parsedKeys.get("session", pnAddrStrs)
-        
-        const updates = {}
+        const pnAddrStrs = Array.from(new Set(deviceJids.map(d => jidToAddr(d.jid).toString())))
+        const updatedBatch = { ...sessionBatch }
         let migrated = 0
         
-        for (const jid of deviceJids) {
+        for (const { jid } of deviceJids) {
           const pnAddr = jidToAddr(jid).toString()
           const lidAddr = jidToAddr(transferDevice(jid, toJid)).toString()
-          const pnSession = pnSessions[pnAddr]
+          const pnSession = updatedBatch[pnAddr]
           
           if (pnSession) {
             const sess = libsignal.SessionRecord.deserialize(pnSession)
             if (sess.haveOpenSession()) {
-              updates[lidAddr] = sess.serialize()
-              updates[pnAddr] = null
+              updatedBatch[lidAddr] = sess.serialize()
+              delete updatedBatch[pnAddr]
               migrated++
               migratedCache.set(`${user}.${jidDecode(jid).device || 0}`, true)
             }
           }
         }
         
-        if (Object.keys(updates).length > 0) await parsedKeys.set({ session: updates })
+        if (migrated > 0) {
+          await parsedKeys.set({ session: { "_index": updatedBatch } })
+        }
         return { migrated, skipped: deviceJids.length - migrated, total: deviceJids.length }
       }, `migrate-${deviceJids.length}`)
     },
@@ -176,7 +194,10 @@ function signalStorage({ creds, keys }, lidMapping, logger) {
     loadSession: async id => {
       try {
         const addr = await resolveLID(id)
-        const { [addr]: sess } = await keys.get("session", [addr])
+        // Load from batched session storage
+        const batchData = await keys.get("session", ["_index"])
+        const sessionBatch = batchData?.['_index'] || {}
+        const sess = sessionBatch[addr]
         return sess ? libsignal.SessionRecord.deserialize(sess) : null
       } catch (e) {
         logger?.error?.(`[Signal] Load session: ${e.message}`)
@@ -186,7 +207,22 @@ function signalStorage({ creds, keys }, lidMapping, logger) {
 
     storeSession: async (id, session) => {
       const addr = await resolveLID(id)
-      await keys.set({ session: { [addr]: session.serialize() } })
+      // Store in batched session storage
+      const existingData = await keys.get("session", ["_index"])
+      const sessionBatch = existingData?.['_index'] || {}
+      
+      // Add/update the session
+      sessionBatch[addr] = session.serialize()
+      
+      // Keep only the most recent 1000 sessions to prevent unlimited growth
+      const sessionKeys = Object.keys(sessionBatch).sort()
+      const recentSessions = sessionKeys.slice(-1000)
+      const trimmedBatch = {}
+      recentSessions.forEach(key => {
+        trimmedBatch[key] = sessionBatch[key]
+      })
+      
+      await keys.set({ session: { "_index": trimmedBatch } })
     },
 
     isTrustedIdentity: () => true,

package/lib/Socket/groups.js

@@ -282,6 +282,9 @@ export const makeGroupsSocket = (config) => {
 };
 export const extractGroupMetadata = (result) => {
     const group = getBinaryNodeChild(result, 'group');
+    if (!group) {
+        throw new Error('Group node not found in result');
+    }
     const descChild = getBinaryNodeChild(group, 'description');
     let desc;
     let descId;

package/lib/Socket/messages-recv.js

@@ -68,6 +68,7 @@ export const makeMessagesRecvSocket = (config) => {
     uploadPreKeys,
     sendPeerDataOperationMessage,
     messageRetryManager,
+    triggerPreKeyCheck,
   } = sock
   /** this mutex ensures that each retryRequest will wait for the previous one to finish */
   const retryMutex = makeMutex()
@@ -141,7 +142,7 @@ export const makeMessagesRecvSocket = (config) => {
   const handleMexNewsletterNotification = async (node) => {
     const mexNode = getBinaryNodeChild(node, "mex")
     if (!mexNode?.content) {
-      logger.warn({ node }, "Invalid mex newsletter notification")
+      //logger.warn({ node }, "Invalid mex newsletter notification")
       return
     }
     let data
@@ -334,157 +335,174 @@ export const makeMessagesRecvSocket = (config) => {
     await query(stanza)
   }
   const sendRetryRequest = async (node, forceIncludeKeys = false) => {
-    const { fullMessage } = decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || "")
-    const { key: msgKey } = fullMessage
-    const msgId = msgKey.id
-    if (messageRetryManager) {
-      // Check if we've exceeded max retries using the new system
-      if (messageRetryManager.hasExceededMaxRetries(msgId)) {
-        logger.debug({ msgId }, "reached retry limit with new retry manager, clearing")
-        messageRetryManager.markRetryFailed(msgId)
-        return
-      }
-      // Increment retry count using new system
-      const retryCount = messageRetryManager.incrementRetryCount(msgId)
-      // Use the new retry count for the rest of the logic
-      const key = `${msgId}:${msgKey?.participant}`
-      msgRetryCache.set(key, retryCount)
-    } else {
-      // Fallback to old system
-      const key = `${msgId}:${msgKey?.participant}`
-      let retryCount = (await msgRetryCache.get(key)) || 0
-      if (retryCount >= maxMsgRetryCount) {
-        logger.debug({ retryCount, msgId }, "reached retry limit, clearing")
-        msgRetryCache.del(key)
-        return
-      }
-      retryCount += 1
-      await msgRetryCache.set(key, retryCount)
+  const { fullMessage } = decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || "")
+  const { key: msgKey } = fullMessage
+  const msgId = msgKey.id
+  
+  if (messageRetryManager) {
+    if (messageRetryManager.hasExceededMaxRetries(msgId)) {
+      logger.debug({ msgId }, "reached retry limit with new retry manager, clearing")
+      messageRetryManager.markRetryFailed(msgId)
+      return
     }
+    const retryCount = messageRetryManager.incrementRetryCount(msgId)
     const key = `${msgId}:${msgKey?.participant}`
-    const retryCount = (await msgRetryCache.get(key)) || 1
-    const { account, signedPreKey, signedIdentityKey: identityKey } = authState.creds
-    const fromJid = node.attrs.from
-    // Check if we should recreate the session
-    let shouldRecreateSession = false
-    let recreateReason = ""
-    if (enableAutoSessionRecreation && messageRetryManager) {
-      try {
-        // Check if we have a session with this JID
-        const sessionId = signalRepository.jidToSignalProtocolAddress(fromJid)
-        const hasSession = await signalRepository.validateSession(fromJid)
-        const result = messageRetryManager.shouldRecreateSession(fromJid, retryCount, hasSession.exists)
-        shouldRecreateSession = result.recreate
-        recreateReason = result.reason
-        if (shouldRecreateSession) {
-          logger.debug({ fromJid, retryCount, reason: recreateReason }, "recreating session for retry")
-          // Delete existing session to force recreation
-          await authState.keys.set({ session: { [sessionId]: null } })
-          forceIncludeKeys = true
+    msgRetryCache.set(key, retryCount)
+  } else {
+    const key = `${msgId}:${msgKey?.participant}`
+    let retryCount = (await msgRetryCache.get(key)) || 0
+    if (retryCount >= maxMsgRetryCount) {
+      logger.debug({ retryCount, msgId }, "reached retry limit, clearing")
+      msgRetryCache.del(key)
+      return
+    }
+    retryCount += 1
+    await msgRetryCache.set(key, retryCount)
+  }
+  
+  const key = `${msgId}:${msgKey?.participant}`
+  const retryCount = (await msgRetryCache.get(key)) || 1
+  const { account, signedPreKey, signedIdentityKey: identityKey } = authState.creds
+  const fromJid = node.attrs.from
+  
+  // ENHANCED: Check both PN and potential LID for session
+  let shouldRecreateSession = false
+  let recreateReason = ""
+  
+  if (enableAutoSessionRecreation && messageRetryManager) {
+    try {
+      const sessionId = signalRepository.jidToSignalProtocolAddress(fromJid)
+      const hasSession = await signalRepository.validateSession(fromJid)
+      
+      // Also check if LID mapping exists and session should be under LID
+      let lidJid = null
+      if (isPnUser(fromJid)) {
+        lidJid = await signalRepository.lidMapping.getLIDForPN(fromJid)
+      }
+      
+      const result = messageRetryManager.shouldRecreateSession(fromJid, retryCount, hasSession.exists)
+      shouldRecreateSession = result.recreate
+      recreateReason = result.reason
+      
+      if (shouldRecreateSession) {
+        logger.debug({ fromJid, lidJid, retryCount, reason: recreateReason }, "recreating session for retry")
+        
+        // Delete both PN and LID sessions to force clean rebuild
+        await authState.keys.set({ session: { [sessionId]: null } })
+        if (lidJid) {
+          const lidSessionId = signalRepository.jidToSignalProtocolAddress(lidJid)
+          await authState.keys.set({ session: { [lidSessionId]: null } })
         }
-      } catch (error) {
-        logger.warn({ error, fromJid }, "failed to check session recreation")
+        
+        forceIncludeKeys = true
       }
+    } catch (error) {
+      logger.warn({ error, fromJid }, "failed to check session recreation")
     }
-    if (retryCount <= 2) {
-      // Use new retry manager for phone requests if available
-      if (messageRetryManager) {
-        // Schedule phone request with delay (like whatsmeow)
-        messageRetryManager.schedulePhoneRequest(msgId, async () => {
-          try {
-            const requestId = await requestPlaceholderResend(msgKey)
-            logger.debug(
-              `sendRetryRequest: requested placeholder resend (${requestId}) for message ${msgId} (scheduled)`,
-            )
-          } catch (error) {
-            logger.warn({ error, msgId }, "failed to send scheduled phone request")
-          }
-        })
-      } else {
-        // Fallback to immediate request
-        const msgId = await requestPlaceholderResend(msgKey)
-        logger.debug(`sendRetryRequest: requested placeholder resend for message ${msgId}`)
-      }
+  }
+  
+  // Rest of the function remains the same...
+  if (retryCount <= 2) {
+    if (messageRetryManager) {
+      messageRetryManager.schedulePhoneRequest(msgId, async () => {
+        try {
+          const requestId = await requestPlaceholderResend(msgKey)
+          logger.debug(
+            `sendRetryRequest: requested placeholder resend (${requestId}) for message ${msgId} (scheduled)`,
+          )
+        } catch (error) {
+          logger.warn({ error, msgId }, "failed to send scheduled phone request")
+        }
+      })
+    } else {
+      const msgId = await requestPlaceholderResend(msgKey)
+      logger.debug(`sendRetryRequest: requested placeholder resend for message ${msgId}`)
     }
-    const deviceIdentity = encodeSignedDeviceIdentity(account, true)
-    await authState.keys.transaction(async () => {
-      const receipt = {
-        tag: "receipt",
-        attrs: {
-          id: msgId,
-          type: "retry",
-          to: node.attrs.from,
+  }
+  
+  const deviceIdentity = encodeSignedDeviceIdentity(account, true)
+  await authState.keys.transaction(async () => {
+    const receipt = {
+      tag: "receipt",
+      attrs: {
+        id: msgId,
+        type: "retry",
+        to: node.attrs.from,
+      },
+      content: [
+        {
+          tag: "retry",
+          attrs: {
+            count: retryCount.toString(),
+            id: node.attrs.id,
+            t: node.attrs.t,
+            v: "1",
+            error: "0",
+          },
+        },
+        {
+          tag: "registration",
+          attrs: {},
+          content: encodeBigEndian(authState.creds.registrationId),
         },
+      ],
+    }
+    
+    if (node.attrs.recipient) {
+      receipt.attrs.recipient = node.attrs.recipient
+    }
+    if (node.attrs.participant) {
+      receipt.attrs.participant = node.attrs.participant
+    }
+    
+    if (retryCount > 1 || forceIncludeKeys || shouldRecreateSession) {
+      const { update, preKeys } = await getNextPreKeys(authState, 1)
+      const [keyId] = Object.keys(preKeys)
+      const key = preKeys[+keyId]
+      const content = receipt.content
+      content.push({
+        tag: "keys",
+        attrs: {},
         content: [
-          {
-            tag: "retry",
-            attrs: {
-              count: retryCount.toString(),
-              id: node.attrs.id,
-              t: node.attrs.t,
-              v: "1",
-              // ADD ERROR FIELD
-              error: "0",
-            },
-          },
-          {
-            tag: "registration",
-            attrs: {},
-            content: encodeBigEndian(authState.creds.registrationId),
-          },
+          { tag: "type", attrs: {}, content: Buffer.from(KEY_BUNDLE_TYPE) },
+          { tag: "identity", attrs: {}, content: identityKey.public },
+          xmppPreKey(key, +keyId),
+          xmppSignedPreKey(signedPreKey),
+          { tag: "device-identity", attrs: {}, content: deviceIdentity },
         ],
-      }
-      if (node.attrs.recipient) {
-        receipt.attrs.recipient = node.attrs.recipient
-      }
-      if (node.attrs.participant) {
-        receipt.attrs.participant = node.attrs.participant
-      }
-      if (retryCount > 1 || forceIncludeKeys || shouldRecreateSession) {
-        const { update, preKeys } = await getNextPreKeys(authState, 1)
-        const [keyId] = Object.keys(preKeys)
-        const key = preKeys[+keyId]
-        const content = receipt.content
-        content.push({
-          tag: "keys",
-          attrs: {},
-          content: [
-            { tag: "type", attrs: {}, content: Buffer.from(KEY_BUNDLE_TYPE) },
-            { tag: "identity", attrs: {}, content: identityKey.public },
-            xmppPreKey(key, +keyId),
-            xmppSignedPreKey(signedPreKey),
-            { tag: "device-identity", attrs: {}, content: deviceIdentity },
-          ],
-        })
-        ev.emit("creds.update", update)
-      }
-      await sendNode(receipt)
-      logger.info({ msgAttrs: node.attrs, retryCount }, "sent retry receipt")
-    }, authState?.creds?.me?.id || "sendRetryRequest")
-  }
-  const handleEncryptNotification = async (node) => {
-    const from = node.attrs.from
-    if (from === S_WHATSAPP_NET) {
-      const countChild = getBinaryNodeChild(node, "count")
-      const count = +countChild.attrs.value
-      const shouldUploadMorePreKeys = count < MIN_PREKEY_COUNT
-      logger.debug({ count, shouldUploadMorePreKeys }, "recv pre-key count")
-      if (shouldUploadMorePreKeys) {
-        smartPreKeyMonitor("server-notification").catch(err => {
-        logger.error({ err }, "Failed to upload pre-keys after server notification")
       })
-      }
-    } else {
-      const identityNode = getBinaryNodeChild(node, "identity")
-      if (identityNode) {
-        logger.info({ jid: from }, "identity changed")
-        // not handling right now
-        // signal will override new identity anyway
+      ev.emit("creds.update", update)
+    }
+    
+    await sendNode(receipt)
+    logger.info({ msgAttrs: node.attrs, retryCount }, "sent retry receipt")
+  }, authState?.creds?.me?.id || "sendRetryRequest")
+}
+
+  const handleEncryptNotification = async (node) => {
+  const from = node.attrs.from
+  if (from === S_WHATSAPP_NET) {
+    const countChild = getBinaryNodeChild(node, "count")
+    const count = +countChild.attrs.value
+    const shouldUploadMorePreKeys = count < MIN_PREKEY_COUNT
+    logger.debug({ count, shouldUploadMorePreKeys }, "recv pre-key count")
+    if (shouldUploadMorePreKeys) {
+      // Use debounced trigger if available, otherwise fallback to direct upload
+      if (typeof triggerPreKeyCheck === 'function') {
+        triggerPreKeyCheck("server-notification", "normal")
       } else {
-        logger.info({ node }, "unknown encrypt notification")
+        await uploadPreKeys(MIN_PREKEY_COUNT)
       }
     }
+  } else {
+    const identityNode = getBinaryNodeChild(node, "identity")
+    if (identityNode) {
+      logger.info({ jid: from }, "identity changed")
+    } else {
+      logger.info({ node }, "unknown encrypt notification")
+    }
   }
+}
   const handleGroupNotification = (fullNode, child, msg) => {
     // TODO: Support PN/LID (Here is only LID now)
     const actingParticipantLid = fullNode.attrs.participant