@ryuu-reinzz/baileys 3.5.1 → 5.0.2

package/lib/Utils/stanza-ack.js

@@ -0,0 +1,38 @@
+/**
+ * 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
+ */
+export function 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: `n.type || DROP_ATTR`
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type;
+    }
+    // WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId;
+    }
+    return stanza;
+}
+//# sourceMappingURL=stanza-ack.js.map

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

@@ -21,6 +21,7 @@ export const processContactAction = (action, id, logger) => {
             {
                 id,
                 name: action.fullName || action.firstName || action.username || undefined,
+                username: action.username || undefined,
                 lid: lidJid || undefined,
                 phoneNumber
             }

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

@@ -1,9 +1,119 @@
-export async function buildTcTokenFromJid({ authState, jid, baseContent = [] }) {
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+// 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; // PSA
+    if (BOT_PHONE_REGEX.test(user))
+        return false; // Bot by phone pattern
+    if (isJidMetaAI(jid))
+        return false; // MetaAI (@bot server)
+    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+}
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY = '__index';
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
+    const entry = data[TC_TOKEN_INDEX_KEY];
+    if (!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 !== TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY)
+            merged.add(jid);
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+export function 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;
+}
+export function 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;
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid))
+            return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!isLidUser(jid))
+        return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
     try {
-        const tcTokenData = await authState.keys.get('tctoken', [jid]);
-        const tcTokenBuffer = tcTokenData?.[jid]?.token;
-        if (!tcTokenBuffer)
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+            if (tcTokenBuffer) {
+                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+                // after we drop the unusable peer token. Only wipe the record entirely when
+                // there's nothing worth keeping.
+                const cleared = 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: {},
@@ -15,4 +125,39 @@ export async function buildTcTokenFromJid({ authState, jid, baseContent = [] })
         return baseContent.length > 0 ? baseContent : undefined;
     }
 }
+export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    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;
+        }
+        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid))
+            continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        // timestamp-less tokens would be immediately expired
+        if (!incomingTs)
+            continue;
+        if (existingTs > 0 && existingTs > incomingTs)
+            continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        onNewJidStored?.(storageJid);
+    }
+}
 //# sourceMappingURL=tc-token-utils.js.map

package/lib/Utils/validate-connection.js

@@ -44,6 +44,9 @@ const getClientPayload = (config) => {
         userAgent: getUserAgent(config)
     };
     payload.webInfo = getWebInfo(config);
