davexbaileys 2.5.21 → 2.5.23

package/lib/Utils/pre-key-manager.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreKeyManager = void 0;
+const p_queue_1 = require("p-queue");
+
+class PreKeyManager {
+    constructor(store, logger) {
+        this.store = store;
+        this.logger = logger;
+        this.queues = new Map();
+    }
+
+    getQueue(keyType) {
+        if (!this.queues.has(keyType)) {
+            this.queues.set(keyType, new p_queue_1.default({ concurrency: 1 }));
+        }
+        return this.queues.get(keyType);
+    }
+
+    async processOperations(data, keyType, transactionCache, mutations, isInTransaction) {
+        const keyData = data[keyType];
+        if (!keyData) return;
+
+        return this.getQueue(keyType).add(async () => {
+            transactionCache[keyType] = transactionCache[keyType] || {};
+            mutations[keyType] = mutations[keyType] || {};
+
+            const deletions = [];
+            const updates = {};
+
+            for (const keyId in keyData) {
+                if (keyData[keyId] === null) {
+                    deletions.push(keyId);
+                }
+                else {
+                    updates[keyId] = keyData[keyId];
+                }
+            }
+
+            if (Object.keys(updates).length > 0) {
+                Object.assign(transactionCache[keyType], updates);
+                Object.assign(mutations[keyType], updates);
+            }
+
+            if (deletions.length > 0) {
+                await this.processDeletions(keyType, deletions, transactionCache, mutations, isInTransaction);
+            }
+        });
+    }
+
+    async processDeletions(keyType, ids, transactionCache, mutations, isInTransaction) {
+        if (isInTransaction) {
+            for (const keyId of ids) {
+                if (transactionCache[keyType] && transactionCache[keyType][keyId]) {
+                    transactionCache[keyType][keyId] = null;
+                    mutations[keyType][keyId] = null;
+                }
+                else {
+                    this.logger.warn(`Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`);
+                }
+            }
+        }
+        else {
+            const existingKeys = await this.store.get(keyType, ids);
+            for (const keyId of ids) {
+                if (existingKeys[keyId]) {
+                    transactionCache[keyType][keyId] = null;
+                    mutations[keyType][keyId] = null;
+                }
+                else {
+                    this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
+                }
+            }
+        }
+    }
+
+    async validateDeletions(data, keyType) {
+        const keyData = data[keyType];
+        if (!keyData) return;
+
+        return this.getQueue(keyType).add(async () => {
+            const deletionIds = Object.keys(keyData).filter(id => keyData[id] === null);
+            if (deletionIds.length === 0) return;
+
+            const existingKeys = await this.store.get(keyType, deletionIds);
+            for (const keyId of deletionIds) {
+                if (!existingKeys[keyId]) {
+                    this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`);
+                    delete data[keyType][keyId];
+                }
+            }
+        });
+    }
+}
+exports.PreKeyManager = PreKeyManager;

package/lib/Utils/process-message.js

@@ -149,7 +149,8 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                     ev.emit('messaging-history.set', {
                         ...data,
                         isLatest: histNotification.syncType !== WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND ? isLatest : undefined,
-                        peerDataRequestSessionId: histNotification.peerDataRequestSessionId
+                        peerDataRequestSessionId: histNotification.peerDataRequestSessionId,
+                        chunkOrder: histNotification.chunkOrder !== undefined ? histNotification.chunkOrder : undefined
                     });
                 }
                 break;
@@ -248,13 +249,14 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         const jid = (_f = message.key) === null || _f === void 0 ? void 0 : _f.remoteJid;
         //let actor = whatsappID (message.participant)
         let participants;
-        const emitParticipantsUpdate = (action) => ev.emit('group-participants.update', { id: jid, author: message.participant, participants, action });
+        const authorUsername = message.key && message.key.participantUsername;
+        const emitParticipantsUpdate = (action) => ev.emit('group-participants.update', { id: jid, author: message.participant, authorUsername, participants, action });
         const emitGroupUpdate = (update) => {
             var _a;
-            ev.emit('groups.update', [{ id: jid, ...update, author: (_a = message.participant) !== null && _a !== void 0 ? _a : undefined }]);
+            ev.emit('groups.update', [{ id: jid, ...update, author: (_a = message.participant) !== null && _a !== void 0 ? _a : undefined, authorUsername }]);
         };
         const emitGroupRequestJoin = (participant, action, method) => {
-            ev.emit('group.join-request', { id: jid, author: message.participant, participant, action, method: method });
+            ev.emit('group.join-request', { id: jid, author: message.participant, authorUsername, participant, action, method: method });
         };
         const participantsIncludesMe = () => participants.find(jid => (0, WABinary_1.areJidsSameUser)(meId, jid));
         switch (message.messageStubType) {

package/lib/Utils/stanza-ack.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAckStanza = void 0;
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ *
+ * @param node - the received binary node to acknowledge
+ * @param errorCode - optional NACK error code
+ * @param meId - own JID, required for message-class ACKs
+ */
+const buildAckStanza = (node, errorCode, meId) => {
+    const { tag, attrs } = node;
+    const stanza = {
+        tag: 'ack',
+        attrs: {
+            id: attrs.id,
+            to: attrs.from,
+            class: tag
+        }
+    };
+    if (errorCode) {
+        stanza.attrs.error = errorCode.toString();
+    }
+    if (attrs.participant) {
+        stanza.attrs.participant = attrs.participant;
+    }
+    if (attrs.recipient) {
+        stanza.attrs.recipient = attrs.recipient;
+    }
+    // WA Web always includes type when present
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type;
+    }
+    // WA Web WAWebHandleMsgSendAck.sendAck/sendNack always includes `from` for message-class ACKs
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId;
+    }
+    return stanza;
+};
+exports.buildAckStanza = buildAckStanza;

package/lib/Utils/sync-action-utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAppStateSyncIrrecoverable = exports.isMissingKeyError = void 0;
+/**
+ * Returns true when the error indicates that an app-state sync key is missing.
+ * WA Web treats these as "Blocked" (waits for key arrival), not fatal.
+ * Errors are tagged via { data: { isMissingKey: true } } in the Boom payload.
+ */
+const isMissingKeyError = (error) => {
+    var _a;
+    return ((_a = error === null || error === void 0 ? void 0 : error.data) === null || _a === void 0 ? void 0 : _a.isMissingKey) === true;
+};
+exports.isMissingKeyError = isMissingKeyError;
+/**
+ * Determines if an app state sync error is unrecoverable.
+ * TypeError indicates a WASM crash; otherwise we give up after MAX_SYNC_ATTEMPTS.
+ * Missing keys are NOT checked here — they are handled separately as "Blocked".
+ */
+const isAppStateSyncIrrecoverable = (error, attemptsForName, maxAttempts) => {
+    return (attemptsForName >= maxAttempts ||
+        (error === null || error === void 0 ? void 0 : error.name) === 'TypeError');
+};
+exports.isAppStateSyncIrrecoverable = isAppStateSyncIrrecoverable;

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeTcTokensFromIqResult = exports.buildTcTokenFromJid = exports.resolveIssuanceJid = exports.resolveTcTokenJid = exports.shouldSendNewTcToken = exports.isTcTokenExpired = exports.buildMergedTcTokenIndexWrite = exports.readTcTokenIndex = exports.TC_TOKEN_INDEX_KEY = exports.storeTcTokensFromHistorySync = exports.getTcTokenKey = void 0;
+const WABinary_1 = require("../WABinary");
+
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+    if (!jid) return false;
+    const user = jid.split('@')[0] || '';
+    if (user === '0') return false;
+    if (BOT_PHONE_REGEX.test(user)) return false;
+    if ((0, WABinary_1.isJidMetaIa)(jid)) return false;
+    return !!(
+        (0, WABinary_1.isLidUser)(jid) ||
+        (0, WABinary_1.isJidUser)(jid) ||
+        jid.endsWith('@c.us')
+    );
+}
+
+const TC_TOKEN_BUCKET_DURATION = 604800;
+const TC_TOKEN_NUM_BUCKETS = 4;
+
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+exports.TC_TOKEN_INDEX_KEY = '__index';
+
+/**
+ * Returns the key used to store a tc-token for a given JID.
+ * @deprecated use resolveTcTokenJid instead
+ */
+const getTcTokenKey = (jid) => {
+    return `tc-token:${(0, WABinary_1.jidNormalizedUser)(jid)}`;
+};
+exports.getTcTokenKey = getTcTokenKey;
+
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+const readTcTokenIndex = async (keys) => {
+    const data = await keys.get('tctoken', [exports.TC_TOKEN_INDEX_KEY]);
+    const entry = data[exports.TC_TOKEN_INDEX_KEY];
+    if (!(entry === null || entry === void 0 ? void 0 : entry.token) || !entry.token.length) return [];
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed)) return [];
+        return parsed.filter(j => typeof j === 'string' && j.length > 0 && j !== exports.TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+};
+exports.readTcTokenIndex = readTcTokenIndex;
+
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+const buildMergedTcTokenIndexWrite = async (keys, addedJids) => {
+    const persisted = await (0, exports.readTcTokenIndex)(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== exports.TC_TOKEN_INDEX_KEY) merged.add(jid);
+    }
+    return {
+        [exports.TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+};
+exports.buildMergedTcTokenIndexWrite = buildMergedTcTokenIndexWrite;
+
+/** Returns true when a tc-token timestamp is past the rolling 28-day window. */
+const isTcTokenExpired = (timestamp) => {
+    if (timestamp === null || timestamp === undefined) return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts)) return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+};
+exports.isTcTokenExpired = isTcTokenExpired;
+
+/** Returns true if we should send a new tc-token to this contact (bucket-based deduplication). */
+const shouldSendNewTcToken = (senderTimestamp) => {
+    if (senderTimestamp === undefined) return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+};
+exports.shouldSendNewTcToken = shouldSendNewTcToken;
+
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+const resolveTcTokenJid = async (jid, getLIDForPN) => {
+    if ((0, WABinary_1.isLidUser)(jid)) return jid;
+    const lid = await getLIDForPN(jid);
+    return lid !== null && lid !== void 0 ? lid : jid;
+};
+exports.resolveTcTokenJid = resolveTcTokenJid;
+
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+const resolveIssuanceJid = async (jid, issueToLid, getLIDForPN, getPNForLID) => {
+    if (issueToLid) {
+        if ((0, WABinary_1.isLidUser)(jid)) return jid;
+        const lid = await getLIDForPN(jid);
+        return lid !== null && lid !== void 0 ? lid : jid;
+    }
+    if (!(0, WABinary_1.isLidUser)(jid)) return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn !== null && pn !== void 0 ? pn : jid;
+    }
+    return jid;
+};
+exports.resolveIssuanceJid = resolveIssuanceJid;
+
+/**
+ * Build tc-token content array from a stored token for a given JID.
+ * Returns undefined if no valid token exists.
+ */
+const buildTcTokenFromJid = async ({ authState, jid, baseContent = [], getLIDForPN }) => {
+    try {
+        const storageJid = await (0, exports.resolveTcTokenJid)(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData === null || tcTokenData === void 0 ? void 0 : tcTokenData[storageJid];
+        const tcTokenBuffer = entry === null || entry === void 0 ? void 0 : entry.token;
+        if (!(tcTokenBuffer === null || tcTokenBuffer === void 0 ? void 0 : tcTokenBuffer.length) || (0, exports.isTcTokenExpired)(entry === null || entry === void 0 ? void 0 : entry.timestamp)) {
+            if (tcTokenBuffer) {
+                const cleared = (entry === null || entry === void 0 ? void 0 : entry.senderTimestamp) !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                    : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+};
+exports.buildTcTokenFromJid = buildTcTokenFromJid;
+
+/**
+ * Store tc-tokens received from a privacy_token IQ response.
+ */
+const storeTcTokensFromIqResult = async ({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) => {
+    const { getBinaryNodeChild, getBinaryNodeChildren } = require('../WABinary');
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
+    if (!tokensNode) return;
+    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+        const rawJid = (0, WABinary_1.jidNormalizedUser)(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid)) continue;
+        const storageJid = await (0, exports.resolveTcTokenJid)(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = (existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.timestamp) ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        if (!incomingTs) continue;
+        if (existingTs > 0 && existingTs > incomingTs) continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: Object.assign(Object.assign({}, existingEntry), { token: Buffer.from(tokenNode.content), timestamp: tokenNode.attrs.t })
+            }
+        });
+        if (onNewJidStored) onNewJidStored(storageJid);
+    }
+};
+exports.storeTcTokensFromIqResult = storeTcTokensFromIqResult;
+
+/**
+ * Extracts and stores tc-tokens from a history sync payload.
+ * Conversations in the history sync may carry tcToken fields that should
+ * be stored so that presenceSubscribe / relayMessage can include them.
+ */
+const storeTcTokensFromHistorySync = async (ev, conversations) => {
+    if (!conversations || !conversations.length) {
+        return;
+    }
+    const chatUpdates = [];
+    for (const conv of conversations) {
+        if (conv.id && conv.tcToken) {
+            chatUpdates.push({
+                id: conv.id,
+                tcToken: conv.tcToken instanceof Uint8Array
+                    ? Buffer.from(conv.tcToken)
+                    : Buffer.isBuffer(conv.tcToken)
+                        ? conv.tcToken
+                        : Buffer.from(Object.values(conv.tcToken))
+            });
+        }
+    }
+    if (chatUpdates.length) {
+        ev.emit('chats.update', chatUpdates);
+    }
+};
+exports.storeTcTokensFromHistorySync = storeTcTokensFromHistorySync;

package/lib/WAUSync/Protocols/USyncContactProtocol.js

@@ -13,11 +13,34 @@ class USyncContactProtocol {
         };
     }
     getUserElement(user) {
-        //TODO: Implement type / username fields (not yet supported)
+        if (user.phone) {
+            return {
+                tag: 'contact',
+                attrs: {},
+                content: user.phone
+            };
+        }
+        if (user.username) {
+            return {
+                tag: 'contact',
+                attrs: {
+                    username: user.username,
+                    ...(user.usernameKey ? { pin: user.usernameKey } : {}),
+                    ...(user.lid ? { lid: user.lid } : {})
+                }
+            };
+        }
+        if (user.type) {
+            return {
+                tag: 'contact',
+                attrs: {
+                    type: user.type
+                }
+            };
+        }
         return {
             tag: 'contact',
-            attrs: {},
-            content: user.phone
+            attrs: {}
         };
     }
     parser(node) {

package/lib/WAUSync/Protocols/USyncUsernameProtocol.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USyncUsernameProtocol = void 0;
+class USyncUsernameProtocol {
+    constructor() {
+        this.name = 'username';
+    }
+    getQueryElement() {
+        return {
+            tag: 'username',
+            attrs: {}
+        };
+    }
+    getUserElement(user) {
+        if (user.usernameKey) {
+            return {
+                tag: 'username',
+                attrs: { key: user.usernameKey }
+            };
+        }
+        return {
+            tag: 'username',
+            attrs: {}
+        };
+    }
+    parser(node) {
+        var _a, _b;
+        if (node.tag === 'username') {
+            const username = (_a = node === null || node === void 0 ? void 0 : node.attrs) === null || _a === void 0 ? void 0 : _a.value;
+            const key = (_b = node === null || node === void 0 ? void 0 : node.attrs) === null || _b === void 0 ? void 0 : _b.key;
+            if (username) {
+                return { username, key };
+            }
+        }
+        return null;
+    }
+}
+exports.USyncUsernameProtocol = USyncUsernameProtocol;

package/lib/WAUSync/Protocols/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./USyncDeviceProtocol"), exports);
 __exportStar(require("./USyncContactProtocol"), exports);
 __exportStar(require("./USyncStatusProtocol"), exports);
 __exportStar(require("./USyncDisappearingModeProtocol"), exports);
+__exportStar(require("./USyncUsernameProtocol"), exports);

package/lib/WAUSync/USyncQuery.js

@@ -5,6 +5,7 @@ const WABinary_1 = require("../WABinary");
 const UsyncBotProfileProtocol_1 = require("./Protocols/UsyncBotProfileProtocol");
 const UsyncLIDProtocol_1 = require("./Protocols/UsyncLIDProtocol");
 const Protocols_1 = require("./Protocols");
+const USyncUsernameProtocol_1 = require("./Protocols/USyncUsernameProtocol");
 class USyncQuery {
     constructor() {
         this.protocols = [];
@@ -89,5 +90,9 @@ class USyncQuery {
         this.protocols.push(new UsyncLIDProtocol_1.USyncLIDProtocol());
         return this;
     }
+    withUsernameProtocol() {
+        this.protocols.push(new USyncUsernameProtocol_1.USyncUsernameProtocol());
+        return this;
+    }
 }
 exports.USyncQuery = USyncQuery;

package/lib/WAUSync/USyncUser.js

@@ -22,5 +22,13 @@ class USyncUser {
         this.personaId = personaId;
         return this;
     }
+    withUsername(username) {
+        this.username = username;
+        return this;
+    }
+    withUsernameKey(usernameKey) {
+        this.usernameKey = usernameKey;
+        return this;
+    }
 }
 exports.USyncUser = USyncUser;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "davexbaileys",
-    "version": "2.5.21",
+    "version": "2.5.23",
     "description": "A lightweight, full-featured WhatsApp Web API library for Node.js — maintained by Dave Tech",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
@@ -20,7 +20,8 @@
         "whatsapp-bot",
         "messaging",
         "chat",
-        "newsletter"
+        "newsletter",
+        "communities"
     ],
     "dependencies": {
         "@cacheable/node-cache": "^1.4.0",
@@ -29,10 +30,20 @@
         "axios": "^1.6.0",
         "libsignal": "github:WhiskeySockets/libsignal-node",
         "lodash": "^4.17.21",
+        "lru-cache": "^11.3.5",
         "music-metadata": "^7.12.3",
         "node-fetch": "^2.6.1",
+        "p-queue": "^9.2.0",
         "pino": "^9.6",
         "protobufjs": "^7.2.4",
         "ws": "^8.13.0"
-    }
-}
+    },
+    "engines": {
+        "node": ">=20.0.0"
+    },
+    "files": [
+        "lib/**/*",
+        "WAProto/**/*",
+        "engine-requirements.js"
+    ]
+}