@zervonex/baileys 0.0.0-stage → 3.0.1

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,283 @@
+import { LRUCache } from 'lru-cache'
+import { isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from '../WABinary/index.js'
+
+export class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new LRUCache({ ttl: 3 * 24 * 60 * 60 * 1000, ttlAutopurge: true, updateAgeOnGet: true })
+        this.inflightLIDLookups = new Map()
+        this.inflightPNLookups = new Map()
+        this.keys = keys
+        this.logger = logger
+        this.pnToLIDFunc = pnToLIDFunc
+    }
+
+    async storeLIDPNMappings(pairs) {
+        if (!pairs.length) return
+
+        const validatedPairs = []
+        for (const { lid, pn } of pairs) {
+            if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && isLidUser(pn)))) {
+                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`)
+                continue
+            }
+            const lidDecoded = jidDecode(lid)
+            const pnDecoded = jidDecode(pn)
+            if (!lidDecoded || !pnDecoded) continue // fixed: was `return`, skips only this pair
+            validatedPairs.push({ pnUser: pnDecoded.user, lidUser: lidDecoded.user })
+        }
+
+        if (!validatedPairs.length) return
+
+        // Batch check all cache misses in one DB call (forward AND reverse)
+        const cacheMissSet = new Set()
+        const existingMappings = new Map()
+        const existingReverse = new Map()
+
+        for (const { pnUser } of validatedPairs) {
+            const cached = this.mappingCache.get(`pn:${pnUser}`)
+            if (cached) existingMappings.set(pnUser, cached)
+            else cacheMissSet.add(pnUser)
+        }
+
+        if (cacheMissSet.size > 0) {
+            this.logger.trace(`Batch fetching ${cacheMissSet.size} LID mappings from database`)
+            const stored = await this.keys.get('lid-mapping', [...cacheMissSet])
+            for (const pnUser of cacheMissSet) {
+                const lidUser = stored[pnUser]
+                if (lidUser) {
+                    existingMappings.set(pnUser, lidUser)
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser)
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser)
+                }
+            }
+        }
+
+        // Separately verify the reverse entry actually exists on disk for every
+        // pair whose forward mapping we found — a forward file existing does NOT
+        // guarantee its `_reverse` sibling was ever written (e.g. when only the
+        // recipient side of a fromMe message was resolved, never the sender side).
+        const reverseKeysToCheck = []
+        for (const { pnUser, lidUser } of validatedPairs) {
+            if (existingMappings.get(pnUser) === lidUser) reverseKeysToCheck.push(`${lidUser}_reverse`)
+        }
+        if (reverseKeysToCheck.length) {
+            const storedReverse = await this.keys.get('lid-mapping', reverseKeysToCheck)
+            for (const key of reverseKeysToCheck) {
+                if (storedReverse[key]) existingReverse.set(key, storedReverse[key])
+            }
+        }
+
+        const pairMap = {}
+        for (const { pnUser, lidUser } of validatedPairs) {
+            const forwardExists = existingMappings.get(pnUser) === lidUser
+            const reverseExists = existingReverse.has(`${lidUser}_reverse`)
+            if (forwardExists && reverseExists) {
+                continue
+            }
+            if (forwardExists && !reverseExists) {
+                this.logger.debug({ pnUser, lidUser }, 'forward mapping exists but reverse is missing, repairing')
+            }
+            pairMap[pnUser] = lidUser
+        }
+        if (!Object.keys(pairMap).length) return
+
+        this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`)
+
+        // Single batched keys.set inside transaction
+        const batchData = {}
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            batchData[pnUser] = lidUser
+            batchData[`${lidUser}_reverse`] = pnUser
+        }
+
+        await this.keys.transaction(async () => {
+            await this.keys.set({ 'lid-mapping': batchData })
+        }, 'lid-mapping')
+
+        // Update cache only after successful DB write
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            this.mappingCache.set(`pn:${pnUser}`, lidUser)
+            this.mappingCache.set(`lid:${lidUser}`, pnUser)
+        }
+    }
+
+    async getLIDForPN(pn) {
+        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null
+    }
+
+    async getLIDsForPNs(pns) {
+        if (!pns.length) return null
+        const sortedPns = [...new Set(pns)].sort()
+        const cacheKey = sortedPns.join(',')
+
+        const inflight = this.inflightLIDLookups.get(cacheKey)
+        if (inflight) {
+            this.logger.trace(`Coalescing getLIDsForPNs for ${sortedPns.length} PNs`)
+            return inflight
+        }
+
+        const promise = this._getLIDsForPNsImpl(pns)
+        this.inflightLIDLookups.set(cacheKey, promise)
+        try {
+            return await promise
+        } finally {
+            this.inflightLIDLookups.delete(cacheKey)
+        }
+    }
+
+    async _getLIDsForPNsImpl(pns) {
+        const usyncFetch = {}
+        const successfulPairs = {}
+        const pending = []
+
+        const addResolvedPair = (pn, decoded, lidUser) => {
+            const normalizedLidUser = lidUser.toString()
+            if (!normalizedLidUser) {
+                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`)
+                return false
+            }
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0
+            const deviceSpecificLid = `${normalizedLidUser}${pnDevice ? `:${pnDevice}` : ''}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`
+            this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`)
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn }
+            return true
+        }
+
+        for (const pn of pns) {
+            if (!isPnUser(pn) && !isHostedPnUser(pn)) continue
+            const decoded = jidDecode(pn)
+            if (!decoded) continue
+            const pnUser = decoded.user
+            const cached = this.mappingCache.get(`pn:${pnUser}`)
+            if (cached) {
+                addResolvedPair(pn, decoded, cached)
+            } else {
+                pending.push({ pn, pnUser, decoded })
+            }
+        }
+
+        if (pending.length) {
+            // Single batched DB fetch for all cache misses
+            const pnUsers = [...new Set(pending.map(p => p.pnUser))]
+            const stored = await this.keys.get('lid-mapping', pnUsers)
+
+            for (const pnUser of pnUsers) {
+                const lidUser = stored[pnUser]
+                if (lidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser)
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser)
+                }
+            }
+
+            for (const { pn, pnUser, decoded } of pending) {
+                const cached = this.mappingCache.get(`pn:${pnUser}`)
+                if (cached) {
+                    addResolvedPair(pn, decoded, cached)
+                } else {
+                    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)
+                }
+            }
+        }
+
+        if (Object.keys(usyncFetch).length > 0) {
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch))
+            if (result?.length > 0) {
+                await this.storeLIDPNMappings(result) // fixed: was fire-and-forget
+                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'}`
+                        const deviceSpecificPn = `${pnUser}${device ? `:${device}` : ''}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`
+                        this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`)
+                        successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn }
+                    }
+                }
+            } else {
+                return null
+            }
+        }
+
+        return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null
+    }
+
+    async getPNForLID(lid) {
+        return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null
+    }
+
+    async getPNsForLIDs(lids) {
+        if (!lids.length) return null
+        const sortedLids = [...new Set(lids)].sort()
+        const cacheKey = sortedLids.join(',')
+
+        const inflight = this.inflightPNLookups.get(cacheKey)
+        if (inflight) {
+            this.logger.trace(`Coalescing getPNsForLIDs for ${sortedLids.length} LIDs`)
+            return inflight
+        }
+
+        const promise = this._getPNsForLIDsImpl(lids)
+        this.inflightPNLookups.set(cacheKey, promise)
+        try {
+            return await promise
+        } finally {
+            this.inflightPNLookups.delete(cacheKey)
+        }
+    }
+
+    async _getPNsForLIDsImpl(lids) {
+        const successfulPairs = {}
+        const pending = []
+
+        const addResolvedPair = (lid, decoded, pnUser) => {
+            if (!pnUser || typeof pnUser !== 'string') return false
+            const lidDevice = decoded.device !== undefined ? decoded.device : 0
+            const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`
+            this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`)
+            successfulPairs[lid] = { lid, pn: pnJid }
+            return true
+        }
+
+        for (const lid of lids) {
+            if (!isLidUser(lid)) continue
+            const decoded = jidDecode(lid)
+            if (!decoded) continue
+            const lidUser = decoded.user
+            const cached = this.mappingCache.get(`lid:${lidUser}`)
+            if (cached) {
+                addResolvedPair(lid, decoded, cached)
+            } else {
+                pending.push({ lid, lidUser, decoded })
+            }
+        }
+
+        if (pending.length) {
+            // Single batched DB fetch for all cache misses
+            const reverseKeys = [...new Set(pending.map(p => `${p.lidUser}_reverse`))]
+            const stored = await this.keys.get('lid-mapping', reverseKeys)
+
+            for (const { lid, lidUser, decoded } of pending) {
+                let pnUser = this.mappingCache.get(`lid:${lidUser}`)
+                if (!pnUser || typeof pnUser !== 'string') {
+                    pnUser = stored[`${lidUser}_reverse`]
+                    if (pnUser && typeof pnUser === 'string') {
+                        this.mappingCache.set(`lid:${lidUser}`, pnUser)
+                        this.mappingCache.set(`pn:${pnUser}`, lidUser)
+                    }
+                }
+                if (pnUser) addResolvedPair(lid, decoded, pnUser)
+                else this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`)
+            }
+        }
+
+        return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null
+    }
+}

