@nexustechpro/baileys 1.1.7 → 2.0.1

package/lib/Socket/messages-send.js

@@ -122,7 +122,8 @@ export const makeMessagesSocket = (config) => {
             if (lidResults.length > 0) { logger.trace('Storing LID maps from device call'); await signalRepository.lidMapping.storeLIDPNMappings(lidResults.map(a => ({ lid: a.lid, pn: a.id }))) }
             try {
                 const lids = lidResults.map(a => a.lid)
-                if (lids.length) await assertSessions(lids, true)
+                // Re-fetch sessions during device lookup to ensure fresh state
+                if (lids.length) await assertSessions(lids, false)
             } catch (e) {
                 logger.warn({ error: e, count: lidResults.length }, 'failed to assert sessions for newly mapped LIDs')
             }
@@ -200,7 +201,7 @@ export const makeMessagesSocket = (config) => {
         for (const node of tokenNodes) {
             const jid = node.attrs.jid
             const token = node.content
-            if (jid && token) tokens[jid] = { token }
+            if (jid && token) tokens[jid] = { token, timestamp: Number(unixTimestampSeconds()) }
         }
     }
     return tokens
@@ -361,8 +362,25 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
                     if (groupData) { participantsList.push(...groupData.participants.map(p => p.id)); groupAddressingMode = groupData?.addressingMode || groupAddressingMode }
                     additionalAttributes = { ...additionalAttributes, addressing_mode: groupAddressingMode }
                 }
+                
+                // DEVICE 0 PRESERVATION FOR GROUPS: Initialize device 0 for all participants
+                const device0EntriesGroup = []
+                for (const jid of participantsList) {
+                    const { user, server } = jidDecode(jid)
+                    if (user) {
+                        device0EntriesGroup.push({ user, device: 0, jid: jidEncode(user, server, 0) })
+                    }
+                }
+                
                 const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false)
-                devices.push(...additionalDevices)
+                // Combine device 0 entries with fetched devices, avoiding duplicates
+                const deviceMap = new Map()
+                for (const d of device0EntriesGroup) deviceMap.set(`${d.user}:${d.device}`, d)
+                for (const d of additionalDevices) {
+                    const key = `${d.user}:${d.device}`
+                    if (!deviceMap.has(key)) deviceMap.set(key, d)
+                }
+                devices.push(...Array.from(deviceMap.values()))
             }
 
             if (groupData?.ephemeralDuration > 0) additionalAttributes = { ...additionalAttributes, expiration: groupData.ephemeralDuration.toString() }
@@ -383,6 +401,7 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
                 if ((!hasKey || !!participant) && !isHostedLidUser(deviceJid) && !isHostedPnUser(deviceJid) && device.device !== 99) { senderKeyRecipients.push(deviceJid); senderKeyMap[deviceJid] = true }
             }
 
+            // Assert sessions once for sender key recipients ONLY to avoid concurrent conflicts
             if (senderKeyRecipients.length) {
                 logger.debug({ senderKeyJids: senderKeyRecipients }, 'sending sender key')
                 const senderKeyMsg = { senderKeyDistributionMessage: { axolotlSenderKeyDistributionMessage: senderKeyDistributionMessage, groupId: destinationJid } }
@@ -416,10 +435,20 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
                 }
 
                 if (additionalAttributes?.category !== 'peer') {
+                    // DEVICE 0 PRESERVATION: Save device 0 entries before refetch
+                    const device0Entries = devices.filter(d => d.device === 0)
+                    const senderOwnUser = device0Entries.find(d => d.user !== user)?.user
                     devices.length = 0
                     const senderIdentity = isLid && meLid ? jidEncode(jidDecode(meLid)?.user, 'lid', undefined) : jidEncode(jidDecode(meId)?.user, 's.whatsapp.net', undefined)
+                    // Fetch both sender and recipient devices to ensure complete enumeration
                     const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false)
