@neelegirl/baileys 1.5.2 → 1.5.3

package/lib/Socket/socket.js

@@ -12,6 +12,7 @@ const Types_1 = require("../Types")
 const Utils_1 = require("../Utils")
 const WABinary_1 = require("../WABinary")
 const Client_1 = require("./Client")
+const WAUSync_1 = require("../WAUSync")
 
 /**
  * Connects to WA servers and performs:
@@ -22,6 +23,9 @@ const Client_1 = require("./Client")
 const makeSocket = (config) => {
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository } = config
     
+    const uqTagId = Utils_1.generateMdTagPrefix()
+    const generateMessageTag = () => `${uqTagId}${epoch++}`
+    
     const url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl
     
     if (config.mobile || url.protocol === 'tcp:') {
@@ -32,6 +36,132 @@ const makeSocket = (config) => {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'))
     }
     
+    /**
+     * 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
+        try {
+            return await Utils_1.promiseTimeout(timeoutMs, (resolve, reject) => {
+                onRecv = resolve
+                onErr = err => {
+                    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)
+            })
+        }
+        
+        finally {
+            ws.off(`TAG:${msgId}`, onRecv)
+            ws.off('close', onErr) // if the socket closes, you'll never receive the message
+            ws.off('error', onErr)
+        }
+    }
+   
+    /** 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()
+        }
+        
+        const msgId = node.attrs.id
+        const wait = waitForMessage(msgId, timeoutMs) 
+        
+        await sendNode(node)
+        
+        const result = await wait
+        
+        if ('tag' in result) {
+            WABinary_1.assertNodeErrorFree(result)
+        }
+        
+        return result
+    }
+    
+    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._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 (...jids) => {
+        const usyncQuery = new WAUSync_1.USyncQuery().withLIDProtocol().withContactProtocol()
+        for (const jid of jids) {
+            if (WABinary_1.isLidUser(jid)) {
+                usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid)) // intentional
+            }
+            else {
+                const phone = `+${jid.replace('+', '').split('@')[0]?.split(':')[0]}`
+                usyncQuery.withUser(new WAUSync_1.USyncUser().withPhone(phone))
+            }
+        }
+        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 }))
+        }
+    }
+    
     const ws = new Client_1.WebSocketClient(url, config)
     
     ws.connect()
@@ -52,7 +182,7 @@ const makeSocket = (config) => {
     
     // add transaction capability
     const keys = Utils_1.addTransactionCapability(authState.keys, logger, transactionOpts)
-    const signalRepository = makeSignalRepository({ creds, keys })
+    const signalRepository = makeSignalRepository({ creds, keys }, onWhatsApp, logger)
     
     let lastDateRecv
     let epoch = 1
@@ -60,8 +190,6 @@ const makeSocket = (config) => {
     let qrTimer
     let closed = false
     
-    const uqTagId = Utils_1.generateMdTagPrefix()
-    const generateMessageTag = () => `${uqTagId}${epoch++}`
     const sendPromise = util_1.promisify(ws.send)
     
     /** send a raw buffer */
@@ -128,52 +256,6 @@ const makeSocket = (config) => {
         return result
     }
     
