@ryuu-reinzz/baileys 3.0.0-beta.2 → 3.0.0-beta.21

package/lib/Defaults/index.js

@@ -2,7 +2,7 @@ import { proto } from '../../WAProto/index.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-const version = [2, 3000, 1027934701];
+const version = [2, 3000, 1033105955];
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
 export const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
@@ -15,15 +15,20 @@ export const WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
 export const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5]);
 export const WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
 export const WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+/** Status messages older than 24 hours are considered expired */
+export const STATUS_EXPIRY_SECONDS = 24 * 60 * 60;
+/** WA Web enforces a 14-day maximum age for placeholder resend requests */
+export const PLACEHOLDER_MAX_AGE_SECONDS = 14 * 24 * 60 * 60;
 export const NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
 export const DICT_VERSION = 3;
 export const KEY_BUNDLE_TYPE = Buffer.from([5]);
 export const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]); // last is "DICT_VERSION"
 /** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
 export const URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
-// TODO: Add WA root CA
 export const WA_CERT_DETAILS = {
-    SERIAL: 0
+    SERIAL: 0,
+    ISSUER: 'WhatsAppLongTerm1',
+    PUBLIC_KEY: Buffer.from('142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b', 'hex')
 };
 export const PROCESSABLE_HISTORY_TYPES = [
     proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP,
@@ -51,7 +56,9 @@ export const DEFAULT_CONNECTION_CONFIG = {
     markOnlineOnConnect: true,
     syncFullHistory: true,
     patchMessageBeforeSending: msg => msg,
-    shouldSyncHistoryMessage: () => true,
+    shouldSyncHistoryMessage: ({ syncType }) => {
+        return syncType !== proto.HistorySync.HistorySyncType.FULL;
+    },
     shouldIgnoreJid: () => false,
     linkPreviewImageThumbnailWidth: 192,
     transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
@@ -112,4 +119,10 @@ export const DEFAULT_CACHE_TTLS = {
     CALL_OFFER: 5 * 60, // 5 minutes
     USER_DEVICES: 5 * 60 // 5 minutes
 };
+export const TimeMs = {
+    Minute: 60 * 1000,
+    Hour: 60 * 60 * 1000,
+    Day: 24 * 60 * 60 * 1000,
+    Week: 7 * 24 * 60 * 60 * 1000
+};
 //# sourceMappingURL=index.js.map

package/lib/Signal/libsignal.js

@@ -1,5 +1,7 @@
-/* @ts-ignore */
+// @ts-ignore
 import * as libsignal from 'libsignal';
+// @ts-ignore
+import { PreKeyWhisperMessage } from 'libsignal/src/protobufs.js';
 import { LRUCache } from 'lru-cache';
 import { generateSignalPubKey } from '../Utils/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, transferDevice, WAJIDDomains } from '../WABinary/index.js';
@@ -7,6 +9,28 @@ import { SenderKeyName } from './Group/sender-key-name.js';
 import { SenderKeyRecord } from './Group/sender-key-record.js';
 import { GroupCipher, GroupSessionBuilder, SenderKeyDistributionMessage } from './Group/index.js';
 import { LIDMappingStore } from './lid-mapping.js';