-                    devices.push(...sessionDevices)
+                    devices.push(...device0Entries, ...sessionDevices)
+                    // If sender devices weren't enumerated, explicitly fetch them
+                    if (senderOwnUser && !sessionDevices.some(d => d.user === senderOwnUser && d.device !== 0)) {
+                        const senderDevices = await getUSyncDevices([senderIdentity], true, false)
+                        const senderLinkedDevices = senderDevices.filter(d => d.device !== 0 && d.user === senderOwnUser)
+                        if (senderLinkedDevices.length > 0) devices.push(...senderLinkedDevices)
+                    }
                 }
             }
 
@@ -471,10 +500,24 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
 
         if (shouldIncludeDeviceIdentity) { stanza.content.push({ tag: 'device-identity', attrs: {}, content: encodeSignedDeviceIdentity(authState.creds.account, true) }); logger.debug({ jid }, 'adding device identity') }
         if (additionalNodes?.length > 0 && !additionalAlready) stanza.content.push(...additionalNodes)
-            // Add TCToken support
-             const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {}
-             const tcTokenBuffer = contactTcTokenData[destinationJid]?.token
-             if (tcTokenBuffer) stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
+            // Add TCToken support with expiration validation
+             if (!isGroup && !isRetryResend && !isStatus) {
+                 const contactTcTokenData = await authState.keys.get('tctoken', [destinationJid])
+                 let tcTokenBuffer = contactTcTokenData[destinationJid]?.token
+                 
+                 // Check if token is expired
+                 if (isTokenExpired(contactTcTokenData[destinationJid])) {
+                     logger.debug({ jid: destinationJid }, 'tctoken expired, refreshing')
+                     try {
+                         const freshTokens = await getPrivacyTokens([destinationJid])
+                         tcTokenBuffer = freshTokens[destinationJid]?.token
+                     } catch (err) {
+                         logger.warn({ jid: destinationJid, err }, 'failed to refresh expired tctoken')
+                     }
+                 }
+                 
+                 if (tcTokenBuffer) stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
+             }
 
             logger.debug({ msgId }, `sending message to ${participants.length} devices`)
             await sendNode(stanza)
@@ -484,7 +527,15 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
         return {key: {remoteJid: jid, fromMe: true, id: finalMsgId, participant: isGroup ? authState.creds.me.id : undefined}, messageId: finalMsgId}
     }
 
