@neelegirl/baileys 1.5.7 → 1.5.8

package/README.md

@@ -5,7 +5,7 @@
 
 <h1 align="center">🌸 Willkommen bei <code>@neelegirl/baileys</code> 🌸</h1>
 <p align="center"><i>Eine charmante WhatsApp Web API für TypeScript/JavaScript – von einer Prinzessin für alle, die Magie lieben.</i></p>
-<p align="center"><strong>✨ Version 1.5.7 – Aktualisiert mit neuesten Features von @whiskeysockets/baileys ✨</strong></p>
+<p align="center"><strong>✨ Version 1.5.8 – Aktualisiert mit neuesten Features von @whiskeysockets/baileys ✨</strong></p>
 
 <div align="center">
 
@@ -45,7 +45,10 @@ Die Entwickler:innen übernehmen keine Verantwortung für den Gebrauch. Lies die
 - 💖 Vollständige **Multi‑Device** Unterstützung
 - 🧩 **LID‑kompatibel** (Linked ID Erkennung & Nutzung)
 - 🧷 Saubere TypeScript‑Typen, DX zum Verlieben
-- 🆕 **Version 1.5.7** – Aktualisiert mit neuesten Features von @whiskeysockets/baileys
+- 🆕 **Version 1.5.8** – Aktualisiert mit neuesten Features von @whiskeysockets/baileys
+- ✨ **Neue Features**: `onWhatsApp()`, `executeUSyncQuery()`, `digestKeyBundle()`, `rotateSignedPreKey()`
+- 🚀 **Verbesserte Pre-Key-Verwaltung** mit automatischer Validierung
+- 💎 **WAM Buffer Support** für erweiterte Statistiken
 
 ---
 

package/lib/Socket/socket.js

@@ -11,6 +11,9 @@ const Defaults_1 = require("../Defaults")
 const Types_1 = require("../Types")
 const Utils_1 = require("../Utils")
 const WABinary_1 = require("../WABinary")
+const BinaryInfo_1 = require("../WAM/BinaryInfo")
+const USyncQuery_1 = require("../WAUSync/USyncQuery")
+const USyncUser_1 = require("../WAUSync/USyncUser")
 const Client_1 = require("./Client")
 const package_json_1 = require("../../package.json")
 const CURRENT_VERSION = package_json_1.version
