@areumtecnologia/wasockets 2.0.0 → 2.2.3

package/lib/Defaults/baileys-version.json

@@ -1,3 +1,3 @@
 {
-    "version": [2, 3000, 1030831524]
+    "version": [2, 3000, 1051853749]
 }

package/lib/Defaults/connection.js

@@ -7,6 +7,19 @@ const { default: logger } = require("../Utils/logger")
 const { makeLibSignalRepository } = require("../Signal/libsignal")
 const { version } = require("./baileys-version.json")
 
+let defaultWaVersion = version
+try {
+    const pkg = require("../../package.json")
+    if (typeof pkg.whatsappVersion === 'string') {
+        const parts = pkg.whatsappVersion.split('.').map(Number)
+        if (parts.length === 3 && parts.every(n => !isNaN(n))) {
+            defaultWaVersion = parts
+        }
+    } else if (Array.isArray(pkg.whatsappVersion) && pkg.whatsappVersion.length === 3) {
+        defaultWaVersion = pkg.whatsappVersion.map(Number)
+    }
+} catch {}
+
 const createGroupMetadataCache = (ttlMs = 300000, maxSize = 250) => {
     const cache = new Map()
 
@@ -35,7 +48,7 @@ const createGroupMetadataCache = (ttlMs = 300000, maxSize = 250) => {
 }
 
 const DEFAULT_CONNECTION_CONFIG = {
-    version, 
+    version: defaultWaVersion, 
     browser: Browsers.windows('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
     connectTimeoutMs: 20000,

package/lib/Socket/index.js

@@ -1,48 +1,51 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const { DEFAULT_CONNECTION_CONFIG, createGroupMetadataCache } = require("../Defaults/connection")
-const { makeCommunitiesSocket } = require("./community")
-const { PluginManager } = require("../Plugins")
-
-// export the last socket layer
-const makeWASocket = (config = {}) => {
-	const newConfig = {
-    	...DEFAULT_CONNECTION_CONFIG,
-   	 ...config
-    }
-    
-    // If the user hasn't provided their own history sync function,
-    // let's create a default one that respects the syncFullHistory flag.
-    if (config.shouldSyncHistoryMessage === undefined) {
-        newConfig.shouldSyncHistoryMessage = () => !!newConfig.syncFullHistory
-    }
-
-    if (!config.cachedGroupMetadata && newConfig.enableGroupCache) {
-        newConfig.cachedGroupMetadata = createGroupMetadataCache()
-    }
-
-    const sock = makeCommunitiesSocket(newConfig)
-    const pluginManager = new PluginManager(sock)
-
-    sock.plugins = pluginManager
-    sock.use = (plugin, options) => {
-        pluginManager.use(plugin, options)
-        return sock
-    }
-    sock.registerMiddleware = (hook, fn) => pluginManager.registerMiddleware(hook, fn)
-    sock.hasPlugin = (name) => pluginManager.hasPlugin(name)
-    sock.listPlugins = () => pluginManager.listPlugins()
-
-    // Auto-install plugins passed in configuration
-    if (Array.isArray(config.plugins)) {
-        for (const p of config.plugins) {
-            sock.use(p)
-        }
-    }
-
-    return sock
-}
-
-exports.default = makeWASocket
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { DEFAULT_CONNECTION_CONFIG, createGroupMetadataCache } = require("../Defaults/connection")
+const { makeCommunitiesSocket } = require("./community")
+const { PluginManager } = require("../Plugins")
+const { makeVoipSocket } = require("./voip")
+
+// export the last socket layer
+const makeWASocket = (config = {}) => {
+	const newConfig = {
+    	...DEFAULT_CONNECTION_CONFIG,
+   	 ...config
+    }
+    
+    // If the user hasn't provided their own history sync function,
+    // let's create a default one that respects the syncFullHistory flag.
+    if (config.shouldSyncHistoryMessage === undefined) {
+        newConfig.shouldSyncHistoryMessage = () => !!newConfig.syncFullHistory
+    }
+
+    if (!config.cachedGroupMetadata && newConfig.enableGroupCache) {
+        newConfig.cachedGroupMetadata = createGroupMetadataCache()
+    }
+
+    const baseSock = makeCommunitiesSocket(newConfig)
+    const sock = makeVoipSocket(newConfig, baseSock)
+    const pluginManager = new PluginManager(sock)
+
+    sock.plugins = pluginManager
+    sock.use = (plugin, options) => {
+        pluginManager.use(plugin, options)
+        return sock
+    }
+    sock.registerMiddleware = (hook, fn) => pluginManager.registerMiddleware(hook, fn)
+    sock.hasPlugin = (name) => pluginManager.hasPlugin(name)
+    sock.listPlugins = () => pluginManager.listPlugins()
+
+    // Auto-install plugins passed in configuration
+    if (Array.isArray(config.plugins)) {
+        for (const p of config.plugins) {
+            sock.use(p)
+        }
+    }
+
+    return sock
+}
+
+exports.default = makeWASocket
+exports.makeWASocket = makeWASocket

package/lib/Socket/messages-recv.js

@@ -273,15 +273,34 @@ const makeMessagesRecvSocket = (config) => {
                 }],
         })
         
