@hansaka02/baileys 7.3.2 → 7.3.6

package/lib/Signal/lid-mapping.js

@@ -2,47 +2,54 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const lru_cache_1 = require("lru-cache")
-const WABinary_1 = require("../WABinary")
+const { LRUCache } = require("lru-cache")
+const { 
+  isHostedPnUser, 
+  isLidUser, 
+  isPnUser, 
+  jidDecode, 
+  jidNormalizedUser, 
+  WAJIDDomains 
+} = require("../WABinary")
 
 class LIDMappingStore {
-	constructor(keys, onWhatsAppFunc, logger) {
-		this.mappingCache = new lru_cache_1.LRUCache({
-            ttl: 7 * 24 * 60 * 60 * 1000, // 7 days
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1000, // 7 days
             ttlAutopurge: true,
             updateAgeOnGet: true
         })
-		this.keys = keys
-		this.logger = logger
-		this.onWhatsAppFunc = onWhatsAppFunc // needed to get LID from PN if not found
-	}
-	/**
+        this.keys = keys
+        this.pnToLIDFunc = pnToLIDFunc
+        this.logger = logger
+    }
+    
+    /**
      * Store LID-PN mapping - USER LEVEL
      */
     async storeLIDPNMappings(pairs) {
         // Validate inputs
         const pairMap = {}
-        const logger = this.logger
         
         for (const { lid, pn } of pairs) {
-            if (!((WABinary_1.isLidUser(lid) && WABinary_1.isJidUser(pn)) || (WABinary_1.isJidUser(lid) && WABinary_1.isLidUser(pn)))) {
-                logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`)
+            if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && isLidUser(pn)))) {
+                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`)
                 continue
             }
             
-            const lidDecoded = WABinary_1.jidDecode(lid)
-            const pnDecoded = WABinary_1.jidDecode(pn)
+            const lidDecoded = jidDecode(lid)
+            const pnDecoded = jidDecode(pn)
             
             if (!lidDecoded || !pnDecoded) return
             
             const pnUser = pnDecoded.user
             const lidUser = lidDecoded.user
             
-            // Check if mapping already exists (cache first, then database)
             let existingLidUser = this.mappingCache.get(`pn:${pnUser}`)
             
             if (!existingLidUser) {
-                // Cache miss - check database
+                this.logger.trace(`Cache miss for PN user ${pnUser}; checking database`)
+                
                 const stored = await this.keys.get('lid-mapping', [pnUser])
                 
                 existingLidUser = stored[pnUser]
@@ -55,102 +62,150 @@ class LIDMappingStore {
             }
             
             if (existingLidUser === lidUser) {
-                logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping')
+                this.logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping')
                 continue
             }
             
             pairMap[pnUser] = lidUser
         }
         
-        logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`)
+        this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`)
         
         await this.keys.transaction(async () => {
             for (const [pnUser, lidUser] of Object.entries(pairMap)) {
                 await this.keys.set({
                     'lid-mapping': {
-                        [pnUser]: lidUser, // "554396160286" -> "102765716062358"
-                        [`${lidUser}_reverse`]: pnUser // "102765716062358_reverse" -> "554396160286"
+                        [pnUser]: lidUser,
+                        [`${lidUser}_reverse`]: pnUser
                     }
                 })
                 
-                // Update cache with both directions
                 this.mappingCache.set(`pn:${pnUser}`, lidUser)
                 this.mappingCache.set(`lid:${lidUser}`, pnUser)
             }
         }, 'lid-mapping')
     }