-    /**
-     * 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
-        try {
-            return await Utils_1.promiseTimeout(timeoutMs, (resolve, reject) => {
-                onRecv = resolve
-                onErr = err => {
-                    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)
-            })
-        }
-        
-        finally {
-            ws.off(`TAG:${msgId}`, onRecv)
-            ws.off('close', onErr) // if the socket closes, you'll never receive the message
-            ws.off('error', onErr)
-        }
-    }
-    
-    /** 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()
-        }
-        
-        const msgId = node.attrs.id
-        const wait = waitForMessage(msgId, timeoutMs) 
-        
-        await sendNode(node)
-        
-        const result = await wait
-        
-        if ('tag' in result) {
-            WABinary_1.assertNodeErrorFree(result)
-        }
-        
-        return result
-    }
     /** connection handshake */
     const validateConnection = async () => {
         let helloMsg = {
@@ -232,23 +314,111 @@ const makeSocket = (config) => {
         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 = Defaults_1.INITIAL_PREKEY_COUNT) => {
-        await keys.transaction(async () => {
-            logger.info({ count }, 'uploading pre-keys')
-            const { update, node } = await Utils_1.getNextPreKeysNode({ creds, keys }, count)
-            await query(node)
-            ev.emit('creds.update', update)
-            logger.info({ count }, 'uploaded pre-keys')
-        })
+    const uploadPreKeys = async (count = Defaults_1.INITIAL_PREKEY_COUNT, retryCount = 0) => {
+        // Check minimum interval (except for retries)
+        if (retryCount === 0) {
+            const timeSinceLastUpload = Date.now() - lastUploadTime
+            if (timeSinceLastUpload < Defaults_1.MIN_UPLOAD_INTERVAL) {
+                logger.debug(`Skipping upload, only ${timeSinceLastUpload}ms since last upload`)
+                return
+            }
+        }
+        
+        // Prevent multiple concurrent uploads
+        if (uploadPreKeysPromise) {
+            logger.debug('Pre-key upload already in progress, waiting for completion')
+            return uploadPreKeysPromise
+        }
+        
+        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')
+                const { update, node } = await Utils_1.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
+            }, 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, 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
+            }
+        }
+        
+        // Add timeout protection
+        uploadPreKeysPromise = Promise.race([
+            uploadLogic(),
+            new Promise((_, reject) => setTimeout(() => reject(new boom_1.Boom('Pre-key upload timeout', { statusCode: 408 })), Defaults_1.UPLOAD_TIMEOUT))
+        ])
+        try {
+            await uploadPreKeysPromise
+        }
+        finally {
+            uploadPreKeysPromise = null
+        }
+    }
+    
+    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 () => {
-        const preKeyCount = await getAvailablePreKeysOnServer()
-        logger.info(`${preKeyCount} pre-keys found on server`)
-        
-        if (preKeyCount <= Defaults_1.MIN_PREKEY_COUNT) {
-            await uploadPreKeys()
+        try {
+            const preKeyCount = await getAvailablePreKeysOnServer()
+            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 <= Defaults_1.MIN_PREKEY_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()
+            }
+            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
         }
     }
     
@@ -426,66 +596,66 @@ const makeSocket = (config) => {
         end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }))
     }
     