package/lib/Socket/Client/index.js

@@ -0,0 +1,2 @@
+export * from './types.js'
+export * from './websocket.js'

package/lib/Socket/Client/types.js

@@ -0,0 +1,10 @@
+import { EventEmitter } from 'events'
+
+export class AbstractSocketClient extends EventEmitter {
+    constructor(url, config) {
+        super()
+        this.url = url
+        this.config = config
+        this.setMaxListeners(0)
+    }
+}

package/lib/Socket/Client/websocket.js

@@ -0,0 +1,84 @@
+import WebSocket from 'ws'
+import { DEFAULT_ORIGIN } from '../../Defaults/index.js'
+import { AbstractSocketClient } from './types.js'
+
+const MAX_CONNECT_RETRIES = 5
+const BASE_RETRY_DELAY = 1000
+
+export class WebSocketClient extends AbstractSocketClient {
+  constructor() {
+    super(...arguments)
+    this.socket = null
+    this._connectRetries = 0
+    this._connectTimer = null
+    this._dead = false
+  }
+
+  get isOpen() { return this.socket?.readyState === WebSocket.OPEN }
+  get isClosed() { return this.socket === null || this.socket?.readyState === WebSocket.CLOSED }
+  get isClosing() { return this.socket === null || this.socket?.readyState === WebSocket.CLOSING }
+  get isConnecting() { return this.socket?.readyState === WebSocket.CONNECTING }
+
+  connect() {
+    if (this.socket || this._dead) return
+    this._tryConnect()
+  }
+
+  _tryConnect() {
+    if (this._dead) return
+    let didOpen = false
+    this.socket = new WebSocket(this.url, {
+      origin: DEFAULT_ORIGIN,
+      headers: this.config.options?.headers,
+      handshakeTimeout: this.config.connectTimeoutMs,
+      timeout: this.config.connectTimeoutMs,
+      agent: this.config.agent,
+      family: 4,
+    })
+    this.socket.setMaxListeners(0)
+
+    for (const event of ['close', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response']) {
+      this.socket.on(event, (...args) => this.emit(event, ...args))
+    }
+
+    this.socket.once('open', () => {
+      didOpen = true
+      this._connectRetries = 0
+    })
+
+    this.socket.on('error', (err) => {
+      const isConnectError = !didOpen && ['ETIMEDOUT', 'ECONNREFUSED', 'ENETUNREACH', 'ENOTFOUND', 'EAI_AGAIN'].includes(err.code)
+      if (isConnectError && this._connectRetries < MAX_CONNECT_RETRIES) {
+        this._connectRetries++
+        const delay = Math.min(BASE_RETRY_DELAY * Math.pow(2, this._connectRetries - 1), 30000)
+        this.socket = null
+        this._connectTimer = setTimeout(() => this._tryConnect(), delay)
+      } else {
+        this.emit('error', err)
+      }
+    })
+  }
+
+  async close() {
+    this._dead = true
+    clearTimeout(this._connectTimer)
+    if (!this.socket) return
+    const closePromise = new Promise(resolve => { this.socket?.once('close', resolve) })
+    this.socket.close()
+    await closePromise
+    this.socket = null
+  }
+
+  reset() {
+    this._dead = false
+    this._connectRetries = 0
+    clearTimeout(this._connectTimer)
+  }
+
+  send(str, cb) {
+    this.socket?.send(str, cb)
+    return Boolean(this.socket)
+  }
+}
+
+export default WebSocketClient

package/lib/Socket/business.js

@@ -0,0 +1,152 @@
+import { parseCatalogNode, getRawMediaUploadData, parseCollectionsNode, parseOrderDetailsNode, parseProductNode, toProductNode, uploadingNecessaryImagesOfProduct } from '../Utils/index.js'
+import { jidNormalizedUser, S_WHATSAPP_NET, getBinaryNodeChild } from '../WABinary/index.js'
+import { makeMessagesRecvSocket } from './messages-recv.js'
+
+export const makeBusinessSocket = (config) => {
+    const sock = makeMessagesRecvSocket(config)
+    const { authState, query, waUploadToServer } = sock
+
+    const updateBussinesProfile = async (args) => {
+        const node = []
+        for (const key of ['address', 'email', 'description']) {
+            if (args[key]) node.push({ tag: key, attrs: {}, content: args[key] })
+        }
+        if (args.websites) {
+            node.push(...args.websites.map(website => ({ tag: 'website', attrs: {}, content: website })))
+        }
+        if (args.hours) {
+            node.push({
+                tag: 'business_hours',
+                attrs: { timezone: args.hours.timezone },
+                content: args.hours.days.map(cfg => {
+                    const base = { tag: 'business_hours_config', attrs: { day_of_week: cfg.day, mode: cfg.mode } }
+                    if (cfg.mode === 'specific_hours') {
+                        return { ...base, attrs: { ...base.attrs, open_time: cfg.openTimeInMinutes, close_time: cfg.closeTimeInMinutes } }
+                    }
+                    return base
+                })
+            })
+        }
+        return query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:biz' },
+            content: [{ tag: 'business_profile', attrs: { v: '3', mutation_type: 'delta' }, content: node }]
+        })
+    }
+
+    const updateCoverPhoto = async (photo) => {
+        const { fileSha256, filePath } = await getRawMediaUploadData(photo, 'biz-cover-photo')
+        const { meta_hmac, fbid, ts } = await waUploadToServer(filePath, {
+            fileEncSha256B64: fileSha256.toString('base64'),
+            mediaType: 'biz-cover-photo'
+        })
+        await query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:biz' },
+            content: [{ tag: 'business_profile', attrs: { v: '3', mutation_type: 'delta' }, content: [{ tag: 'cover_photo', attrs: { id: String(fbid), op: 'update', token: meta_hmac, ts: String(ts) } }] }]
+        })
+        return fbid
+    }
+
+    const removeCoverPhoto = async (id) =>
+        query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:biz' },
+            content: [{ tag: 'business_profile', attrs: { v: '3', mutation_type: 'delta' }, content: [{ tag: 'cover_photo', attrs: { op: 'delete', id } }] }]
+        })
+
+    const getCatalog = async ({ jid, limit, cursor } = {}) => {
+        jid = jidNormalizedUser(jid || authState.creds.me?.id)
+        const queryParamNodes = [
+            { tag: 'limit', attrs: {}, content: Buffer.from((limit || 10).toString()) },
+            { tag: 'width', attrs: {}, content: Buffer.from('100') },
+            { tag: 'height', attrs: {}, content: Buffer.from('100') }
+        ]
+        if (cursor) queryParamNodes.push({ tag: 'after', attrs: {}, content: cursor })
+        const result = await query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'get', xmlns: 'w:biz:catalog' },
+            content: [{ tag: 'product_catalog', attrs: { jid, allow_shop_source: 'true' }, content: queryParamNodes }]
+        })
+        return parseCatalogNode(result)
+    }
+
+    const getCollections = async (jid, limit = 51) => {
+        jid = jidNormalizedUser(jid || authState.creds.me?.id)
+        const result = await query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'get', xmlns: 'w:biz:catalog', smax_id: '35' },
+            content: [{
+                tag: 'collections',
+                attrs: { biz_jid: jid },
+                content: [
+                    { tag: 'collection_limit', attrs: {}, content: Buffer.from(limit.toString()) },
+                    { tag: 'item_limit', attrs: {}, content: Buffer.from(limit.toString()) },
+                    { tag: 'width', attrs: {}, content: Buffer.from('100') },
+                    { tag: 'height', attrs: {}, content: Buffer.from('100') }
+                ]
+            }]
+        })
+        return parseCollectionsNode(result)
+    }
+
+    const getOrderDetails = async (orderId, tokenBase64) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'get', xmlns: 'fb:thrift_iq', smax_id: '5' },
+            content: [{
+                tag: 'order',
+                attrs: { op: 'get', id: orderId },
+                content: [
+                    { tag: 'image_dimensions', attrs: {}, content: [{ tag: 'width', attrs: {}, content: Buffer.from('100') }, { tag: 'height', attrs: {}, content: Buffer.from('100') }] },
+                    { tag: 'token', attrs: {}, content: Buffer.from(tokenBase64) }
+                ]
+            }]
+        })
+        return parseOrderDetailsNode(result)
+    }
+
+    const productUpdate = async (productId, update) => {
+        update = await uploadingNecessaryImagesOfProduct(update, waUploadToServer)
+        const result = await query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:biz:catalog' },
+            content: [{ tag: 'product_catalog_edit', attrs: { v: '1' }, content: [toProductNode(productId, update), { tag: 'width', attrs: {}, content: '100' }, { tag: 'height', attrs: {}, content: '100' }] }]
+        })
+        return parseProductNode(getBinaryNodeChild(getBinaryNodeChild(result, 'product_catalog_edit'), 'product'))
+    }
+
+    const productCreate = async (create) => {
+        create.isHidden = !!create.isHidden
+        create = await uploadingNecessaryImagesOfProduct(create, waUploadToServer)
+        const result = await query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:biz:catalog' },
+            content: [{ tag: 'product_catalog_add', attrs: { v: '1' }, content: [toProductNode(undefined, create), { tag: 'width', attrs: {}, content: '100' }, { tag: 'height', attrs: {}, content: '100' }] }]
+        })
+        return parseProductNode(getBinaryNodeChild(getBinaryNodeChild(result, 'product_catalog_add'), 'product'))
+    }
+
+    const productDelete = async (productIds) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:biz:catalog' },
+            content: [{ tag: 'product_catalog_delete', attrs: { v: '1' }, content: productIds.map(id => ({ tag: 'product', attrs: {}, content: [{ tag: 'id', attrs: {}, content: Buffer.from(id) }] })) }]
+        })
+        return { deleted: +(getBinaryNodeChild(result, 'product_catalog_delete')?.attrs.deleted_count || 0) }
+    }
+
+    return {
+        ...sock,
+        logger: config.logger,
+        getOrderDetails,
+        getCatalog,
+        getCollections,
+        productCreate,
+        productDelete,
+        productUpdate,
+        updateBussinesProfile,
+        updateCoverPhoto,
+        removeCoverPhoto
+    }
+}