+    
     /**
      * Get LID for PN - Returns device-specific LID based on user mapping
      */
     async getLIDForPN(pn) {
-        if (!WABinary_1.isJidUser(pn)) return null
-        
-        const logger = this.logger
-        const decoded = WABinary_1.jidDecode(pn)
-        
-        if (!decoded) return null
-        
-        // Check cache first for PN → LID mapping
-        const pnUser = decoded.user
+        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null
+    }
+    
+    async getLIDsForPNs(pns) {
+        const usyncFetch = {}
         
-        let lidUser = this.mappingCache.get(`pn:${pnUser}`)
+        // mapped from pn to lid mapping to prevent duplication in results later
+        const successfulPairs = {}
         
-        if (!lidUser) {
-            // Cache miss - check database
-            const stored = await this.keys.get('lid-mapping', [pnUser])
+        for (const pn of pns) {
+            if (!isPnUser(pn) && !isHostedPnUser(pn)) continue
             
-            lidUser = stored[pnUser]
+            const decoded = jidDecode(pn)
+            if (!decoded) continue
             
-            if (lidUser) {
-                // Cache the database result
-                this.mappingCache.set(`pn:${pnUser}`, lidUser)
-            }
+            // Check cache first for PN → LID mapping
+            const pnUser = decoded.user
             
-            else {
-                // Not in database - try USync
-                logger.trace(`No LID mapping found for PN user ${pnUser}; getting from USync`)
+            let lidUser = this.mappingCache.get(`pn:${pnUser}`)
+            
+            if (!lidUser) {
+                // Cache miss - check database
+                const stored = await this.keys.get('lid-mapping', [pnUser])
                 
-                const { exists, lid } = (await this.onWhatsAppFunc?.(pn))?.[0] // this function already adds LIDs to mapping
+                lidUser = stored[pnUser]
                 
-                if (exists && lid) {
-                    lidUser = WABinary_1.jidDecode(lid)?.user
-                    
-                    if (lidUser) {
-                        // Cache the USync result
-                        this.mappingCache.set(`pn:${pnUser}`, lidUser)
-                    }
+                if (lidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser)
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser)
                 }
                 
                 else {
-                    return null
+                    this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`)
+                    
+                    const device = decoded.device || 0
+                    
+                    let normalizedPn = jidNormalizedUser(pn)
+                    
+                    if (isHostedPnUser(normalizedPn)) {
+                        normalizedPn = `${pnUser}@s.whatsapp.net`
+                    }
+                    
+                    if (!usyncFetch[normalizedPn]) {
+                        usyncFetch[normalizedPn] = [device]
+                    }
+                    
+                    else {
+                        usyncFetch[normalizedPn]?.push(device)
+                    }
+                    
+                    continue
                 }
             }
+            
+            lidUser = lidUser.toString()
+            
+            if (!lidUser) {
+                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`)
+                return null
+            }
+            
+            // Push the PN device ID to the LID to maintain device separation
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0
+            const deviceSpecificLid = `${lidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`
+            
+            this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`)
+            
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn }
         }
         
-        if (typeof lidUser !== 'string' || !lidUser) {
-            logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`)
-            return null
+        if (Object.keys(usyncFetch).length > 0) {
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch)) // this function already adds LIDs to mapping
+            
+            if (result && result.length > 0) {
+                await this.storeLIDPNMappings(result)
+                
+                for (const pair of result) {
+                    const pnDecoded = jidDecode(pair.pn)
+                    const pnUser = pnDecoded?.user
+                    
+                    if (!pnUser) continue
+                    
+                    const lidUser = jidDecode(pair.lid)?.user
+                    
+                    if (!lidUser) continue
+                    
+                    for (const device of usyncFetch[pair.pn]) {
+                        const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted.lid' : 'lid'}`
+                        
+                        this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`)
+                        
+                        const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`
+                        
+                        successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn }
+                    }
+                }
+            }
+            
+            else {
+                return null
+            }
         }
         
-        // Push the PN device ID to the LID to maintain device separation
-        const pnDevice = decoded.device !== undefined ? decoded.device : 0
-        const deviceSpecificLid = `${lidUser}:${pnDevice}@lid`
-        
-        logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`)
-        
-        return deviceSpecificLid
+        return Object.values(successfulPairs)
     }
+    
     /**
      * Get PN for LID - USER LEVEL with device construction
      */
      async getPNForLID(lid) {
-        if (!WABinary_1.isLidUser(lid)) return null
-        
-        const logger = this.logger
-        const decoded = WABinary_1.jidDecode(lid)
+        if (!isLidUser(lid)) return null
+            
+        const decoded = jidDecode(lid)
         
         if (!decoded) return null
-        
+            
         // Check cache first for LID → PN mapping
         const lidUser = decoded.user
         
@@ -158,11 +213,12 @@ class LIDMappingStore {
         
         if (!pnUser || typeof pnUser !== 'string') {
             // Cache miss - check database
-            const stored = await this.keys.get('lid-mapping', [`${lidUser}_reverse`]);
+            const stored = await this.keys.get('lid-mapping', [`${lidUser}_reverse`])
+            
             pnUser = stored[`${lidUser}_reverse`]
             
             if (!pnUser || typeof pnUser !== 'string') {
-                logger.trace(`No reverse mapping found for LID user: ${lidUser}`)
+                this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`)
                 return null
             }
             