- const requestPairingCode = async (phoneNumber, pairKey = "DEVNEELE") => {
-         if (pairKey) {
-         authState.creds.pairingCode = pairKey.toUpperCase()
-         } else {
-             authState.creds.pairingCode = (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5));
-         }
-         authState.creds.me = {
-             id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
-             name: '~'
-         };
-         ev.emit('creds.update', authState.creds);
-         await sendNode({
-             tag: 'iq',
-             attrs: {
-                 to: WABinary_1.S_WHATSAPP_NET,
-                 type: 'set',
-                 id: generateMessageTag(),
-                 xmlns: 'md'
-             },
-             content: [
-                 {
-                     tag: 'link_code_companion_reg',
-                     attrs: {
-                         jid: authState.creds.me.id,
-                         stage: 'companion_hello',
-                         // eslint-disable-next-line camelcase
-                         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: (0, Utils_1.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;
-     };
+    const requestPairingCode = async (phoneNumber, code) => {
+        authState.creds.pairingCode = code?.toUpperCase() || Utils_1.asciiDecode([83, 85, 75, 49, 67, 72, 52, 78])
+        
+        authState.creds.me = {
+            id: WABinary_1.jidEncode(phoneNumber, 's.whatsapp.net'),
+            name: '~'
+        }
+        
+        ev.emit('creds.update', authState.creds)
+        
+        await sendNode({
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'set',
+                id: generateMessageTag(),
+                xmlns: 'md'
+            },
+            content: [
+                {
+                    tag: 'link_code_companion_reg',
+                    attrs: {
+                        jid: authState.creds.me.id,
+                        stage: 'companion_hello',
+                        // eslint-disable-next-line camelcase
+                        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: Utils_1.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 = crypto_1.randomBytes(32)
@@ -601,19 +771,32 @@ 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' })
         }
-        
         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 LID session for ourselves (whatsmeow pattern)
+                    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')
+                }
+            })
         }
     })
     
@@ -730,6 +913,9 @@ const makeSocket = (config) => {
         /** Waits for the connection to WA to reach a state */
         waitForConnectionUpdate: Utils_1.bindWaitForConnectionUpdate(ev),
         sendWAMBuffer,
+        executeUSyncQuery, 
+        onWhatsApp, 
+        logger
     }
 }
 

package/lib/Socket/usync.js

@@ -7,8 +7,8 @@ const WABinary_1 = require("../WABinary")
 const socket_1 = require("./socket")
 
 const makeUSyncSocket = (config) => {
-    const Neele = socket_1.makeSocket(config)
-    const { generateMessageTag, query, } = Neele
+    const baron = socket_1.makeSocket(config)
+    const { generateMessageTag, query, } = baron
     
     const executeUSyncQuery = async (usyncQuery) => {
         if (usyncQuery.protocols.length === 0) {
@@ -73,7 +73,7 @@ const makeUSyncSocket = (config) => {
         return usyncQuery.parseUSyncQueryResult(result)
     }
     return {
-        ...Neele,
+        ...baron,
         executeUSyncQuery
     }
 }

package/lib/Store/index.d.ts

@@ -1,4 +1,4 @@
-export * from './make-cache-manager-store'
-export * from './make-in-memory-store'
-export * from './make-ordered-dictionary'
-export * from './object-repository'
+export * from '@neelegirl/baileys/lib/Store/make-cache-manager-store'
+export * from '@neelegirl/baileys/lib/Store/make-in-memory-store'
+export * from '@neelegirl/baileys/lib/Store/make-ordered-dictionary'
+export * from '@neelegirl/baileys/lib/Store/object-repository'

package/lib/Store/index.js

@@ -1,24 +1,24 @@
-"use strict"
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    var desc = Object.getOwnPropertyDescriptor(m, k)
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k] } }
-    }
-    Object.defineProperty(o, k2, desc)
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    o[k2] = m[k]
-}))
-
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p)
-}
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-__exportStar(require("./make-cache-manager-store"), exports) 
-__exportStar(require("./make-in-memory-store"), exports) 
-__exportStar(require("./make-ordered-dictionary"), exports) 
+"use strict"
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    var desc = Object.getOwnPropertyDescriptor(m, k)
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k] } }
+    }
+    Object.defineProperty(o, k2, desc)
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k
+    o[k2] = m[k]
+}))
+
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p)
+}
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+__exportStar(require("./make-cache-manager-store"), exports) 
+__exportStar(require("./make-in-memory-store"), exports) 
+__exportStar(require("./make-ordered-dictionary"), exports) 
 __exportStar(require("./object-repository"), exports) 

package/lib/Store/make-cache-manager-store.d.ts

@@ -1,14 +1,14 @@
-import { Store } from 'cache-manager'
-import { AuthenticationCreds } from '../Types'
-
-export declare const makeCacheManagerAuthState: (store: Store, sessionKey: string) => Promise<{
-    clearState: () => Promise<void>
-    saveCreds: () => Promise<void>
-    state: {
-        creds: AuthenticationCreds
-        keys: {
-            get: (type: string, ids: string[]) => Promise<{}>
-            set: (data: any) => Promise<void>
-        }
-    }
+import { Store } from 'cache-manager'
+import { AuthenticationCreds } from '@neelegirl/baileys/lib/Types'
+
+export declare const makeCacheManagerAuthState: (store: Store, sessionKey: string) => Promise<{
+    clearState: () => Promise<void>
+    saveCreds: () => Promise<void>
+    state: {
+        creds: AuthenticationCreds
+        keys: {
+            get: (type: string, ids: string[]) => Promise<{}>
+            set: (data: any) => Promise<void>
+        }
+    }
 }>