-        await query(stanza)
+        await sendNode(stanza)
         
         return {
             id: callId,
-            to: toJid
+            to: toJid,
+            callKey: encKey
         }
     }
     
-    const rejectCall = async (callId, callFrom) => {
+    const getVoIPRelayTokens = async () => {
+        const stanza = {
+            tag: 'iq',
+            attrs: {
+                id: generateMessageID(),
+                to: S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'w:p',
+            },
+            content: [{
+                tag: 'relay',
+                attrs: { latency: '15' },
+                content: undefined,
+            }],
+        }
+        return await query(stanza, 3000)
+    }
+    
+    const rejectCall = async (callId, callFrom, reason = '0') => {
         const stanza = ({
             tag: 'call',
             attrs: {
@@ -293,16 +312,38 @@ const makeMessagesRecvSocket = (config) => {
                     attrs: {
                         'call-id': callId,
                         'call-creator': callFrom,
-                        count: '0',
+                        count: reason.toString(),
                     },
                     content: undefined,
                 }],
         })
         
-        await query(stanza)
+        await sendNode(stanza)
     }
     
-    const acceptCall = async (callId, callFrom) => {
+    const acceptCall = async (callId, callFrom, options = {}) => {
+        const acceptContent = [
+            { tag: 'audio', attrs: { enc: 'opus', rate: options.audioRate || '16000' }, content: undefined },
+            { tag: 'net', attrs: { medium: '3' }, content: undefined },
+            { tag: 'capability', attrs: { ver: '1' }, content: new Uint8Array([1, 4, 255, 131, 207, 4]) },
+            { tag: 'encopt', attrs: { keygen: '2' }, content: undefined },
+        ]
+
+        if (options.isVideo) {
+            acceptContent.push({
+                tag: 'video',
+                attrs: {
+                    enc: 'vp8',
+                    dec: 'vp8',
+                    orientation: '0',
+                    screen_width: '1920',
+                    screen_height: '1080',
+                    device_orientation: '0'
+                },
+                content: undefined
+            })
+        }
+
         const stanza = ({
             tag: 'call',
             attrs: {
@@ -315,14 +356,14 @@ const makeMessagesRecvSocket = (config) => {
                         'call-id': callId,
                         'call-creator': callFrom,
                     },
-                    content: undefined,
+                    content: acceptContent,
                 }],
         })
         
-        await query(stanza)
+        await sendNode(stanza)
     }
 
-    const terminateCall = async (callId, callFrom) => {
+    const terminateCall = async (callId, callFrom, reason = 'hangup') => {
         const stanza = ({
             tag: 'call',
             attrs: {
@@ -334,12 +375,13 @@ const makeMessagesRecvSocket = (config) => {
                     attrs: {
                         'call-id': callId,
                         'call-creator': callFrom,
+                        reason,
                     },
                     content: undefined,
                 }],
         })
         
-        await query(stanza)
+        await sendNode(stanza)
     }
     
     const sendRetryRequest = async (node, forceIncludeKeys = false) => {
@@ -1307,8 +1349,9 @@ const makeMessagesRecvSocket = (config) => {
                     
                     const errorMessage = msg?.messageStubParameters?.[0] || ''
                     const isPreKeyError = errorMessage.includes('PreKey')
+                    const isSessionOrMacError = errorMessage.includes('MAC') || errorMessage.includes('Session') || errorMessage.includes('Invalid')
                     
-                    logger.debug(`[handleMessage] Attempting retry request for failed decryption`)
+                    logger.debug(`[handleMessage] Attempting retry request for failed decryption (isPreKey: ${isPreKeyError}, isSessionOrMac: ${isSessionOrMacError})`)
                     
                     // Handle both pre-key and normal retries in single mutex
                     await retryMutex.mutex(async () => {
@@ -1318,6 +1361,20 @@ const makeMessagesRecvSocket = (config) => {
                                 return
                             }
                             
+                            // Auto-heal corrupted sessions (Bad MAC, Invalid Key) by purging stale session
+                            if (isSessionOrMacError) {
+                                const senderJid = node.attrs.participant || node.attrs.from
+                                if (senderJid && signalRepository) {
+                                    try {
+                                        const sessionId = signalRepository.jidToSignalProtocolAddress(senderJid)
+                                        await authState.keys.set({ session: { [sessionId]: null } })
+                                        logger.info({ senderJid, errorMessage }, 'Auto-healed corrupted Signal session for sender')
+                                    } catch (healErr) {
+                                        logger.warn({ healErr, senderJid }, 'Failed to clear corrupted session during auto-heal')
+                                    }
+                                }
+                            }
+                            
                             // Handle pre-key errors with upload and delay
                             if (isPreKeyError) {
                                 logger.info({ error: errorMessage }, 'PreKey error detected, uploading and retrying')
@@ -1336,7 +1393,8 @@ const makeMessagesRecvSocket = (config) => {
                             
                             const encNode = getBinaryNodeChild(node, 'enc')
                             
-                            await sendRetryRequest(node, !encNode)
+                            // Force include keys if pre-key or session corrupted
+                            await sendRetryRequest(node, !encNode || isSessionOrMacError || isPreKeyError)
                             
                             if (retryRequestDelayMs) {
                                 await delay(retryRequestDelayMs)
@@ -1438,7 +1496,9 @@ const makeMessagesRecvSocket = (config) => {
             id: callId,
             date: new Date(+attrs.t * 1000),
             offline: !!attrs.offline,
-            status
+            status,
+            rawNode: node,
+            infoNode: infoChild
         }
         
         if (status === 'offer') {
@@ -1675,6 +1735,7 @@ const makeMessagesRecvSocket = (config) => {
         rejectCall,
         acceptCall,
         terminateCall,
+        getVoIPRelayTokens,
         fetchMessageHistory,
         requestPlaceholderResend,
         messageRetryManager

package/lib/Socket/messages-send.js

@@ -502,11 +502,16 @@ const makeMessagesSocket = (config) => {
         
         if (jidsRequiringFetch.length) {
             // LID if mapped, otherwise original
-            const wireJids = [
+            let wireJids = [
                 ...jidsRequiringFetch.filter(jid => !!isLidUser(jid) || !!isHostedLidUser(jid)),
-                ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => !!isPnUser(jid) || !!isHostedPnUser(jid)))) || []).map(a => a.lid)
+                ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => !!isPnUser(jid) || !!isHostedPnUser(jid)))) || []).map(a => a?.lid).filter(Boolean)
             ]
             
+            // If PN numbers do not have an LID mapping in local DB yet, query directly using their PN JIDs
+            if (!wireJids.length) {
+                wireJids = jidsRequiringFetch
+            }
+            
             logger.debug({ jidsRequiringFetch, wireJids }, 'fetching sessions')
             
             const result = await query({
@@ -655,36 +660,56 @@ const makeMessagesSocket = (config) => {
     }
     
     /** Fetch image for groups, user, and newsletter **/
-    const profilePictureUrl = async (jid) => {
+    const profilePictureUrl = async (jid, type = 'preview', timeoutMs) => {
         if (isJidNewsletter(jid)) {
             const metadata = await suki.newsletterMetadata('JID', jid) 
 
             return getUrlFromDirectPath(metadata.thread_metadata.picture?.direct_path || '') 
+        } else {
+            const normalizedJid = jidNormalizedUser(jid)
+            const isUser = isPnUser(normalizedJid) || isLidUser(normalizedJid)
+            const me = authState.creds.me
+            const isSelf = me && (normalizedJid === jidNormalizedUser(me.id) || (me.lid && normalizedJid === jidNormalizedUser(me.lid)))
 
-         } 
-
-         else {               
-              const result = await query({
-                  tag: 'iq',
-                  attrs: {
-                      target: jidNormalizedUser(jid),
-                      to: S_WHATSAPP_NET,
-                      type: 'get',
-                      xmlns: 'w:profile:picture'
-                   },
-                   content: [{ 
-                        tag: 'picture', 
-                        attrs: { 
-                           type: 'image', 
-                           query: 'url' 
-                        }
-                   }]
-              })
+            const pictureContent = []
+            if (isUser && !isSelf) {
+                try {
+                    const contactTcTokenData = await authState.keys.get('tctoken', [normalizedJid])
+                    const entry = contactTcTokenData?.[normalizedJid]
+                    if (entry?.token && entry?.timestamp) {
+                        pictureContent.push({
+                            tag: 'tctoken',
+                            attrs: { t: String(entry.timestamp) },
+                            content: entry.token
+                        })
+                    }
+                } catch (e) {
+                    // ignore tc token error
+                }
+            }
 
-              const child = getBinaryNodeChild(result, 'picture')
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    target: normalizedJid,
+                    to: S_WHATSAPP_NET,
+                    type: 'get',
+                    xmlns: 'w:profile:picture'
+                },
+                content: [{ 
+                    tag: 'picture', 
+                    attrs: { 
+                        type: type === 'image' ? 'image' : 'preview', 
+                        query: 'url' 
+                    },
+                    content: pictureContent.length ? pictureContent : undefined
+                }]
+            }, timeoutMs)
 
-              return child?.attrs?.url || null
-          }
+            const child = getBinaryNodeChild(result, 'picture')
+
+            return child?.attrs?.url || null
+        }
     }
 
     const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, additionalNodes, AI = false }) => {

package/lib/Socket/socket.js

@@ -479,6 +479,7 @@ const makeSocket = (config) => {
     
     // Pre-key upload state management
     let uploadPreKeysPromise = null
+    let preKeyHealthInterval = null
     let lastUploadTime = 0
     
     /** generates and uploads a set of pre-keys to the server */
@@ -665,6 +666,7 @@ const makeSocket = (config) => {
         
         clearInterval(keepAliveReq)
         clearTimeout(qrTimer)
+        if (preKeyHealthInterval) { clearInterval(preKeyHealthInterval); preKeyHealthInterval = null; }
         
         ws.removeAllListeners('close')
         ws.removeAllListeners('open')
@@ -986,6 +988,17 @@ const makeSocket = (config) => {
         
         clearTimeout(qrTimer) // will never happen in all likelyhood -- but just in case WA sends success on first try
         
+        // Start proactive periodic pre-key check (every 6 hours)
+        if (!preKeyHealthInterval) {
+            preKeyHealthInterval = setInterval(() => {
+                if (ws.isOpen) {
+                    uploadPreKeysToServerIfRequired().catch(err => {
+                        logger.warn({ err: err?.message }, 'Periodic pre-key check encountered an issue')
+                    })
+                }
+            }, 6 * 3600 * 1000)
+        }
+        
         ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } })
         ev.emit('connection.update', { connection: 'open' })
         

package/lib/Socket/voip.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+/**
+ * VoIP Socket Mixin for WaSockets
+ * Extends the unified 'sock' instance with direct WebAssembly WhatsApp calling
+ */
+const makeVoipSocket = (config, baseSocket) => {
+    let voipEngine = null;
+    let enginePromise = null;
+
+    const getVoipEngine = async () => {
+        if (voipEngine) return voipEngine;
+        if (enginePromise) return enginePromise;
+
+        enginePromise = (async () => {
+            const { VoipEngine } = await import("../VoIP/engine/index.mjs");
+            const engine = new VoipEngine(baseSocket, config.voip && typeof config.voip === "object" ? config.voip : {});
+            await engine.init();
+            voipEngine = engine;
+            return engine;
+        })();
+
+        return enginePromise;
+    };
+
+    // Auto-init eagerly whenever VoIP is enabled (boolean true or object with autoInit !== false)
+    const shouldAutoInit = config.voip === true || (typeof config.voip === "object" && config.voip?.autoInit !== false);
+    if (shouldAutoInit) {
+        getVoipEngine().catch(err => {
+            config.logger?.warn?.({ err: err?.message }, "Failed to eagerly auto-init VoIP engine");
+        });
+    }
+
+    // Intercept socket end to clean up VoIP worker threads cleanly
+    const originalEnd = baseSocket.end ? baseSocket.end.bind(baseSocket) : undefined;
+    baseSocket.end = (error) => {
+        try {
+            voipEngine?.destroy?.();
+        } catch {}
+        return originalEnd ? originalEnd(error) : undefined;
+    };
+
+    return {
+        ...baseSocket,
+
+        /**
+         * Place an outbound WhatsApp VoIP call (voice or video)
+         * @param phoneNumber Destination phone number or JID
+         * @param options Call options (durationMs, isVideo, audioSource)
+         * @returns ActiveCall instance
+         */
+        call: async (phoneNumber, options = {}) => {
+            const engine = await getVoipEngine();
+            return engine.startCall(phoneNumber, options);
+        },
+
+        /**
+         * Place an outbound WhatsApp video call
+         * @param phoneNumber Destination phone number or JID
+         * @param options Call options
+         * @returns ActiveCall instance
+         */
+        callVideo: async (phoneNumber, options = {}) => {
+            const engine = await getVoipEngine();
+            return engine.startCall(phoneNumber, { ...options, isVideo: true });
+        },
+
+        /**
+         * Currently active call on this socket, or null if idle
+         */
+        get activeCall() {
+            return voipEngine?.activeCall || null;
+        },
+
+        /**
+         * Clears any active call state to allow a new call
+         */
+        clearActiveCall: () => {
+            voipEngine?.clearActiveCall?.();
+        },
+
+        /**
+         * Accept an incoming WhatsApp call (voice or video) via WebAssembly VoIP stack
+         * @param callId Unique Call ID from offer
+         * @param from Caller JID or phone number
+         * @param options Call options (isVideo, audioSource)
+         * @returns ActiveCall instance
+         */
+        acceptCall: async (callId, from, options = {}) => {
+            const engine = await getVoipEngine();
+            return engine.acceptCall(callId, from, options);
+        },
+
+        /**
+         * Answer an incoming call (alias for acceptCall)
+         */
+        answerCall: async (callId, from, options = {}) => {
+            const engine = await getVoipEngine();
+            return engine.acceptCall(callId, from, options);
+        },
+
+        /**
+         * Reject an incoming call
+         */
+        rejectCall: async (callId, from, reason = 0) => {
+            const engine = await getVoipEngine();
+            return engine.rejectCall(callId, from, reason);
+        },
+
+        /**
+         * Low-level VoIP engine controller
+         */
+        voip: {
+            getEngine: getVoipEngine,
+            destroy: () => voipEngine?.destroy?.()
+        }
+    };
+};
+
+exports.makeVoipSocket = makeVoipSocket;
+

package/lib/Store/make-cache-manager-store.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const { caching } = require("cache-manager")
+const cacheManager = require("cache-manager")
 const { proto } = require("../../WAProto")
 const {
   BufferJSON, 
@@ -12,7 +12,12 @@ const { default: logger } = require("../Utils/logger")
 
 const makeCacheManagerAuthState = async (store, sessionKey) => {
     const defaultKey = (file) => `${sessionKey}:${file}`
-    const databaseConn = await caching(store)
+    const databaseConn = store?.get && store?.set
+        ? store
+        : typeof cacheManager.createCache === 'function'
+            ? (store ? cacheManager.createCache(store) : cacheManager.createCache())
+            : await cacheManager.caching(store)
+
     const writeData = async (file, data) => {
         let ttl = undefined
         if (file === 'creds') {
@@ -43,8 +48,12 @@ const makeCacheManagerAuthState = async (store, sessionKey) => {
     }
     const clearState = async () => {
         try {
-            const result = await databaseConn.store.keys(`${sessionKey}*`)
-            await Promise.all(result.map(async (key) => await databaseConn.del(key)))
+            if (typeof databaseConn.clear === 'function') {
+                await databaseConn.clear()
+            } else if (databaseConn.store?.keys) {
+                const result = await databaseConn.store.keys(`${sessionKey}*`)
+                await Promise.all(result.map(async (key) => await databaseConn.del(key)))
+            }
         }
         catch (err) {
         }
@@ -86,4 +95,4 @@ const makeCacheManagerAuthState = async (store, sessionKey) => {
 
 module.exports = {
   makeCacheManagerAuthState
-}
+}

package/lib/Types/index.d.ts

@@ -187,6 +187,10 @@ export interface BaileysEventMap {
     'contacts.update': Partial<Contact>[]
     'group-participants.update': { id: string; author?: string; participants: string[]; action: 'add' | 'remove' | 'demote' | 'promote' }
     'call': WACallEvent[]
+    'call.created': { callId: string; to: string; isVideo?: boolean }
+    'call.ringing': { callId: string; to: string }
+    'call.connected': { callId: string; to: string; isVideo?: boolean }
+    'call.ended': { callId: string; to: string; reason: string }
     [key: string]: any
 }
 

package/lib/Utils/auth-utils.js

@@ -3,7 +3,22 @@
 Object.defineProperty(exports, "__esModule", { value: true })
 
 const { randomBytes } = require("crypto")
-const { default: PQueue } = require("p-queue") 
+let PQueue
+try {
+    const pq = require("p-queue")
+    PQueue = pq.default || pq
+} catch {
+    PQueue = class SimpleQueue {
+        constructor() {
+            this._chain = Promise.resolve()
+        }
+        add(fn) {
+            const result = this._chain.then(() => fn())
+            this._chain = result.catch(() => {})
+            return result
+        }
+    }
+} 
 const { NodeCache } = require("@cacheable/node-cache")
 const { DEFAULT_CACHE_TTLS } = require("../Defaults/constants")
 const { AsyncLocalStorage } = require("async_hooks")

package/lib/Utils/browser-utils.js

@@ -27,13 +27,17 @@ const Browsers = {
     macOS: browser => ['Mac OS', browser, '14.4.1'],
     baileys: browser => ['Baileys', browser, '6.5.0'],
     windows: browser => ['Windows', browser, '10.0.22631'],
-    //android: browser => [browser, 'Android', ''],
+    android: browser => [browser, 'Android', ''],
     /** The appropriate browser based on your OS & release */
     appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
 }
 
 const getPlatformId = (browser) => {
-    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()]
+    const platform = browser.toUpperCase()
+    if (platform === 'ANDROID') {
+        return (proto.DeviceProps.PlatformType.ANDROID_PHONE || 16).toString()
+    }
+    const platformType = proto.DeviceProps.PlatformType[platform]
     return platformType ? platformType.toString() : '1' //chrome
 }