+    if (config.pushName) {
+        payload.pushName = config.pushName;
+    }
     return payload;
 };
 export const generateLoginNode = (userJid, config) => {

package/lib/WAUSync/Protocols/USyncContactProtocol.js

@@ -11,11 +11,34 @@ export 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,25 @@
+import { assertNodeErrorFree } from '../../WABinary/index.js';
+import { USyncUser } from '../USyncUser.js';
+export class USyncUsernameProtocol {
+    constructor() {
+        this.name = 'username';
+    }
+    getQueryElement() {
+        return {
+            tag: 'username',
+            attrs: {}
+        };
+    }
+    getUserElement(user) {
+        void user;
+        return null;
+    }
+    parser(node) {
+        if (node.tag === 'username') {
+            assertNodeErrorFree(node);
+            return typeof node.content === 'string' ? node.content : null;
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=USyncUsernameProtocol.js.map

package/lib/WAUSync/Protocols/index.js

@@ -2,4 +2,5 @@ export * from './USyncDeviceProtocol.js';
 export * from './USyncContactProtocol.js';
 export * from './USyncStatusProtocol.js';
 export * from './USyncDisappearingModeProtocol.js';
+export * from './USyncUsernameProtocol.js';
 //# sourceMappingURL=index.js.map

package/lib/WAUSync/USyncQuery.js

@@ -1,7 +1,7 @@
 import { getBinaryNodeChild } from '../WABinary/index.js';
 import { USyncBotProfileProtocol } from './Protocols/UsyncBotProfileProtocol.js';
 import { USyncLIDProtocol } from './Protocols/UsyncLIDProtocol.js';
-import { USyncContactProtocol, USyncDeviceProtocol, USyncDisappearingModeProtocol, USyncStatusProtocol } from './Protocols/index.js';
+import { USyncContactProtocol, USyncDeviceProtocol, USyncDisappearingModeProtocol, USyncStatusProtocol, USyncUsernameProtocol } from './Protocols/index.js';
 import { USyncUser } from './USyncUser.js';
 export class USyncQuery {
     constructor() {
@@ -23,7 +23,7 @@ export class USyncQuery {
         return this;
     }
     parseUSyncQueryResult(result) {
-        if (!result || result.attrs.type !== 'result') {
+        if (result?.attrs.type !== 'result') {
             return;
         }
         const protocolMap = Object.fromEntries(this.protocols.map(protocol => {
@@ -90,5 +90,9 @@ export class USyncQuery {
         this.protocols.push(new USyncLIDProtocol());
         return this;
     }
+    withUsernameProtocol() {
+        this.protocols.push(new USyncUsernameProtocol());
+        return this;
+    }
 }
 //# sourceMappingURL=USyncQuery.js.map

package/lib/WAUSync/USyncUser.js

@@ -11,6 +11,14 @@ export class USyncUser {
         this.phone = phone;
         return this;
     }
+    withUsername(username) {
+        this.username = username;
+        return this;
+    }
+    withUsernameKey(usernameKey) {
+        this.usernameKey = usernameKey;
+        return this;
+    }
     withType(type) {
         this.type = type;
         return this;

package/package.json

@@ -8,7 +8,7 @@
             "require": "./lib/index.cjs"
         }
     },
-    "version": "3.5.1",
+    "version": "5.0.2",
     "description": "A WebSockets library for interacting with WhatsApp Web",
     "keywords": [
         "whatsapp",
@@ -19,28 +19,26 @@
         "url": "git@github.com:WhiskeySockets/Baileys.git"
     },
     "license": "MIT",
-    "author": "Ryuu Reinzz",
+    "author": "ryuu-reinzz",
+    "types": "lib/index.d.ts",
     "files": [
         "lib/**/*",
         "WAProto/**/*",
         "engine-requirements.js"
     ],
-    "scripts": {
-        "start": "node engine-requirements.js"
-    },
     "dependencies": {
         "@cacheable/node-cache": "^1.4.0",
-        "@ryuu-reinzz/haruka-lib": "^3.7.1",
+        "@ryuu-reinzz/haruka-lib": "4.0.3",
         "@hapi/boom": "^9.1.3",
         "async-mutex": "^0.5.0",
         "better-sqlite3": "^12.5.0",
         "libsignal": "npm:@ryuu-reinzz/libsignal@2.2.0",
         "lru-cache": "^11.1.0",
-        "music-metadata": "^11.7.0",
+        "music-metadata": "^11.12.3",
         "p-queue": "^9.0.0",
         "pino": "^9.6",
         "protobufjs": "^8.0.0",
-        "whatsapp-rust-bridge": "0.5.2",
+        "whatsapp-rust-bridge": "0.5.4",
         "ws": "^8.13.0"
     },
     "devDependencies": {
@@ -59,7 +57,7 @@
         "eslint-config-prettier": "^10.1.2",
         "eslint-plugin-prettier": "^5.4.0",
         "jest": "^30.0.5",
-        "jimp": "^1.6.0",
+        "jimp": "^1.6.1",
         "jiti": "^2.4.2",
         "json": "^11.0.0",
         "link-preview-js": "^3.0.0",
@@ -67,8 +65,8 @@
         "open": "^8.4.2",
         "pino-pretty": "^13.1.1",
         "prettier": "^3.5.3",
-        "protobufjs-cli": "^2.0.1",
-        "release-it": "^15.10.3",
+        "protobufjs-cli": "^1.1.3",
+        "release-it": "^20.0.1",
         "ts-jest": "^29.4.0",
         "tsc-esm-fix": "^3.1.2",
         "tsx": "^4.20.3",
@@ -78,10 +76,39 @@
     },
     "peerDependencies": {
         "audio-decode": "^2.1.3",
-        "jimp": "^1.6.0",
+        "jimp": "^1.6.1",
         "link-preview-js": "^3.0.0",
         "sharp": "*"
     },
+    "resolutions": {
+        "ajv@npm:^6.12.4": "^6.14.0",
+        "basic-ftp": "^5.2.4",
+        "brace-expansion@npm:^1.1.7": "^1.1.13",
+        "brace-expansion@npm:^2.0.1": "^2.0.3",
+        "flatted": "^3.4.2",
+        "glob@npm:^10.2.2": "^10.5.0",
+        "glob@npm:^10.3.10": "^10.5.0",
+        "glob@npm:^10.5.0": "^10.5.0",
+        "handlebars": "^4.7.9",
+        "ip-address": "^10.1.1",
+        "js-yaml@npm:^3.13.1": "^3.14.2",
+        "js-yaml@npm:^4.1.0": "^4.1.1",
+        "markdown-it": "^14.1.1",
+        "minimatch@npm:^3.0.4": "^3.1.5",
+        "minimatch@npm:^3.1.2": "^3.1.5",
+        "minimatch@npm:^5.0.1": "^5.1.8",
+        "minimatch@npm:^9.0.4": "^9.0.9",
+        "minimatch@npm:^9.0.5": "^9.0.9",
+        "picomatch@npm:^2.0.4": "^2.3.2",
+        "picomatch@npm:^2.3.1": "^2.3.2",
+        "picomatch@npm:^4.0.0": "^4.0.4",
+        "picomatch@npm:^4.0.2": "^4.0.4",
+        "socks": "^2.8.8",
+        "tar": "^7.5.11",
+        "tmp": "^0.2.5",
+        "underscore": "^1.13.8",
+        "yaml@npm:^2.6.1": "^2.8.4"
+    },
     "peerDependenciesMeta": {
         "audio-decode": {
             "optional": true