+/** Extract identity key from PreKeyWhisperMessage for identity change detection */
+function extractIdentityFromPkmsg(ciphertext) {
+    try {
+        if (!ciphertext || ciphertext.length < 2) {
+            return undefined;
+        }
+        // Version byte check (version 3)
+        const version = ciphertext[0];
+        if ((version & 0xf) !== 3) {
+            return undefined;
+        }
+        // Parse protobuf (skip version byte)
+        const preKeyProto = PreKeyWhisperMessage.decode(ciphertext.slice(1));
+        if (preKeyProto.identityKey?.length === 33) {
+            return new Uint8Array(preKeyProto.identityKey);
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
     const lidMapping = new LIDMappingStore(auth.keys, logger, pnToLIDFunc);
     const storage = signalStorage(auth, lidMapping);
@@ -48,6 +72,17 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid);
             const session = new libsignal.SessionCipher(storage, addr);
+            // Extract and save sender's identity key before decryption for identity change detection
+            if (type === 'pkmsg') {
+                const identityKey = extractIdentityFromPkmsg(ciphertext);
+                if (identityKey) {
+                    const addrStr = addr.toString();
+                    const identityChanged = await storage.saveIdentity(addrStr, identityKey);
+                    if (identityChanged) {
+                        logger.info({ jid, addr: addrStr }, 'identity key changed or new contact, session will be re-established');
+                    }
+                }
+            }
             async function doDecrypt() {
                 let result;
                 switch (type) {
@@ -296,7 +331,33 @@ function signalStorage({ creds, keys }, lidMapping) {
             await keys.set({ session: { [wireJid]: session.serialize() } });
         },
         isTrustedIdentity: () => {
-            return true; // todo: implement
+            return true; // TOFU - Trust on First Use (same as WhatsApp Web)
+        },
+        loadIdentityKey: async (id) => {
+            const wireJid = await resolveLIDSignalAddress(id);
+            const { [wireJid]: key } = await keys.get('identity-key', [wireJid]);
+            return key || undefined;
+        },
+        saveIdentity: async (id, identityKey) => {
+            const wireJid = await resolveLIDSignalAddress(id);
+            const { [wireJid]: existingKey } = await keys.get('identity-key', [wireJid]);
+            const keysMatch = existingKey &&
+                existingKey.length === identityKey.length &&
+                existingKey.every((byte, i) => byte === identityKey[i]);
+            if (existingKey && !keysMatch) {
+                // Identity changed - clear session and update key
+                await keys.set({
+                    session: { [wireJid]: null },
+                    'identity-key': { [wireJid]: identityKey }
+                });
+                return true;
+            }
+            if (!existingKey) {
+                // New contact - Trust on First Use (TOFU)
+                await keys.set({ 'identity-key': { [wireJid]: identityKey } });
+                return true;
+            }
+            return false;
         },
         loadPreKey: async (id) => {
             const keyId = id.toString();

package/lib/Signal/lid-mapping.js

@@ -7,16 +7,16 @@ export class LIDMappingStore {
             ttlAutopurge: true,
             updateAgeOnGet: true
         });
+        this.inflightLIDLookups = new Map();
+        this.inflightPNLookups = new Map();
         this.keys = keys;
         this.pnToLIDFunc = pnToLIDFunc;
         this.logger = logger;
     }
-    /**
-     * Store LID-PN mapping - USER LEVEL
-     */
     async storeLIDPNMappings(pairs) {
-        // Validate inputs
-        const pairMap = {};
+        if (pairs.length === 0)
+            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}`);
@@ -25,67 +25,135 @@ export class LIDMappingStore {
             const lidDecoded = jidDecode(lid);
             const pnDecoded = jidDecode(pn);
             if (!lidDecoded || !pnDecoded)
-                return;
-            const pnUser = pnDecoded.user;
-            const lidUser = lidDecoded.user;
-            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
-            if (!existingLidUser) {
-                this.logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
-                const stored = await this.keys.get('lid-mapping', [pnUser]);
-                existingLidUser = stored[pnUser];
+                continue;
+            validatedPairs.push({ pnUser: pnDecoded.user, lidUser: lidDecoded.user });
+        }
+        if (validatedPairs.length === 0)
+            return;
+        const cacheMissSet = new Set();
+        const existingMappings = 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) {
+            const cacheMisses = [...cacheMissSet];
+            this.logger.trace(`Batch fetching ${cacheMisses.length} LID mappings from database`);
+            const stored = await this.keys.get('lid-mapping', cacheMisses);
+            for (const pnUser of cacheMisses) {
+                const existingLidUser = stored[pnUser];
                 if (existingLidUser) {
-                    // Update cache with database value
+                    existingMappings.set(pnUser, existingLidUser);
                     this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
                     this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
                 }
             }
+        }
+        const pairMap = {};
+        for (const { pnUser, lidUser } of validatedPairs) {
+            const existingLidUser = existingMappings.get(pnUser);
             if (existingLidUser === lidUser) {
                 this.logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping');
                 continue;
             }
             pairMap[pnUser] = lidUser;
         }
+        if (Object.keys(pairMap).length === 0)
+            return;
         this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
+        const batchData = {};
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            batchData[pnUser] = lidUser;
+            batchData[`${lidUser}_reverse`] = pnUser;
+        }
         await this.keys.transaction(async () => {
-            for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-                await this.keys.set({
-                    'lid-mapping': {
-                        [pnUser]: lidUser,
-                        [`${lidUser}_reverse`]: pnUser
-                    }
-                });
-                this.mappingCache.set(`pn:${pnUser}`, lidUser);
-                this.mappingCache.set(`lid:${lidUser}`, pnUser);
-            }
+            await this.keys.set({ 'lid-mapping': batchData });
         }, 'lid-mapping');
+        // Update cache after successful DB write
+        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+            this.mappingCache.set(`pn:${pnUser}`, lidUser);
+            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        }
     }
-    /**
-     * Get LID for PN - Returns device-specific LID based on user mapping
-     */
     async getLIDForPN(pn) {
         return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
     }
     async getLIDsForPNs(pns) {
+        if (pns.length === 0)
+            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 request 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 = {};
-        // mapped from pn to lid mapping to prevent duplication in results later
         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;
+            }
+            // Push the PN device ID to the LID to maintain device separation
+            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;
-            // Check cache first for PN → LID mapping
             const pnUser = decoded.user;
-            let lidUser = this.mappingCache.get(`pn:${pnUser}`);
-            if (!lidUser) {
-                // Cache miss - check database
-                const stored = await this.keys.get('lid-mapping', [pnUser]);
-                lidUser = stored[pnUser];
-                if (lidUser) {
+            const cached = this.mappingCache.get(`pn:${pnUser}`);
+            if (cached && typeof cached === 'string') {
+                if (!addResolvedPair(pn, decoded, cached)) {
+                    this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
+                    continue;
+                }
+                continue;
+            }
+            pending.push({ pn, pnUser, decoded });
+        }
+        if (pending.length) {
+            const pnUsers = [...new Set(pending.map(item => item.pnUser))];
+            const stored = await this.keys.get('lid-mapping', pnUsers);
+            for (const pnUser of pnUsers) {
+                const lidUser = stored[pnUser];
+                if (lidUser && typeof lidUser === 'string') {
                     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 && typeof cached === 'string') {
+                    if (!addResolvedPair(pn, decoded, cached)) {
+                        this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
+                        continue;
+                    }
+                }
                 else {
                     this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
                     const device = decoded.device || 0;
@@ -99,19 +167,8 @@ export class LIDMappingStore {
                     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 (Object.keys(usyncFetch).length > 0) {
             const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch)); // this function already adds LIDs to mapping
@@ -134,38 +191,81 @@ export class LIDMappingStore {
                 }
             }
             else {
-                return null;
+                this.logger.warn('USync fetch yielded no results for pending PNs');
             }
         }
-        return Object.values(successfulPairs);
+        return Object.values(successfulPairs).length > 0 ? Object.values(successfulPairs) : null;
     }
-    /**
-     * Get PN for LID - USER LEVEL with device construction
-     */
     async getPNForLID(lid) {
-        if (!isLidUser(lid))
-            return null;
-        const decoded = jidDecode(lid);
-        if (!decoded)
+        return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null;
+    }
+    async getPNsForLIDs(lids) {
+        if (lids.length === 0)
             return null;
-        // Check cache first for LID → PN mapping
-        const lidUser = decoded.user;
-        let pnUser = this.mappingCache.get(`lid:${lidUser}`);
-        if (!pnUser || typeof pnUser !== 'string') {
-            // Cache miss - check database
-            const stored = await this.keys.get('lid-mapping', [`${lidUser}_reverse`]);
-            pnUser = stored[`${lidUser}_reverse`];
+        const sortedLids = [...new Set(lids)].sort();
+        const cacheKey = sortedLids.join(',');
+        const inflight = this.inflightPNLookups.get(cacheKey);
+        if (inflight) {
+            this.logger.trace(`Coalescing getPNsForLIDs request 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') {
-                this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
-                return null;
+                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 && typeof cached === 'string') {
+                addResolvedPair(lid, decoded, cached);
+                continue;
+            }
+            pending.push({ lid, lidUser, decoded });
+        }
+        if (pending.length) {
+            const reverseKeys = [...new Set(pending.map(item => `${item.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 && typeof pnUser === 'string') {
+                    addResolvedPair(lid, decoded, pnUser);
+                }
+                else {
+                    this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+                }
             }
-            this.mappingCache.set(`lid:${lidUser}`, pnUser);
         }
-        // Construct device-specific PN JID
-        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}`);
-        return pnJid;
+        return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null;
     }
 }
 //# sourceMappingURL=lid-mapping.js.map

package/lib/Socket/Client/websocket.js

@@ -35,11 +35,15 @@ export class WebSocketClient extends AbstractSocketClient {
             this.socket?.on(event, (...args) => this.emit(event, ...args));
         }
     }
-    close() {
+    async close() {
         if (!this.socket) {
             return;
         }
+        const closePromise = new Promise(resolve => {
+            this.socket?.once('close', resolve);
+        });
         this.socket.close();
+        await closePromise;
         this.socket = null;
     }
     send(str, cb) {

package/lib/Socket/business.js

@@ -10,35 +10,38 @@ export const makeBusinessSocket = (config) => {
         const node = [];
         const simpleFields = ['address', 'email', 'description'];
         node.push(...simpleFields
-            .filter(key => args[key])
+            .filter(key => args[key] !== undefined && args[key] !== null)
             .map(key => ({
             tag: key,
             attrs: {},
             content: args[key]
         })));
-        if (args.websites) {
+        if (args.websites !== undefined) {
             node.push(...args.websites.map(website => ({
                 tag: 'website',
                 attrs: {},
                 content: website
             })));
         }
-        if (args.hours) {
+        if (args.hours !== undefined) {
             node.push({
                 tag: 'business_hours',
                 attrs: { timezone: args.hours.timezone },
-                content: args.hours.days.map(config => {
+                content: args.hours.days.map(dayConfig => {
                     const base = {
                         tag: 'business_hours_config',
-                        attrs: { day_of_week: config.day, mode: config.mode }
+                        attrs: {
+                            day_of_week: dayConfig.day,
+                            mode: dayConfig.mode
+                        }
                     };
-                    if (config.mode === 'specific_hours') {
+                    if (dayConfig.mode === 'specific_hours') {
                         return {
                             ...base,
                             attrs: {
                                 ...base.attrs,
-                                open_time: config.openTimeInMinutes,
-                                close_time: config.closeTimeInMinutes
+                                open_time: dayConfig.openTimeInMinutes,
+                                close_time: dayConfig.closeTimeInMinutes
                             }
                         };
                     }