-           const getPrivacyTokens = async (jids) => {
+           const TOKEN_EXPIRY_TTL = 24 * 60 * 60 // 24 hours in seconds
+    
+    const isTokenExpired = (tokenData) => {
+        if (!tokenData || !tokenData.timestamp) return true
+        const age = unixTimestampSeconds() - Number(tokenData.timestamp)
+        return age > TOKEN_EXPIRY_TTL
+    }
+    
+    const getPrivacyTokens = async (jids) => {
            const t = unixTimestampSeconds().toString()
            const result = await query({ tag: 'iq', attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'privacy' }, content: [{ tag: 'tokens', attrs: {}, content: jids.map(jid => ({ tag: 'token', attrs: { jid: jidNormalizedUser(jid), t, type: 'trusted_contact' } })) }] })
            const tokens = parseTCTokens(result)

package/lib/Socket/nexus-handler.js

@@ -277,7 +277,7 @@ class NexusHandler {
                     eventMessage: {
                         contextInfo: {
                             mentionedJid: [jid], participant: jid, remoteJid: 'status@broadcast',
-                            forwardedNewsletterMessageInfo: { newsletterName: 'Nexus Events', newsletterJid: '120363421563597486@newsletter', serverMessageId: 1 }
+                            forwardedNewsletterMessageInfo: { newsletterName: 'Nexus Events', newsletterJid: '120363422827915475@newsletter', serverMessageId: 1 }
                         },
                         isCanceled: e.isCanceled || false, name: e.name, description: e.description,
                         location: e.location || { degreesLatitude: 0, degreesLongitude: 0, name: 'Location' }, joinLink: e.joinLink || '',

package/lib/Socket/registration.js

@@ -0,0 +1,197 @@
+/* eslint-disable camelcase */
+import axios from 'axios';
+import { MOBILE_TOKEN, MOBILE_REGISTRATION_ENDPOINT, MOBILE_USERAGENT, REGISTRATION_PUBLIC_KEY } from '../Defaults/index.js';
+import { md5, Curve, aesEncryptGCM } from '../Utils/crypto.js';
+import { jidEncode } from '../WABinary/index.js';
+import { makeCommunitiesSocket } from './communities.js';
+
+function urlencode(str) {
+    return str.replace(/-/g, '%2d').replace(/_/g, '%5f').replace(/~/g, '%7e');
+}
+
+function convertBufferToUrlHex(buffer) {
+    let id = '';
+    buffer.forEach((x) => {
+        // encode random identity_id buffer as percentage url encoding
+        id += `%${x.toString(16).padStart(2, '0').toLowerCase()}`;
+    });
+    return id;
+}
+
+const validRegistrationOptions = (config) =>
+    config?.phoneNumberCountryCode &&
+    config.phoneNumberNationalNumber &&
+    config.phoneNumberMobileCountryCode;
+
+const makeRegistrationSocket = (config) => {
+    const sock = makeCommunitiesSocket(config);
+
+    const register = async (code) => {
+        if (!validRegistrationOptions(config.auth.creds.registration)) {
+            throw new Error('please specify the registration options');
+        }
+
+        const result = await mobileRegister(
+            { ...sock.authState.creds, ...sock.authState.creds.registration, code },
+            config.options
+        );
+
+        sock.authState.creds.me = {
+            id: jidEncode(result.login, 's.whatsapp.net'),
+            name: '~'
+        };
+        sock.authState.creds.registered = true;
+        sock.ev.emit('creds.update', sock.authState.creds);
+
+        return result;
+    };
+
+    const requestRegistrationCode = async (registrationOptions) => {
+        registrationOptions = registrationOptions || config.auth.creds.registration;
+
+        if (!validRegistrationOptions(registrationOptions)) {
+            throw new Error('Invalid registration options');
+        }
+
+        sock.authState.creds.registration = registrationOptions;
+        sock.ev.emit('creds.update', sock.authState.creds);
+
+        return mobileRegisterCode(
+            { ...config.auth.creds, ...registrationOptions },
+            config.options
+        );
+    };
+
+    return {
+        ...sock,
+        register,
+        requestRegistrationCode,
+    };
+};
+
+function registrationParams(params) {
+    const e_regid = Buffer.alloc(4);
+    e_regid.writeInt32BE(params.registrationId);
+
+    const e_skey_id = Buffer.alloc(3);
+    e_skey_id.writeInt16BE(params.signedPreKey.keyId);
+
+    params.phoneNumberCountryCode = params.phoneNumberCountryCode.replace('+', '').trim();
+    params.phoneNumberNationalNumber = params.phoneNumberNationalNumber.replace(/[/\-\s)(]/g, '').trim();
+
+    return {
+        cc:                    params.phoneNumberCountryCode,
+        in:                    params.phoneNumberNationalNumber,
+        Rc:                    '0',
+        lg:                    'en',
+        lc:                    'GB',
+        mistyped:              '6',
+        authkey:               Buffer.from(params.noiseKey.public).toString('base64url'),
+        e_regid:               e_regid.toString('base64url'),
+        e_keytype:             'BQ',
+        e_ident:               Buffer.from(params.signedIdentityKey.public).toString('base64url'),
+        // e_skey_id:          e_skey_id.toString('base64url'),
+        e_skey_id:             'AAAA',
+        e_skey_val:            Buffer.from(params.signedPreKey.keyPair.public).toString('base64url'),
+        e_skey_sig:            Buffer.from(params.signedPreKey.signature).toString('base64url'),
+        fdid:                  params.phoneId,
+        network_ratio_type:    '1',
+        expid:                 params.deviceId,
+        simnum:                '1',
+        hasinrc:               '1',
+        pid:                   Math.floor(Math.random() * 1000).toString(),
+        id:                    convertBufferToUrlHex(params.identityId),
+        backup_token:          convertBufferToUrlHex(params.backupToken),
+        token:                 md5(Buffer.concat([MOBILE_TOKEN, Buffer.from(params.phoneNumberNationalNumber)])).toString('hex'),
+        fraud_checkpoint_code: params.captcha,
+    };
+}
+
+/**
+ * Requests a registration code for the given phone number.
+ */
+function mobileRegisterCode(params, fetchOptions) {
+    return mobileRegisterFetch('/code', {
+        params: {
+            ...registrationParams(params),
+            mcc:     `${params.phoneNumberMobileCountryCode}`.padStart(3, '0'),
+            mnc:     `${params.phoneNumberMobileNetworkCode || '001'}`.padStart(3, '0'),
+            sim_mcc: '000',
+            sim_mnc: '000',
+            method:  params?.method || 'sms',
+            reason:  '',
+            hasav:   '1',
+        },
+        ...fetchOptions,
+    });
+}
+
+function mobileRegisterExists(params, fetchOptions) {
+    return mobileRegisterFetch('/exist', {
+        params: registrationParams(params),
+        ...fetchOptions,
+    });
+}
+
+/**
+ * Registers the phone number on WhatsApp with the received OTP code.
+ */
+async function mobileRegister(params, fetchOptions) {
+    return mobileRegisterFetch('/register', {
+        params: { ...registrationParams(params), code: params.code.replace('-', '') },
+        ...fetchOptions,
+    });
+}
+
+/**
+ * Encrypts the given string as AEAD aes-256-gcm with the public WhatsApp key and a random keypair.
+ */
+function mobileRegisterEncrypt(data) {
+    const keypair = Curve.generateKeyPair();
+    const key     = Curve.sharedKey(keypair.private, REGISTRATION_PUBLIC_KEY);
+    const buffer  = aesEncryptGCM(Buffer.from(data), new Uint8Array(key), Buffer.alloc(12), Buffer.alloc(0));
+
+    return Buffer.concat([Buffer.from(keypair.public), buffer]).toString('base64url');
+}
+
+async function mobileRegisterFetch(path, opts = {}) {
+    let url = `${MOBILE_REGISTRATION_ENDPOINT}${path}`;
+
+    if (opts.params) {
+        const parameter = [];
+        for (const param in opts.params) {
+            if (opts.params[param] !== null && opts.params[param] !== undefined) {
+                parameter.push(param + '=' + urlencode(opts.params[param]));
+            }
+        }
+        url += `?${parameter.join('&')}`;
+        delete opts.params;
+    }
+
+    if (!opts.headers) {
+        opts.headers = {};
+    }
+    opts.headers['User-Agent'] = MOBILE_USERAGENT;
+
+    const response = await axios(url, opts);
+    const json = response.data;
+
+    if (response.status > 300 || json.reason) {
+        throw json;
+    }
+    if (json.status && !['ok', 'sent'].includes(json.status)) {
+        throw json;
+    }
+
+    return json;
+}
+
+export {
+    makeRegistrationSocket,
+    registrationParams,
+    mobileRegisterCode,
+    mobileRegisterExists,
+    mobileRegister,
+    mobileRegisterEncrypt,
+    mobileRegisterFetch,
+};

package/lib/Socket/socket.js

@@ -308,15 +308,13 @@ export const makeSocket = (config) => {
       const hasSessions = !!sessionData?.['_index']
 
       const currentPreKeyId = creds.nextPreKeyId - 1
-      const preKeyData = currentPreKeyId > 0 
-        ? await keys.get("pre-key", [currentPreKeyId.toString()]) 
-        : {}
-      const hasCurrentPreKey = !!preKeyData[currentPreKeyId?.toString()]
-
+      const expectedPreKeys = Math.max(0, currentPreKeyId)
+      const preKeyThreshold = 20
+      
       logger.info({
         hasDeviceList,
         hasSessions,
-        hasCurrentPreKey,
+        expectedPreKeys,
         currentPreKeyId
       }, "Auth state integrity check complete")
 
@@ -326,9 +324,6 @@ export const makeSocket = (config) => {
       if (!hasSessions) {
         logger.warn("⚠️  Sessions are empty - will establish as contacts message")
       }
-      if (!hasCurrentPreKey && currentPreKeyId > 0) {
-        logger.warn({ currentPreKeyId }, "⚠️  Current pre-key missing - will regenerate batch")
-      }
     } catch (error) {
       logger.error({ error }, "Auth state integrity check failed")
     }
@@ -579,26 +574,12 @@ export const makeSocket = (config) => {
     try {
       const preKeyCount = await getAvailablePreKeysOnServer()
       const currentPreKeyId = creds.nextPreKeyId - 1
-      const preKeys = currentPreKeyId > 0 
-        ? await keys.get("pre-key", [currentPreKeyId.toString()]) 
-        : {}
-      const currentPreKeyExists = !!preKeys[currentPreKeyId.toString()]
 
       logger.info(
-        `${preKeyCount} pre-keys on server, current ID: ${currentPreKeyId}, exists: ${currentPreKeyExists}`
+        `Server: ${preKeyCount} pre-keys, Current ID: ${currentPreKeyId}`
       )
 
-      // Critical: Missing current pre-key
-      if (!currentPreKeyExists && currentPreKeyId > 0) {
-        logger.warn(
-          { currentPreKeyId },
-          "🚨 Current pre-key file missing - regenerating full batch"
-        )
-        await uploadPreKeys(INITIAL_PREKEY_COUNT)
-        return
-      }
-
-      // Low server count
+      // Only regenerate if server is low
       if (preKeyCount < MIN_PREKEY_COUNT) {
         const uploadCount = INITIAL_PREKEY_COUNT - preKeyCount
         logger.info(
@@ -607,7 +588,7 @@ export const makeSocket = (config) => {
         await uploadPreKeys(uploadCount)
       } else {
         logger.info(
-          `✅ PreKey validation passed - Server: ${preKeyCount} pre-keys, Current ID: ${currentPreKeyId} exists`
+          `✅ PreKey validation passed - Server: ${preKeyCount} pre-keys`
         )
       }
     } catch (error) {
@@ -1214,7 +1195,7 @@ export const makeSocket = (config) => {
     onWhatsApp,
     listener: (eventName) => {
       if (typeof ev.listenerCount === "function") return ev.listenerCount(eventName)
-      if (typeof ev.listeners === "function") return ev.listeners(eventName)?.length || 0
+      if (typeof ev.listener === "function") return ev.listener(eventName)?.length || 0
       return 0
     }
   }

package/lib/Utils/decode-wa-message.js

@@ -209,6 +209,11 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
           decryptables += 1
           let msgBuffer
           const decryptionJid = await getDecryptionJid(author, repository, logger)
+          let decryptionAltJid = null
+          const { senderAlt } = extractAddressingContext(stanza)
+          if (senderAlt) {
+            decryptionAltJid = await getDecryptionJid(senderAlt, repository, logger)
+          }
           if (tag !== "plaintext") {
             // TODO: Handle hosted devices
             await storeMappingFromEnvelope(stanza, author, repository, decryptionJid, logger)
@@ -228,6 +233,7 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
       try {
         msgBuffer = await repository.decryptMessage({
           jid: decryptionJid,
+          alternateJid: decryptionAltJid,
           type: e2eType,
           ciphertext: content,
         })

package/lib/Utils/generics.js

@@ -1,7 +1,7 @@
 import { Boom } from '@hapi/boom'
 import { createHash, randomBytes } from 'crypto'
 import { proto } from '../../WAProto/index.js'
-const baileysVersion = [2, 3000, 1033105955]
+const baileysVersion = [2, 3000, 1027934701]
 import { DisconnectReason } from '../Types/index.js'
 import { getAllBinaryNodeChildren, jidDecode } from '../WABinary/index.js'
 import { sha256 } from './crypto.js'

package/lib/Utils/link-preview.js

@@ -57,13 +57,17 @@ export const getUrlInfo = async (text, opts = {
                 originalThumbnailUrl: image
             };
             if (opts.uploadImage) {
-                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
-                    upload: opts.uploadImage,
-                    mediaTypeOverride: 'thumbnail-link',
-                    options: opts.fetchOpts
-                });
-                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
-                urlInfo.highQualityThumbnail = imageMessage || undefined;
+                try {
+                    const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
+                        upload: opts.uploadImage,
+                        mediaTypeOverride: 'thumbnail-link',
+                        options: opts.fetchOpts
+                    });
+                    urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
+                    urlInfo.highQualityThumbnail = imageMessage || undefined;
+                } catch (error) {
+                    opts.logger?.warn({ err: error.message, url: image }, 'failed to upload link preview thumbnail, continuing without it');
+                }
             }
             else {
                 try {