@@ -38,6 +41,7 @@ const makeSocket = (config) => {
     
     ws.connect()
     const ev = Utils_1.makeEventBuffer(logger)
+    const publicWAMBuffer = new BinaryInfo_1.BinaryInfo()
     
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
     const ephemeralKeyPair = Utils_1.Curve.generateKeyPair()
@@ -54,7 +58,11 @@ const makeSocket = (config) => {
     
     // add transaction capability
     const keys = Utils_1.addTransactionCapability(authState.keys, logger, transactionOpts)
-    const signalRepository = makeSignalRepository({ creds, keys })
+    // pnFromLIDUSync wird später definiert, daher temporär undefined
+    let signalRepository
+    const initSignalRepository = () => {
+        signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync)
+    }
     
     let lastDateRecv
     let epoch = 1
@@ -139,21 +147,38 @@ const makeSocket = (config) => {
         let onRecv
         let onErr
         try {
-            return await Utils_1.promiseTimeout(timeoutMs, (resolve, reject) => {
-                onRecv = resolve
+            const result = await Utils_1.promiseTimeout(timeoutMs, (resolve, reject) => {
+                onRecv = data => {
+                    resolve(data)
+                }
                 onErr = err => {
-                    reject(err || new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed }))
+                    reject(err ||
+                        new boom_1.Boom('Connection Closed', {
+                            statusCode: Types_1.DisconnectReason.connectionClosed
+                        }))
                 }
                 ws.on(`TAG:${msgId}`, onRecv)
-                ws.on('close', onErr) // if the socket closes, you'll never receive the message
-                ws.off('error', onErr)
+                ws.on('close', onErr)
+                ws.on('error', onErr)
+                return () => reject(new boom_1.Boom('Query Cancelled'))
             })
+            return result
+        }
+        catch (error) {
+            // Catch timeout and return undefined instead of throwing
+            if (error instanceof boom_1.Boom && error.output?.statusCode === Types_1.DisconnectReason.timedOut) {
+                logger?.warn?.({ msgId }, 'timed out waiting for message')
+                return undefined
+            }
+            throw error
         }
-        
         finally {
-            ws.off(`TAG:${msgId}`, onRecv)
-            ws.off('close', onErr) // if the socket closes, you'll never receive the message
-            ws.off('error', onErr)
+            if (onRecv)
+                ws.off(`TAG:${msgId}`, onRecv)
+            if (onErr) {
+                ws.off('close', onErr)
+                ws.off('error', onErr)
+            }
         }
     }
     
@@ -162,20 +187,146 @@ const makeSocket = (config) => {
         if (!node.attrs.id) {
             node.attrs.id = generateMessageTag()
         }
-        
         const msgId = node.attrs.id
-        const wait = waitForMessage(msgId, timeoutMs) 
-        
-        await sendNode(node)
-        
-        const result = await wait
-        
-        if ('tag' in result) {
+        const result = await Utils_1.promiseTimeout(timeoutMs, async (resolve, reject) => {
+            const result = waitForMessage(msgId, timeoutMs).catch(reject)
+            sendNode(node)
+                .then(async () => resolve(await result))
+                .catch(reject)
+        })
+        if (result && 'tag' in result) {
             WABinary_1.assertNodeErrorFree(result)
         }
-        
         return result
     }
+    // Validate current key-bundle on server; on failure, trigger pre-key upload and rethrow
+    const digestKeyBundle = async () => {
+        const res = await query({
+            tag: 'iq',
+            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: 'get', xmlns: 'encrypt' },
+            content: [{ tag: 'digest', attrs: {} }]
+        })
+        const digestNode = WABinary_1.getBinaryNodeChild(res, 'digest')
+        if (!digestNode) {
+            await uploadPreKeys()
+            throw new Error('encrypt/get digest returned no digest node')
+        }
+    }
+    // Rotate our signed pre-key on server; on failure, run digest as fallback and rethrow
+    const rotateSignedPreKey = async () => {
+        const newId = (creds.signedPreKey.keyId || 0) + 1
+        const skey = await Utils_1.signedKeyPair(creds.signedIdentityKey, newId)
+        await query({
+            tag: 'iq',
+            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: 'set', xmlns: 'encrypt' },
+            content: [
+                {
+                    tag: 'rotate',
+                    attrs: {},
+                    content: [Utils_1.xmppSignedPreKey(skey)]
+                }
+            ]
+        })
+        // Persist new signed pre-key in creds
+        ev.emit('creds.update', { signedPreKey: skey })
+    }
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.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 iq = {
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.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]
+                }
+            ]
+        }
+        const result = await query(iq)
+        return usyncQuery.parseUSyncQueryResult(result)
+    }
+    const onWhatsApp = async (...phoneNumber) => {
+        let usyncQuery = new USyncQuery_1.USyncQuery()
+        let contactEnabled = false
+        for (const jid of phoneNumber) {
+            if (WABinary_1.isLidUser(jid)) {
+                logger?.warn('LIDs are not supported with onWhatsApp')
+                continue
+            }
+            else {
+                if (!contactEnabled) {
+                    contactEnabled = true
+                    usyncQuery = usyncQuery.withContactProtocol()
+                }
+                const phone = `+${jid.replace('+', '').split('@')[0]?.split(':')[0]}`
+                usyncQuery.withUser(new USyncUser_1.USyncUser().withPhone(phone))
+            }
+        }
+        if (usyncQuery.users.length === 0) {
+            return [] // return early without forcing an empty query
+        }
+        const results = await executeUSyncQuery(usyncQuery)
+        if (results) {
+            return results.list.filter(a => !!a.contact).map(({ contact, id }) => ({ jid: id, exists: contact }))
+        }
+    }
+    const pnFromLIDUSync = async (jids) => {
+        const usyncQuery = new USyncQuery_1.USyncQuery().withLIDProtocol().withContext('background')
+        for (const jid of jids) {
+            if (WABinary_1.isLidUser(jid)) {
+                logger?.warn('LID user found in LID fetch call')
+                continue
+            }
+            else {
+                usyncQuery.withUser(new USyncUser_1.USyncUser().withId(jid))
+            }
+        }
+        if (usyncQuery.users.length === 0) {
+            return [] // return early without forcing an empty query
+        }
+        const results = await executeUSyncQuery(usyncQuery)
+        if (results) {
+            return results.list.filter(a => !!a.lid).map(({ lid, id }) => ({ pn: id, lid: lid }))
+        }
+        return []
+    }
+    // Initialize signalRepository after pnFromLIDUSync is defined
+    initSignalRepository()
     /** connection handshake */
     const validateConnection = async () => {
         let helloMsg = {
@@ -254,8 +405,8 @@ const makeSocket = (config) => {
         }
     }
     
-    const onMessageReceived = (data) => {
-        noise.decodeFrame(data, frame => {
+    const onMessageReceived = async (data) => {
+        await noise.decodeFrame(data, frame => {
             // reset ping timeout
             lastDateRecv = new Date()
             let anyTriggered = false
@@ -509,7 +660,7 @@ const makeSocket = (config) => {
             content: [
                 {
                     tag: 'add',
-                    attrs: {},
+                    attrs: { t: Math.round(Date.now() / 1000) + '' },
                     content: wamBuffer
                 }
             ]
@@ -619,27 +770,52 @@ const makeSocket = (config) => {
     ws.on('CB:success', async (node) => {
         try {
             await uploadPreKeysToServerIfRequired()
-            
             await sendPassiveIq('active')
-            
-            logger.info('opened connection to WA')
-            
-            clearTimeout(qrTimer) // will never happen in all likelyhood -- but just in case WA sends success on first try
-            ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } })
-            ev.emit('connection.update', { connection: 'open' })
+            // After successful login, validate our key-bundle against server
+            try {
+                await digestKeyBundle()
+            }
+            catch (e) {
+                logger.warn({ e }, 'failed to run digest after login')
+            }
         }
-        
         catch (err) {
-            logger.error({ err }, 'error opening connection')
-            end(err)
+            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
+        ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } })
+        ev.emit('connection.update', { connection: 'open' })
+        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 } = WABinary_1.jidDecode(myPN)
+                    await authState.keys.set({
+                        'device-list': {
+                            [user]: [device?.toString() || '0']
+                        }
+                    })
+                    // migrate our own session
+                    await signalRepository.migrateSession(myPN, myLID)
+                    logger.info({ myPN, myLID }, 'Own LID session created successfully')
+                }
+                catch (error) {
+                    logger.error({ error, lid: myLID }, 'Failed to create own LID session')
+                }
+            })
         }
     })
     
     ws.on('CB:stream:error', (node) => {
-        logger.error({ node }, 'stream errored out')
+        const [reasonNode] = WABinary_1.getAllBinaryNodeChildren(node)
+        logger.error({ reasonNode, fullErrorNode: node }, 'stream errored out')
         const { reason, statusCode } = Utils_1.getErrorCodeFromStreamError(node)
-        
-        end(new boom_1.Boom(`Stream Errored (${reason})`, { statusCode, data: node }))
+        end(new boom_1.Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }))
     })
     
     // stream fail, possible logout
@@ -653,10 +829,9 @@ const makeSocket = (config) => {
         end(new boom_1.Boom('Multi-device beta not joined', { statusCode: Types_1.DisconnectReason.multideviceMismatch }))
     })
     
-    ws.on('CB:ib,,offline_preview', (node) => {
+    ws.on('CB:ib,,offline_preview', async (node) => {
         logger.info('offline preview received', JSON.stringify(node))
-        
-        sendNode({
+        await sendNode({
             tag: 'ib',
             attrs: {},
             content: [{ tag: 'offline_batch', attrs: { count: '100' } }]
@@ -744,10 +919,15 @@ const makeSocket = (config) => {
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,
+        digestKeyBundle,
+        rotateSignedPreKey,
         requestPairingCode,
+        wamBuffer: publicWAMBuffer,
         /** Waits for the connection to WA to reach a state */
         waitForConnectionUpdate: Utils_1.bindWaitForConnectionUpdate(ev),
         sendWAMBuffer,
+        executeUSyncQuery,
+        onWhatsApp
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neelegirl/baileys",
-  "version": "1.5.7",
+  "version": "1.5.8",
   "description": "WhatsApp API for wa-api, a multi-device WhatsApp Web API client",
   "keywords": [
     "whatsapp",