@badzz88/baileys 8.5.6 → 8.5.8

package/{src → lib}/Utils/reporting-utils.js

@@ -1,8 +1,6 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.getMessageReportingToken = exports.shouldIncludeReportingToken = void 0;
-const Crypto_1 = require('./crypto');
-const crypto_2 = require('./crypto');
+import { createHmac } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { hkdf } from './crypto.js';
 const reportingFields = [
     { f: 1 },
     {
@@ -59,7 +57,7 @@ const reportingFields = [
     { f: 93, s: [{ f: 1, m: true }] },
     { f: 94, s: [{ f: 1, m: true }] }
 ];
-const compileReportingFields = fields => {
+const compileReportingFields = (fields) => {
     const map = new Map();
     for (const f of fields) {
         map.set(f.f, {
@@ -78,11 +76,10 @@ const WIRE = {
     BYTES: 2,
     FIXED32: 5
 };
-const shouldIncludeReportingToken = message => !message.reactionMessage &&
+export const shouldIncludeReportingToken = (message) => !message.reactionMessage &&
     !message.encReactionMessage &&
     !message.encEventResponseMessage &&
     !message.pollUpdateMessage;
-exports.shouldIncludeReportingToken = shouldIncludeReportingToken;
 const generateMsgSecretKey = (modificationType, origMsgId, origMsgSender, modificationSender, origMsgSecret) => {
     const useCaseSecret = Buffer.concat([
         Buffer.from(origMsgId, 'utf8'),
@@ -90,7 +87,7 @@ const generateMsgSecretKey = (modificationType, origMsgId, origMsgSender, modifi
         Buffer.from(modificationSender, 'utf8'),
         Buffer.from(modificationType, 'utf8')
     ]);
-    return (0, crypto_2.hkdf)(origMsgSecret, 32, { info: useCaseSecret.toString('latin1') });
+    return hkdf(origMsgSecret, 32, { info: useCaseSecret.toString('latin1') });
 };
 const extractReportingTokenContent = (data, cfg) => {
     const out = [];
@@ -105,7 +102,7 @@ const extractReportingTokenContent = (data, cfg) => {
         const fieldStart = i;
         i += tag.bytes;
         const fieldCfg = cfg.get(fieldNum);
-        const pushSlice = end => {
+        const pushSlice = (end) => {
             if (end > data.length) {
                 return false;
             }
@@ -113,7 +110,7 @@ const extractReportingTokenContent = (data, cfg) => {
             i = end;
             return true;
         };
-        const skip = end => {
+        const skip = (end) => {
             if (end > data.length) {
                 return false;
             }
@@ -223,7 +220,7 @@ const decodeVarint = (buffer, offset) => {
     }
     return { value: 0, bytes: 0, ok: false };
 };
-const encodeVarint = value => {
+const encodeVarint = (value) => {
     const parts = [];
     let remaining = value >>> 0;
     while (remaining > 0x7f) {
@@ -233,7 +230,7 @@ const encodeVarint = value => {
     parts.push(remaining);
     return Buffer.from(parts);
 };
-const getMessageReportingToken = async (msgProtobuf, message, key) => {
+export const getMessageReportingToken = async (msgProtobuf, message, key) => {
     const msgSecret = message.messageContextInfo?.messageSecret;
     if (!msgSecret || !key.id) {
         return null;
@@ -245,7 +242,7 @@ const getMessageReportingToken = async (msgProtobuf, message, key) => {
     if (!content || content.length === 0) {
         return null;
     }
-    const reportingToken = Buffer.from(Crypto_1.hmacSign(content, reportingSecret)).subarray(0, 16);
+    const reportingToken = createHmac('sha256', reportingSecret).update(content).digest().subarray(0, 16);
     return {
         tag: 'reporting',
         attrs: {},
@@ -258,4 +255,4 @@ const getMessageReportingToken = async (msgProtobuf, message, key) => {
         ]
     };
 };
-exports.getMessageReportingToken = getMessageReportingToken;
+//# sourceMappingURL=reporting-utils.js.map

package/lib/Utils/signal.js

@@ -0,0 +1,201 @@
+import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
+import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from '../WABinary/index.js';
+import { Curve, generateSignalPubKey } from './crypto.js';
+import { encodeBigEndian } from './generics.js';
+function chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+}
+export const createSignalIdentity = (wid, accountSignatureKey) => {
+    return {
+        identifier: { name: wid, deviceId: 0 },
+        identifierKey: generateSignalPubKey(accountSignatureKey)
+    };
+};
+export const getPreKeys = async ({ get }, min, limit) => {
+    const idList = [];
+    for (let id = min; id < limit; id++) {
+        idList.push(id.toString());
+    }
+    return get('pre-key', idList);
+};
+export const generateOrGetPreKeys = (creds, range) => {
+    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
+    const remaining = range - avaliable;
+    const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
+    const newPreKeys = {};
+    if (remaining > 0) {
+        for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
+            newPreKeys[i] = Curve.generateKeyPair();
+        }
+    }
+    return {
+        newPreKeys,
+        lastPreKeyId,
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+    };
+};
+export const xmppSignedPreKey = (key) => ({
+    tag: 'skey',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+        { tag: 'value', attrs: {}, content: key.keyPair.public },
+        { tag: 'signature', attrs: {}, content: key.signature }
+    ]
+});
+export const xmppPreKey = (pair, id) => ({
+    tag: 'key',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
+        { tag: 'value', attrs: {}, content: pair.public }
+    ]
+});
+const isValidUInt = (n) => typeof n === 'number' && Number.isInteger(n);
+export const extractE2ESessionFromRetryReceipt = (receipt) => {
+    const keysNode = getBinaryNodeChild(receipt, 'keys');
+    if (!keysNode)
+        return null;
+    const typeBuf = getBinaryNodeChildBuffer(keysNode, 'type');
+    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== KEY_BUNDLE_TYPE[0])
+        return null;
+    const identity = getBinaryNodeChildBuffer(keysNode, 'identity');
+    const skey = getBinaryNodeChild(keysNode, 'skey');
+    if (!identity || identity.length !== 32 || !skey)
+        return null;
+    const registrationId = getBinaryNodeChildUInt(receipt, 'registration', 4);
+    if (!isValidUInt(registrationId))
+        return null;
+    const signedPubKey = getBinaryNodeChildBuffer(skey, 'value');
+    const signedSig = getBinaryNodeChildBuffer(skey, 'signature');
+    const signedKeyId = getBinaryNodeChildUInt(skey, 'id', 3);
+    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
+        return null;
+    }
+    const preKeyNode = getBinaryNodeChild(keysNode, 'key');
+    let preKey;
+    if (preKeyNode) {
+        const preKeyPub = getBinaryNodeChildBuffer(preKeyNode, 'value');
+        const preKeyId = getBinaryNodeChildUInt(preKeyNode, 'id', 3);
+        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
+            return null;
+        }
+        preKey = { keyId: preKeyId, publicKey: generateSignalPubKey(preKeyPub) };
+    }
+    return {
+        registrationId,
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: {
+            keyId: signedKeyId,
+            publicKey: generateSignalPubKey(signedPubKey),
+            signature: signedSig
+        },
+        preKey
+    };
+};
+export const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) => key
+        ? {
+            keyId: getBinaryNodeChildUInt(key, 'id', 3),
+            publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
+            signature: getBinaryNodeChildBuffer(key, 'signature')
+        }
+        : undefined;
+    const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user');
+    for (const node of nodes) {
+        assertNodeErrorFree(node);
+    }
+    // Most of the work in repository.injectE2ESession is CPU intensive, not IO
+    // So Promise.all doesn't really help here,
+    // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
+    // This way we chunk it in smaller parts and between those parts we can yield to the event loop
+    // It's rare case when you need to E2E sessions for so many users, but it's possible
+    const chunkSize = 100;
+    const chunks = chunk(nodes, chunkSize);
+    for (const nodesChunk of chunks) {
+        for (const node of nodesChunk) {
+            const signedKey = getBinaryNodeChild(node, 'skey');
+            const key = getBinaryNodeChild(node, 'key');
+            const identity = getBinaryNodeChildBuffer(node, 'identity');
+            const jid = node.attrs.jid;
+            const registrationId = getBinaryNodeChildUInt(node, 'registration', 4);
+            await repository.injectE2ESession({
+                jid,
+                session: {
+                    registrationId: registrationId,
+                    identityKey: generateSignalPubKey(identity),
+                    signedPreKey: extractKey(signedKey),
+                    preKey: extractKey(key)
+                }
+            });
+        }
+    }
+};
+export const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = jidDecode(myJid);
+    const extracted = [];
+    for (const userResult of result) {
+        const { devices, id } = userResult;
+        const decoded = jidDecode(id), { user, server } = decoded;
+        let { domainType } = decoded;
+        const deviceList = devices?.deviceList;
+        if (!Array.isArray(deviceList))
+            continue;
+        for (const { id: device, keyIndex, isHosted } of deviceList) {
+            if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
+                ((myUser !== user && myLid !== user) || myDevice !== device) && // either different user or if me user, not this device
+                (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+            ) {
+                if (isHosted) {
+                    domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
+                }
+                extracted.push({
+                    user,
+                    device,
+                    domainType,
+                    server: getServerFromDomainType(server, domainType)
+                });
+            }
+        }
+    }
+    return extracted;
+};
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+export const getNextPreKeys = async ({ creds, keys }, count) => {
+    const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count);
+    const update = {
+        nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+        firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
+    };
+    await keys.set({ 'pre-key': newPreKeys });
+    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    return { update, preKeys };
+};
+export const getNextPreKeysNode = async (state, count) => {
+    const { creds } = state;
+    const { update, preKeys } = await getNextPreKeys(state, count);
+    const node = {
+        tag: 'iq',
+        attrs: {
+            xmlns: 'encrypt',
+            type: 'set',
+            to: S_WHATSAPP_NET
+        },
+        content: [
+            { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
+            { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
+            { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
+            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
+            xmppSignedPreKey(creds.signedPreKey)
+        ]
+    };
+    return { update, node };
+};
+//# sourceMappingURL=signal.js.map

package/{src → lib}/Utils/stanza-ack.js

@@ -1,7 +1,12 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.buildAckStanza = buildAckStanza;
-function buildAckStanza(node, errorCode, meId) {
+/**
+ * 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',
@@ -20,11 +25,14 @@ function buildAckStanza(node, errorCode, meId) {
     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/sticker.js

@@ -0,0 +1,110 @@
+import { Boom } from '@hapi/boom';
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+
+const runFfmpeg = (input, args) => new Promise((resolve, reject) => {
+    const proc = spawn('ffmpeg', ['-hide_banner', '-loglevel', 'error', '-i', 'pipe:0', ...args, 'pipe:1'], { stdio: ['pipe', 'pipe', 'pipe'] });
+    const outChunks = [];
+    const errChunks = [];
+    proc.stdout.on('data', chunk => outChunks.push(chunk));
+    proc.stderr.on('data', chunk => errChunks.push(chunk));
+    proc.on('error', err => reject(new Boom(`ffmpeg failed to start: ${err.message}`, { statusCode: 500 })));
+    proc.on('close', code => {
+        if (code !== 0) {
+            reject(new Boom(`ffmpeg exited with code ${code}: ${Buffer.concat(errChunks).toString('utf8').slice(0, 500)}`, { statusCode: 500 }));
+            return;
+        }
+        resolve(Buffer.concat(outChunks));
+    });
+    proc.stdin.on('error', () => { });
+    proc.stdin.end(input);
+});
+export const convertToWebp = async (buffer, { animated = false, quality = 60 } = {}) => {
+    const scalePad = "scale='min(512,iw)':'min(512,ih)':force_original_aspect_ratio=decrease,format=rgba,pad=512:512:-1:-1:color=#00000000";
+    const args = animated
+        ? ['-vf', `${scalePad},fps=15`, '-loop', '0', '-preset', 'default', '-an', '-vsync', '0', '-vcodec', 'libwebp', '-q:v', String(quality), '-f', 'webp']
+        : ['-vf', `${scalePad}`, '-vframes', '1', '-vcodec', 'libwebp', '-q:v', String(quality), '-f', 'webp'];
+    return runFfmpeg(buffer, args);
+};
+const readChunks = (buf) => {
+    const chunks = [];
+    let offset = 12;
+    while (offset + 8 <= buf.length) {
+        const fourCC = buf.toString('ascii', offset, offset + 4);
+        const size = buf.readUInt32LE(offset + 4);
+        const dataStart = offset + 8;
+        const data = buf.subarray(dataStart, dataStart + size);
+        chunks.push({ fourCC, data });
+        offset = dataStart + size + (size % 2);
+    }
+    return chunks;
+};
+const buildChunk = (fourCC, data) => {
+    const header = Buffer.alloc(8);
+    header.write(fourCC, 0, 4, 'ascii');
+    header.writeUInt32LE(data.length, 4);
+    const pad = data.length % 2 === 1 ? Buffer.from([0]) : Buffer.alloc(0);
+    return Buffer.concat([header, data, pad]);
+};
+const buildExifChunkData = (json) => {
+    const header = Buffer.from([0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
+    const payload = Buffer.from(JSON.stringify(json), 'utf8');
+    header.writeUInt32LE(payload.length, 14);
+    return Buffer.concat([header, payload]);
+};
+export const writeExifToWebp = (webpBuffer, { packId, packName = '', publisher = '', emojis = [], isAvatar = false } = {}) => {
+    if (webpBuffer.toString('ascii', 0, 4) !== 'RIFF' || webpBuffer.toString('ascii', 8, 12) !== 'WEBP') {
+        throw new Boom('writeExifToWebp: not a valid webp buffer', { statusCode: 400 });
+    }
+    const chunks = readChunks(webpBuffer);
+    const exifData = buildExifChunkData({
+        'sticker-pack-id': packId || randomUUID(),
+        'sticker-pack-name': packName,
+        'sticker-pack-publisher': publisher,
+        emojis: emojis.length ? emojis : ['🤖'],
+        'is-avatar-sticker': isAvatar ? 1 : 0
+    });
+    let vp8x = chunks.find(c => c.fourCC === 'VP8X');
+    const otherChunks = chunks.filter(c => c.fourCC !== 'VP8X' && c.fourCC !== 'EXIF');
+    if (!vp8x) {
+        const img = otherChunks.find(c => c.fourCC === 'VP8 ' || c.fourCC === 'VP8L');
+        if (!img) {
+            throw new Boom('writeExifToWebp: no VP8/VP8L image data found', { statusCode: 400 });
+        }
+        let width;
+        let height;
+        if (img.fourCC === 'VP8 ') {
+            width = (img.data.readUInt16LE(6) & 0x3fff);
+            height = (img.data.readUInt16LE(8) & 0x3fff);
+        }
+        else {
+            const b = img.data;
+            width = 1 + (((b[2] & 0x3f) << 8) | b[1]);
+            height = 1 + (((b[4] & 0xf) << 10) | (b[3] << 2) | ((b[2] & 0xc0) >> 6));
+        }
+        const flags = Buffer.alloc(4);
+        flags[0] = 0x08;
+        const dims = Buffer.alloc(6);
+        dims.writeUIntLE(width - 1, 0, 3);
+        dims.writeUIntLE(height - 1, 3, 3);
+        vp8x = { fourCC: 'VP8X', data: Buffer.concat([flags, dims]) };
+    }
+    else {
+        const flagsByte = vp8x.data[0] | 0x08;
+        vp8x = { fourCC: 'VP8X', data: Buffer.concat([Buffer.from([flagsByte]), vp8x.data.subarray(1)]) };
+    }
+    const rebuilt = [vp8x, ...otherChunks, { fourCC: 'EXIF', data: exifData }];
+    const chunkBuffers = rebuilt.map(c => buildChunk(c.fourCC, c.data));
+    const payload = Buffer.concat(chunkBuffers);
+    const riffSize = 4 + payload.length;
+    const out = Buffer.alloc(8 + 4 + payload.length);
+    out.write('RIFF', 0, 4, 'ascii');
+    out.writeUInt32LE(riffSize, 4);
+    out.write('WEBP', 8, 4, 'ascii');
+    payload.copy(out, 12);
+    return out;
+};
+export const makeSticker = async (buffer, { pack = '', author = '', emojis = [], isPrivate = false, animated = false, quality = 60 } = {}) => {
+    const webp = await convertToWebp(buffer, { animated, quality });
+    return writeExifToWebp(webp, { packName: pack, publisher: author, emojis, isAvatar: isPrivate });
+};

package/{src → lib}/Utils/sync-action-utils.js

@@ -1,16 +1,20 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.emitSyncActionResults = exports.processContactAction = void 0;
-const WABinary_1 = require('../WABinary');
-const processContactAction = (action, id, logger) => {
+import { proto } from '../../WAProto/index.js';
+import { isLidUser, isPnUser } from '../WABinary/index.js';
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
+export const processContactAction = (action, id, logger) => {
     const results = [];
     if (!id) {
         logger?.warn({ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid }, 'contactAction sync: missing id in index');
         return results;
     }
     const lidJid = action.lidJid;
-    const idIsPn = (0, WABinary_1.isPnUser)(id);
+    const idIsPn = isPnUser(id);
+    // PN is in index[1], not in contactAction.pnJid which is usually null
     const phoneNumber = idIsPn ? id : action.pnJid || undefined;
+    // Always emit contacts.upsert
     results.push({
         event: 'contacts.upsert',
         data: [
@@ -23,7 +27,8 @@ const processContactAction = (action, id, logger) => {
             }
         ]
     });
-    if (lidJid && (0, WABinary_1.isLidUser)(lidJid) && idIsPn) {
+    // Emit lid-mapping.update if we have valid LID-PN pair
+    if (lidJid && isLidUser(lidJid) && idIsPn) {
         results.push({
             event: 'lid-mapping.update',
             data: { lid: lidJid, pn: id }
@@ -31,8 +36,7 @@ const processContactAction = (action, id, logger) => {
     }
     return results;
 };
-exports.processContactAction = processContactAction;
-const emitSyncActionResults = (ev, results) => {
+export const emitSyncActionResults = (ev, results) => {
     for (const result of results) {
         if (result.event === 'contacts.upsert') {
             ev.emit('contacts.upsert', result.data);
@@ -42,4 +46,4 @@ const emitSyncActionResults = (ev, results) => {
         }
     }
 };
-exports.emitSyncActionResults = emitSyncActionResults;
+//# sourceMappingURL=sync-action-utils.js.map

package/{src → lib}/Utils/tc-token-utils.js

@@ -1,62 +1,59 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.TC_TOKEN_INDEX_KEY = void 0;
-exports.readTcTokenIndex = readTcTokenIndex;
-exports.buildMergedTcTokenIndexWrite = buildMergedTcTokenIndexWrite;
-exports.isTcTokenExpired = isTcTokenExpired;
-exports.shouldSendNewTcToken = shouldSendNewTcToken;
-exports.resolveTcTokenJid = resolveTcTokenJid;
-exports.resolveIssuanceJid = resolveIssuanceJid;
-exports.buildTcTokenFromJid = buildTcTokenFromJid;
-exports.storeTcTokensFromIqResult = storeTcTokensFromIqResult;
-const WABinary_1 = require('../WABinary');
+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;
+        return false; // PSA
     if (BOT_PHONE_REGEX.test(user))
-        return false;
-    if ((0, WABinary_1.isJidMetaAI)(jid))
-        return false;
-    return !!((0, WABinary_1.isPnUser)(jid) ||
-        (0, WABinary_1.isLidUser)(jid) ||
-        (0, WABinary_1.isHostedPnUser)(jid) ||
-        (0, WABinary_1.isHostedLidUser)(jid) ||
-        jid.endsWith('@c.us'));
+        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;
-const TC_TOKEN_NUM_BUCKETS = 4;
-exports.TC_TOKEN_INDEX_KEY = '__index';
-async function readTcTokenIndex(keys) {
-    const data = await keys.get('tctoken', [exports.TC_TOKEN_INDEX_KEY]);
-    const entry = data[exports.TC_TOKEN_INDEX_KEY];
+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 !== exports.TC_TOKEN_INDEX_KEY);
+        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY);
     }
     catch {
         return [];
     }
 }
-async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+/** 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 !== exports.TC_TOKEN_INDEX_KEY)
+        if (jid && jid !== TC_TOKEN_INDEX_KEY)
             merged.add(jid);
     }
     return {
-        [exports.TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
     };
 }
-function isTcTokenExpired(timestamp) {
+// 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;
@@ -68,7 +65,7 @@ function isTcTokenExpired(timestamp) {
     const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
     return ts < cutoffTimestamp;
 }
-function shouldSendNewTcToken(senderTimestamp) {
+export function shouldSendNewTcToken(senderTimestamp) {
     if (senderTimestamp === undefined)
         return true;
     const now = Math.floor(Date.now() / 1000);
@@ -76,20 +73,22 @@ function shouldSendNewTcToken(senderTimestamp) {
     const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
     return currentBucket > senderBucket;
 }
-async function resolveTcTokenJid(jid, getLIDForPN) {
-    if ((0, WABinary_1.isLidUser)(jid))
+/** 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;
 }
-async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
     if (issueToLid) {
-        if ((0, WABinary_1.isLidUser)(jid))
+        if (isLidUser(jid))
             return jid;
         const lid = await getLIDForPN(jid);
         return lid ?? jid;
     }
-    if (!(0, WABinary_1.isLidUser)(jid))
+    if (!isLidUser(jid))
         return jid;
     if (getPNForLID) {
         const pn = await getPNForLID(jid);
@@ -97,7 +96,7 @@ async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
     }
     return jid;
 }
-async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
     try {
         const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
         const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
@@ -105,6 +104,9 @@ async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDFor
         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;
@@ -123,16 +125,17 @@ async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDFor
         return baseContent.length > 0 ? baseContent : undefined;
     }
 }
-async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
-    const tokensNode = (0, WABinary_1.getBinaryNodeChild)(result, 'tokens');
+export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
     if (!tokensNode)
         return;
-    const tokenNodes = (0, WABinary_1.getBinaryNodeChildren)(tokensNode, 'token');
+    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);
+        // 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);
@@ -140,6 +143,7 @@ async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForP
         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)
@@ -156,3 +160,4 @@ async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForP
         onNewJidStored?.(storageJid);
     }
 }
+//# sourceMappingURL=tc-token-utils.js.map