@@ -171,8 +227,9 @@ class LIDMappingStore {
         
         // Construct device-specific PN JID
         const lidDevice = decoded.device !== undefined ? decoded.device : 0
-        const pnJid = `${pnUser}:${lidDevice}@s.whatsapp.net`
-        logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`)
+        const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`
+        
+        this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`)
         
         return pnJid
     }

package/lib/Socket/Client/types.js

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const events_1 = require("events")
+const { EventEmitter } = require("events")
 
-class AbstractSocketClient extends events_1.EventEmitter {
+class AbstractSocketClient extends EventEmitter {
     constructor(url, config) {
         super()
         this.url = url

package/lib/Socket/Client/websocket.js

@@ -1,38 +1,45 @@
 "use strict"
 
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod }
-}
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const ws_1 = __importDefault(require("ws"))
-const Defaults_1 = require("../../Defaults")
-const types_1 = require("./types")
+const {
+  OPEN, 
+  CLOSED, 
+  CLOSING, 
+  CONNECTING, 
+  WebSocket
+} = require("ws")
+const { DEFAULT_ORIGIN } = require("../../Defaults/constants")
+const { AbstractSocketClient } = require("./types")
 
-class WebSocketClient extends types_1.AbstractSocketClient {
+class WebSocketClient extends AbstractSocketClient {
     constructor() {
         super(...arguments)
         this.socket = null
     }
+    
     get isOpen() {
-        return this.socket?.readyState === ws_1.default.OPEN
+        return this.socket?.readyState === OPEN
     }
+    
     get isClosed() {
-        return this.socket?.readyState === ws_1.default.CLOSED
+        return this.socket?.readyState === CLOSED
     }
+    
     get isClosing() {
-        this.socket?.readyState === ws_1.default.CLOSING
+        this.socket?.readyState === CLOSING
     }
+    
     get isConnecting() {
-        this.socket?.readyState === ws_1.default.CONNECTING
+        this.socket?.readyState === CONNECTING
     }
-    async connect() {
+    
+    connect() {
         if (this.socket) {
             return
         }
-        this.socket = new ws_1.default(this.url, {
-            origin: Defaults_1.DEFAULT_ORIGIN,
+        this.socket = new WebSocket(this.url, {
+            origin: DEFAULT_ORIGIN,
             headers: this.config.options?.headers,
             handshakeTimeout: this.config.connectTimeoutMs,
             timeout: this.config.connectTimeoutMs,
@@ -44,13 +51,15 @@ class WebSocketClient extends types_1.AbstractSocketClient {
             this.socket?.on(event, (...args) => this.emit(event, ...args))
         }
     }
-    async close() {
+    
+    close() {
         if (!this.socket) {
             return
         }
         this.socket.close()
         this.socket = null
     }
+    
     send(str, cb) {
         this.socket?.send(str, cb)
         return Boolean(this.socket)

package/lib/Socket/business.js

@@ -2,15 +2,28 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const Utils_1 = require("../Utils")
-const WABinary_1 = require("../WABinary")
-const business_1 = require("../Utils/business")
-const generic_utils_1 = require("../WABinary/generic-utils")
-const messages_recv_1 = require("./messages-recv")
+const {
+  toProductNode, 
+  parseCatalogNode, 
+  parseCollectionsNode, 
+  parseOrderDetailsNode, 
+  getRawMediaUploadData, 
+  uploadingNecessaryImagesOfProduct
+} = require("../Utils")
+const {
+  S_WHATSAPP_NET, 
+  jidNormalizedUser, 
+  getBinaryNodeChild
+} = require("../WABinary")
+const { makeMessagesRecvSocket } = require("./messages-recv")
 
 const makeBusinessSocket = (config) => {
-    const suki = messages_recv_1.makeMessagesRecvSocket(config)
-    const { authState, query, waUploadToServer } = suki
+    const suki = makeMessagesRecvSocket(config)
+    const { 
+        authState, 
+        query, 
+        waUploadToServer 
+    } = suki
     
     const updateBussinesProfile = async (args) => {
         const node = []
@@ -63,7 +76,7 @@ const makeBusinessSocket = (config) => {
         const result = await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
                 xmlns: 'w:biz'
             },
@@ -83,7 +96,7 @@ const makeBusinessSocket = (config) => {
     }
     
     const updateCoverPhoto = async (photo) => {
-        const { fileSha256, filePath } = await Utils_1.getRawMediaUploadData(photo, 'biz-cover-photo')
+        const { fileSha256, filePath } = await getRawMediaUploadData(photo, 'biz-cover-photo')
         const fileSha256B64 = fileSha256.toString('base64')
         
         const { meta_hmac, fbid, ts } = await waUploadToServer(filePath, {
@@ -94,7 +107,7 @@ const makeBusinessSocket = (config) => {
         await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
                 xmlns: 'w:biz'
             },
@@ -122,7 +135,7 @@ const makeBusinessSocket = (config) => {
         return await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
                 xmlns: 'w:biz'
             },
@@ -146,7 +159,7 @@ const makeBusinessSocket = (config) => {
     
     const getCatalog = async ({ jid, limit, cursor }) => {
         jid = jid || authState.creds.me?.id
-        jid = WABinary_1.jidNormalizedUser(jid)
+        jid = jidNormalizedUser(jid)
         
         const queryParamNodes = [
             {
@@ -177,7 +190,7 @@ const makeBusinessSocket = (config) => {
         const result = await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'get',
                 xmlns: 'w:biz:catalog'
             },
@@ -193,17 +206,17 @@ const makeBusinessSocket = (config) => {
             ]
         })
         
-        return business_1.parseCatalogNode(result)
+        return parseCatalogNode(result)
     }
     
     const getCollections = async (jid, limit = 51) => {
         jid = jid || authState.creds.me?.id
-        jid = WABinary_1.jidNormalizedUser(jid)
+        jid = jidNormalizedUser(jid)
         
         const result = await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'get',
                 xmlns: 'w:biz:catalog',
                 'smax_id': '35'
@@ -240,14 +253,14 @@ const makeBusinessSocket = (config) => {
             ]
         })
         
-        return business_1.parseCollectionsNode(result)
+        return parseCollectionsNode(result)
     }
     
     const getOrderDetails = async (orderId, tokenBase64) => {
         const result = await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'get',
                 xmlns: 'fb:thrift_iq',
                 'smax_id': '5'
@@ -286,17 +299,17 @@ const makeBusinessSocket = (config) => {
             ]
         })
         
-        return business_1.parseOrderDetailsNode(result)
+        return parseOrderDetailsNode(result)
     }
     
     const productUpdate = async (productId, update) => {
-        update = await business_1.uploadingNecessaryImagesOfProduct(update, waUploadToServer)
-        const editNode = business_1.toProductNode(productId, update)
+        update = await uploadingNecessaryImagesOfProduct(update, waUploadToServer)
+        const editNode = toProductNode(productId, update)
         
         const result = await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
                 xmlns: 'w:biz:catalog'
             },
@@ -320,21 +333,21 @@ const makeBusinessSocket = (config) => {
                 }
             ]
         })
-        const productCatalogEditNode = generic_utils_1.getBinaryNodeChild(result, 'product_catalog_edit')
-        const productNode = generic_utils_1.getBinaryNodeChild(productCatalogEditNode, 'product')
-        return business_1.parseProductNode(productNode)
+        const productCatalogEditNode = getBinaryNodeChild(result, 'product_catalog_edit')
+        const productNode = getBinaryNodeChild(productCatalogEditNode, 'product')
+        return parseProductNode(productNode)
     }
     
     const productCreate = async (create) => {
         // ensure isHidden is defined
         create.isHidden = !!create.isHidden
-        create = await business_1.uploadingNecessaryImagesOfProduct(create, waUploadToServer)
-        const createNode = business_1.toProductNode(undefined, create)
+        create = await uploadingNecessaryImagesOfProduct(create, waUploadToServer)
+        const createNode = toProductNode(undefined, create)
         
         const result = await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
                 xmlns: 'w:biz:catalog'
             },
@@ -358,17 +371,17 @@ const makeBusinessSocket = (config) => {
                 }
             ]
         })
-        const productCatalogAddNode = generic_utils_1.getBinaryNodeChild(result, 'product_catalog_add')
-        const productNode = generic_utils_1.getBinaryNodeChild(productCatalogAddNode, 'product')
+        const productCatalogAddNode = getBinaryNodeChild(result, 'product_catalog_add')
+        const productNode = getBinaryNodeChild(productCatalogAddNode, 'product')
         
-        return business_1.parseProductNode(productNode)
+        return parseProductNode(productNode)
     }
     
     const productDelete = async (productIds) => {
         const result = await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
                 xmlns: 'w:biz:catalog'
             },
@@ -390,7 +403,7 @@ const makeBusinessSocket = (config) => {
                 }
             ]
         })
-        const productCatalogDelNode = generic_utils_1.getBinaryNodeChild(result, 'product_catalog_delete')
+        const productCatalogDelNode = getBinaryNodeChild(result, 'product_catalog_delete')
         return {
             deleted: +(productCatalogDelNode?.attrs?.deleted_count || 0) 
         }