@hansaka02/baileys 7.3.4 → 7.3.6

package/lib/Socket/socket.js

@@ -46,11 +46,13 @@ const {
   encodeBinaryNode, 
   getBinaryNodeChild, 
   getBinaryNodeChildren, 
+  getAllBinaryNodeChildren, 
   isLidUser,
   jidDecode,
   jidEncode, 
-  S_WHATSAPP_NET 
+  S_WHATSAPP_NET
 } = require("../WABinary")
+const { BinaryInfo } = require("../WAM") 
 const {
   USyncUser, 
   USyncQuery
@@ -64,11 +66,23 @@ const { WebSocketClient } = require("./Client")
  * - query phone connection
  */
 const makeSocket = (config) => {
-    const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository } = config
+    const { 
+        waWebSocketUrl, 
+        connectTimeoutMs, 
+        logger, 
+        keepAliveIntervalMs, 
+        browser, 
+        auth: authState, 
+        printQRInTerminal, 
+        defaultQueryTimeoutMs, 
+        transactionOpts,
+        qrTimeout, 
+        makeSignalRepository 
+    } = config
     
     const uqTagId = generateMdTagPrefix()
     const generateMessageTag = () => `${uqTagId}${epoch++}`
-    
+    const publicWAMBuffer = new BinaryInfo()
     const url = typeof waWebSocketUrl === 'string' ? new URL(waWebSocketUrl) : waWebSocketUrl
     
     if (config.mobile || url.protocol === 'tcp:') {
@@ -79,6 +93,53 @@ const makeSocket = (config) => {
         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
+    })
+    
+    const ws = new WebSocketClient(url, config)
+    
+    ws.connect()
+    
+    const sendPromise = promisify(ws.send)
+    
+    /** send a raw buffer */
+    const sendRawMessage = async (data) => {
+        if (!ws.isOpen) {
+            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed })
+        }
+        
+        const bytes = noise.encodeFrame(data)
+        
+        await promiseTimeout(connectTimeoutMs, async (resolve, reject) => {
+            try {
+                await sendPromise.call(ws, bytes)
+                resolve()
+            }
+            catch (error) {
+                reject(error)
+            }
+        })
+    }
+    
+    /** send a binary node */
+    const sendNode = (frame) => {
+        if (logger.level === 'trace') {
+            logger.trace({ xml: binaryNodeToString(frame), msg: 'xml send' })
+        }
+        
+        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
@@ -87,22 +148,47 @@ const makeSocket = (config) => {
     const waitForMessage = async (msgId, timeoutMs = defaultQueryTimeoutMs) => {
         let onRecv
         let onErr
+        
         try {
-            return await promiseTimeout(timeoutMs, (resolve, reject) => {
-                onRecv = resolve
+            const result = await promiseTimeout(timeoutMs, (resolve, reject) => {
+                onRecv = data => {
+                    resolve(data)
+                }
+                
                 onErr = err => {
-                    reject(err || new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }))
+                    reject(err ||
+                        new Boom('Connection Closed', {
+                            statusCode: 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('Query Cancelled'))
             })
+            
+            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
+            }
+            
+            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)
+            }
         }
     }
    
@@ -113,22 +199,60 @@ const makeSocket = (config) => {
         }
         
         const msgId = node.attrs.id
-        const wait = waitForMessage(msgId, timeoutMs) 
-        
-        await sendNode(node)
-        
-        const result = await wait
+        const result = await promiseTimeout(timeoutMs, async (resolve, reject) => {
+            const result = waitForMessage(msgId, timeoutMs).catch(reject)
+            sendNode(node)
+                .then(async () => resolve(await result))
+                .catch(reject)
+        })
         
-        if ('tag' in result) {
+        if (result && 'tag' in result) {
             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: S_WHATSAPP_NET, type: 'get', xmlns: 'encrypt' },
+            content: [{ tag: 'digest', attrs: {} }]
+        })
+        
+        const digestNode = 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 signedKeyPair(creds.signedIdentityKey, newId)
+        
+        await query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'encrypt' },
+            content: [
+                {
+                    tag: 'rotate',
+                    attrs: {},
+                    content: [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('USyncQuery must have at least one protocol');
+            throw new Boom('USyncQuery must have at least one protocol')
         }
         
         // todo: validate users, throw WARNING on no valid users
@@ -179,53 +303,74 @@ const makeSocket = (config) => {
         }
         
         const result = await query(iq)
+        
         return usyncQuery.parseUSyncQueryResult(result)
     }
     
-    const onWhatsApp = async (...jids) => {
-        const usyncQuery = new USyncQuery().withLIDProtocol().withContactProtocol()
-        for (const jid of jids) {
+    const onWhatsApp = async (...phoneNumber) => {
+        let usyncQuery = new USyncQuery()
+        let contactEnabled = false
+        
+        for (const jid of phoneNumber) {
             if (isLidUser(jid)) {
-                usyncQuery.withUser(new USyncUser().withId(jid)) // intentional
+                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().withPhone(phone))
             }
         }
+        
+        if (usyncQuery.users.length === 0) {
+            return [] // return early without forcing an empty query
+        }
+        
         const results = await executeUSyncQuery(usyncQuery)
+        
         if (results) {
-            if (results.list.filter(a => !!a.lid).length > 0) {
-                const lidOnly = results.list.filter(a => !!a.lid)
-                await signalRepository.lidMapping.storeLIDPNMappings(lidOnly.map(a => ({ pn: a.id, lid: a.lid })))
-            }
-            return results.list
-                .filter(a => !!a.contact)
-                .map(({ contact, id, lid }) => ({ jid: id, exists: contact, lid: lid }))
+            return results.list.filter(a => !!a.contact).map(({ contact, id }) => ({ jid: id, exists: contact }))
         }
     }
     
-    const ws = new WebSocketClient(url, config)
+    const pnFromLIDUSync = async (jids) => {
+        const usyncQuery = new USyncQuery().withLIDProtocol().withContext('background')
+        for (const jid of jids) {
+            if (isLidUser(jid)) {
+                logger?.warn('LID user found in LID fetch call')
+                continue
+            }
+            
+            else {
+                usyncQuery.withUser(new 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 []
+    }
     
-    ws.connect()
     const ev = makeEventBuffer(logger)
-    
-    /** 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
-    })
-    
     const { creds } = authState
     
     // add transaction capability
     const keys = addTransactionCapability(authState.keys, logger, transactionOpts)
-    const signalRepository = makeSignalRepository({ creds, keys }, onWhatsApp, logger)
+    const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync)
     
     let lastDateRecv
     let epoch = 1
@@ -233,37 +378,6 @@ const makeSocket = (config) => {
     let qrTimer
     let closed = false
     
-    const sendPromise = promisify(ws.send)
-    
-    /** send a raw buffer */
-    const sendRawMessage = async (data) => {
-        if (!ws.isOpen) {
-            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed })
-        }
-        
-        const bytes = noise.encodeFrame(data)
-        await promiseTimeout(connectTimeoutMs, async (resolve, reject) => {
-            try {
-                await sendPromise.call(ws, bytes)
-                resolve()
-            }
-            catch (error) {
-                reject(error)
-            }
-        })
-    }
-    
-    /** send a binary node */
-    const sendNode = (frame) => {
-        if (logger.level === 'trace') {
-            logger.trace({ xml: binaryNodeToString(frame), msg: 'xml send' })
-        }
-        
-        const buff = encodeBinaryNode(frame)
-        
-        return sendRawMessage(buff)
-    }
-    
     /** log & process any unexpected errors */
     const onUnexpectedError = (err, msg) => {
         logger.error({ err }, `unexpected error in '${msg}'`)
@@ -283,6 +397,7 @@ const makeSocket = (config) => {
         const result = promiseTimeout(connectTimeoutMs, (resolve, reject) => {
             onOpen = resolve
             onClose = mapWebSocketError(reject)
+            
             ws.on('frame', onOpen)
             ws.on('close', onClose)
             ws.on('error', onClose)
@@ -306,6 +421,7 @@ const makeSocket = (config) => {
         }
         
         helloMsg = proto.HandshakeMessage.fromObject(helloMsg)
+        
         logger.info({ browser, helloMsg }, 'connected to WA')
         
         const init = proto.HandshakeMessage.encode(helloMsg).finish()
@@ -315,6 +431,7 @@ const makeSocket = (config) => {
         logger.trace({ handshake }, 'handshake recv from WA')
         
         const keyEnc = await noise.processHandshake(handshake, creds.noiseKey)
+        
         let node
         
         if (!creds.me) {
@@ -326,15 +443,18 @@ const makeSocket = (config) => {
             node = generateLoginNode(creds.me.id, 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,
-            },
+                payload: payloadEnc
+            }
         }).finish())
-        noise.finishInit()
+        
+        await noise.finishInit()
+        
         startKeepAliveRequest()
     }
     
@@ -362,10 +482,11 @@ const makeSocket = (config) => {
     let lastUploadTime = 0
     
     /** generates and uploads a set of pre-keys to the server */
-    const uploadPreKeys = async (count = INITIAL_PREKEY_COUNT, retryCount = 0) => {
+    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`)
                 return
@@ -375,7 +496,7 @@ const makeSocket = (config) => {
         // Prevent multiple concurrent uploads
         if (uploadPreKeysPromise) {
             logger.debug('Pre-key upload already in progress, waiting for completion')
-            return uploadPreKeysPromise
+            await uploadPreKeysPromise
         }
         
         const uploadLogic = async () => {
@@ -384,6 +505,7 @@ const makeSocket = (config) => {
             // 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')
+                
                 const { update, node } = await getNextPreKeysNode({ creds, keys }, count)
                 
                 // Update credentials immediately to prevent duplicate IDs on retry
@@ -398,15 +520,21 @@ const makeSocket = (config) => {
                 logger.info({ count }, 'uploaded pre-keys successfully')
                 lastUploadTime = Date.now()
             }
+            
             catch (uploadError) {
-                logger.error({ uploadError, count }, 'Failed to upload pre-keys to server')
+                logger.error({ uploadError: uploadError.toString(), count }, 'Failed to upload pre-keys to server')
+                
                 // Exponential backoff retry (max 3 retries)
                 if (retryCount < 3) {
                     const backoffDelay = Math.min(1000 * Math.pow(2, retryCount), 10000)
+                    
                     logger.info(`Retrying pre-key upload in ${backoffDelay}ms`)
+                    
                     await new Promise(resolve => setTimeout(resolve, backoffDelay))
+                    
                     return uploadPreKeys(count, retryCount + 1)
                 }
+                
                 throw uploadError
             }
         }
@@ -416,9 +544,11 @@ const makeSocket = (config) => {
             uploadLogic(),
             new Promise((_, reject) => setTimeout(() => reject(new Boom('Pre-key upload timeout', { statusCode: 408 })), UPLOAD_TIMEOUT))
         ])
+        
         try {
             await uploadPreKeysPromise
         }
+        
         finally {
             uploadPreKeysPromise = null
         }
@@ -426,50 +556,69 @@ const makeSocket = (config) => {
     
     const verifyCurrentPreKeyExists = async () => {
         const currentPreKeyId = creds.nextPreKeyId - 1
+        
         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
+            
             const preKeyCount = await getAvailablePreKeysOnServer()
+            
+            if (preKeyCount === 0)
+                count = INITIAL_PREKEY_COUNT
+            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}`)
             
-            const lowServerCount = preKeyCount <= MIN_PREKEY_COUNT
+            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`)
+                    
                 logger.info(`Uploading PreKeys due to: ${reasons.join(', ')}`)
-                await uploadPreKeys()
+                
+                await uploadPreKeys(count)
             }
+            
             else {
                 logger.info(`PreKey validation passed - Server: ${preKeyCount}, Current prekey ${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
         }
     }
     
-    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
+            
             anyTriggered = ws.emit('frame', frame)
             
             // if it's a binary node
@@ -513,8 +662,10 @@ const makeSocket = (config) => {
         closed = true
         
         logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed')
+        
         clearInterval(keepAliveReq)
         clearTimeout(qrTimer)
+        
         ws.removeAllListeners('close')
         ws.removeAllListeners('open')
         ws.removeAllListeners('message')
@@ -523,7 +674,7 @@ const makeSocket = (config) => {
             try {
                 ws.close()
             }
-            catch (_a) { }
+            catch { }
         }
         
         ev.emit('connection.update', {
@@ -543,7 +694,7 @@ const makeSocket = (config) => {
         }
         
         if (ws.isClosed || ws.isClosing) {
-            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed })
+            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
         }
         
         let onOpen
@@ -552,6 +703,7 @@ const makeSocket = (config) => {
         await new Promise((resolve, reject) => {
             onOpen = () => resolve(undefined)
             onClose = mapWebSocketError(reject)
+            
             ws.on('open', onOpen)
             ws.on('close', onClose)
             ws.on('error', onClose)
@@ -663,7 +815,6 @@ const makeSocket = (config) => {
                     attrs: {
                         jid: authState.creds.me.id,
                         stage: 'companion_hello',
-                        // eslint-disable-next-line camelcase
                         should_show_push_notification: 'true'
                     },
                     content: [
@@ -720,7 +871,7 @@ const makeSocket = (config) => {
             content: [
                 {
                     tag: 'add',
-                    attrs: {},
+                    attrs: { t: Math.round(Date.now() / 1000) + '' },
                     content: wamBuffer
                 }
             ]
@@ -810,21 +961,37 @@ const makeSocket = (config) => {
         }
     })
     
+    // login complete
     // login complete
     ws.on('CB:success', async (node) => {
         try {
             await uploadPreKeysToServerIfRequired()
             await sendPassiveIq('active')
+            
+            // 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.warn({ err }, 'failed to send initial passive iq');
+            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
+        
+        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
@@ -832,10 +999,21 @@ const makeSocket = (config) => {
                     // Store our own LID-PN mapping
                     await signalRepository.lidMapping.storeLIDPNMappings([{ lid: myLID, pn: myPN }])
                     
-                    // Create LID session for ourselves (whatsmeow pattern)
-                    await signalRepository.migrateSession([myPN], myLID)
+                    // 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 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')
                 }
@@ -844,11 +1022,14 @@ const makeSocket = (config) => {
     })
     
     ws.on('CB:stream:error', (node) => {
-        logger.error({ node }, 'stream errored out')
+        const [reasonNode] = getAllBinaryNodeChildren(node)
+        
+        logger.error({ reasonNode, fullErrorNode: node }, 'stream errored out')
+        
         const { reason, statusCode } = getErrorCodeFromStreamError(node)
         
-        end(new Boom(`Stream Errored (${reason})`, { statusCode, data: node }))
-    })
+        end(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }))
+    });
     
     // stream fail, possible logout
     ws.on('CB:failure', (node) => {
@@ -939,7 +1120,7 @@ const makeSocket = (config) => {
         authState: { creds, keys },
         signalRepository,
         get user() {
-            return authState.creds.me
+            return authState.creds.me;
         },
         generateMessageTag,
         query,
@@ -952,13 +1133,15 @@ const makeSocket = (config) => {
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,
+        digestKeyBundle,
+        rotateSignedPreKey,
         requestPairingCode,
+        wamBuffer: publicWAMBuffer,
         /** Waits for the connection to WA to reach a state */
         waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
         sendWAMBuffer,
-        executeUSyncQuery, 
-        onWhatsApp, 
-        logger
+        executeUSyncQuery,
+        onWhatsApp
     }
 }