@itsliaaa/baileys 0.1.33 → 0.2.1

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

@@ -33,6 +33,7 @@ export const DECRYPTION_RETRY_CONFIG = {
     baseDelayMs: 100,
     sessionRecordErrors: ['No session record', 'SessionError: No session record']
 };
+/** NACK reason codes we send to the server (client → server) */
 export const NACK_REASONS = {
     ParsingError: 487,
     UnrecognizedStanza: 488,
@@ -48,6 +49,17 @@ export const NACK_REASONS = {
     UnsupportedLIDGroup: 551,
     DBOperationFailed: 552
 };
+/**
+ * Server-side error codes returned in ack stanzas (server → client) that we
+ * currently have dedicated handlers for. Extend as more handlers are added.
+ * Distinct from the client-side NackReason enum (WAWebCreateNackFromStanza).
+ */
+export const SERVER_ERROR_CODES = {
+    /** 1:1 message missing privacy token (tctoken) */
+    MissingTcToken: '463',
+    /** Stanza validation failure (SMAX_INVALID) — likely stale device session */
+    SmaxInvalid: '479'
+};
 export const extractAddressingContext = (stanza) => {
     let senderAlt;
     let recipientAlt;
@@ -148,10 +160,12 @@ export function decodeMessageNode(stanza, meId, meLid) {
     const key = {
         remoteJid: chatId,
         remoteJidAlt: !isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+        remoteJidUsername: !isJidGroup(chatId) ? stanza.attrs.peer_recipient_username || stanza.attrs.recipient_username : undefined,
         fromMe,
         id: msgId,
         participant,
         participantAlt: isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+        participantUsername: stanza.attrs.participant ? stanza.attrs.participant_username : undefined,
         addressingMode: addressingContext.addressingMode,
         ...(msgType === 'newsletter' && stanza.attrs.server_id ? { server_id: stanza.attrs.server_id } : {})
     };

package/lib/Utils/event-buffer.js

@@ -252,6 +252,7 @@ eventData, logger) {
             data.historySets.empty = false;
             data.historySets.syncType = eventData.syncType;
             data.historySets.progress = eventData.progress;
+            data.historySets.chunkOrder = eventData.chunkOrder;
             data.historySets.peerDataRequestSessionId = eventData.peerDataRequestSessionId;
             data.historySets.isLatest = eventData.isLatest || data.historySets.isLatest;
             break;
@@ -519,6 +520,7 @@ function consolidateEvents(data) {
             syncType: data.historySets.syncType,
             progress: data.historySets.progress,
             isLatest: data.historySets.isLatest,
+            chunkOrder: data.historySets.chunkOrder,
             peerDataRequestSessionId: data.historySets.peerDataRequestSessionId
         };
     }

package/lib/Utils/generics.js

@@ -316,6 +316,15 @@ export const getCallStatusFromNode = ({ tag, attrs }) => {
                 status = 'terminate';
             }
             break;
+        case 'preaccept':
+            status = 'preaccept';
+            break;
+        case 'transport':
+            status = 'transport';
+            break;
+        case 'relaylatency':
+            status = 'relaylatency';
+            break;
         case 'reject':
             status = 'reject';
             break;

package/lib/Utils/history.js

@@ -1,5 +1,6 @@
+import { pipeline } from 'stream/promises';
 import { promisify } from 'util';
-import { inflate } from 'zlib';
+import { createInflate, inflate } from 'zlib';
 import { proto } from '../../WAProto/index.js';
 import { WAMessageStubType } from '../Types/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/index.js';
@@ -24,13 +25,13 @@ const extractPnFromMessages = (messages) => {
 };
 export const downloadHistory = async (msg, options) => {
     const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
-    const bufferArray = [];
-    for await (const chunk of stream) {
-        bufferArray.push(chunk);
-    }
-    let buffer = Buffer.concat(bufferArray);
-    // decompress buffer
-    buffer = await inflatePromise(buffer);
+    // Pipe decrypted stream directly through zlib inflate
+    // This avoids allocating an intermediate buffer for the compressed data
+    const inflater = createInflate();
+    const chunks = [];
+    inflater.on('data', (chunk) => chunks.push(chunk));
+    await pipeline(stream, inflater);
+    const buffer = Buffer.concat(chunks);
     const syncData = proto.HistorySync.decode(buffer);
     return syncData;
 };
@@ -55,6 +56,7 @@ export const processHistoryMessage = (item, logger) => {
                 contacts.push({
                     id: chat.id,
                     name: chat.displayName || chat.name || chat.username || undefined,
+                    username: chat.username || undefined,
                     lid: chat.lidJid || chat.accountLid || undefined,
                     phoneNumber: chat.pnJid || undefined
                 });
@@ -95,7 +97,7 @@ export const processHistoryMessage = (item, logger) => {
                         });
                     }
                 }
-                chats.push({ ...chat });
+                chats.push(chat);
             }
             break;
         case proto.HistorySync.HistorySyncType.PUSH_NAME:

package/lib/Utils/identity-change-handler.js

@@ -37,6 +37,7 @@ export async function handleIdentityChange(node, ctx) {
         ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
         return { action: 'skipped_offline' };
     }
+    ctx.onBeforeSessionRefresh?.(from);
     try {
         await ctx.assertSessions([from], true);
         return { action: 'session_refreshed' };

package/lib/Utils/messages-media.js

@@ -516,7 +516,7 @@ export const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, {
     };
     const output = new Transform({
         transform(chunk, _, callback) {
-            let data = Buffer.concat([remainingBytes, chunk]);
+            let data = remainingBytes.length ? Buffer.concat([remainingBytes, chunk]) : chunk;
             const decryptLength = toSmallestChunkSize(data.length);
             remainingBytes = data.slice(decryptLength);
             data = data.slice(0, decryptLength);

package/lib/Utils/messages.js

@@ -674,6 +674,7 @@ export const generateWAMessageContent = async (message, options) => {
             extContent.description = urlInfo.description;
             extContent.title = urlInfo.title;
             extContent.previewType = urlInfo.previewType ?? 0;
+            extContent.linkPreviewMetadata = urlInfo.linkPreviewMetadata;
             const img = urlInfo.highQualityThumbnail;
             if (img) {
                 extContent.thumbnailDirectPath = img.directPath;
@@ -685,6 +686,19 @@ export const generateWAMessageContent = async (message, options) => {
                 extContent.thumbnailEncSha256 = img.fileEncSha256;
             }
         }
+        let faviconInfo = message.favicon;
+        if (faviconInfo) {
+            faviconInfo = await prepareWAMessageMedia(faviconInfo, options);
+            extContent.faviconMMSMetadata = {
+                thumbnailDirectPath: faviconInfo.directPath,
+                mediaKey: faviconInfo.mediaKey,
+                mediaKeyTimestamp: faviconInfo.mediaKeyTimestamp,
+                thumbnailWidth: 32,
+                thumbnailHeight: 32,
+                thumbnailSha256: faviconInfo.fileSha256,
+                thumbnailEncSha256: faviconInfo.fileEncSha256
+            };
+        }
         if (options.backgroundColor) {
             extContent.backgroundArgb = await assertColor(options.backgroundColor);
         }

package/lib/Utils/process-message.js

@@ -5,6 +5,7 @@ import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJid
 import { aesDecryptGCM, hmacSign } from './crypto.js';
 import { getKeyAuthor, toNumber } from './generics.js';
 import { downloadAndProcessHistorySyncNotification } from './history.js';
+import { buildMergedTcTokenIndexWrite, resolveTcTokenJid } from './tc-token-utils.js';
 const REAL_MSG_STUB_TYPES = new Set([
     WAMessageStubType.CALL_MISSED_GROUP_VIDEO,
     WAMessageStubType.CALL_MISSED_GROUP_VOICE,
@@ -12,6 +13,53 @@ const REAL_MSG_STUB_TYPES = new Set([
     WAMessageStubType.CALL_MISSED_VOICE
 ]);
 const REAL_MSG_REQ_ME_STUB_TYPES = new Set([WAMessageStubType.GROUP_PARTICIPANT_ADD]);
+async function storeTcTokensFromHistorySync(chats, signalRepository, keyStore, logger) {
+    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
+    const candidates = [];
+    for (const chat of chats) {
+        const ts = chat.tcTokenTimestamp ? toNumber(chat.tcTokenTimestamp) : 0;
+        if (chat.tcToken?.length && ts > 0) {
+            const jid = jidNormalizedUser(chat.id);
+            const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+            candidates.push({
+                storageJid,
+                token: Buffer.from(chat.tcToken),
+                ts,
+                senderTs: chat.tcTokenSenderTimestamp ? toNumber(chat.tcTokenSenderTimestamp) : undefined
+            });
+        }
+    }
+    if (!candidates.length) {
+        return;
+    }
+    const jids = candidates.map(c => c.storageJid);
+    const existing = await keyStore.get('tctoken', jids);
+    const entries = {};
+    for (const c of candidates) {
+        const existingEntry = existing[c.storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        if (existingTs > 0 && existingTs >= c.ts) {
+            continue;
+        }
+        entries[c.storageJid] = {
+            ...existingEntry,
+            token: c.token,
+            timestamp: String(c.ts),
+            ...(c.senderTs !== undefined ? { senderTimestamp: c.senderTs } : {})
+        };
+    }
+    if (Object.keys(entries).length) {
+        logger?.debug({ count: Object.keys(entries).length }, 'storing tctokens from history sync');
+        try {
+            // Include updated __index so cross-session pruning picks these JIDs up.
+            const indexWrite = await buildMergedTcTokenIndexWrite(keyStore, Object.keys(entries));
+            await keyStore.set({ tctoken: { ...entries, ...indexWrite } });
+        }
+        catch (err) {
+            logger?.warn({ err }, 'failed to store tctokens from history sync');
+        }
+    }
+};
 /** Cleans a received message to further processing */
 export const cleanMessage = (message, meId, meLid) => {
     // ensure remoteJid and participant doesn't have device or agent in it
@@ -174,9 +222,11 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                             .storeLIDPNMappings(data.lidPnMappings)
                             .catch(err => logger?.warn({ err }, 'failed to store LID-PN mappings from history sync'));
                     }
+                    await storeTcTokensFromHistorySync(data.chats, signalRepository, keyStore, logger);
                     ev.emit('messaging-history.set', {
                         ...data,
                         isLatest: histNotification.syncType !== proto.HistorySync.HistorySyncType.ON_DEMAND ? isLatest : undefined,
+                        chunkOrder: histNotification.chunkOrder,
                         peerDataRequestSessionId: histNotification.peerDataRequestSessionId
                     });
                 }
@@ -383,12 +433,13 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             id: jid,
             author: message.key.participant,
             authorPn: message.key.participantAlt,
+            authorUsername: message.key.participantUsername,
             participants,
             action
         });
         const emitGroupUpdate = (update) => {
             ev.emit('groups.update', [
-                { id: jid, ...update, author: message.key.participant ?? undefined, authorPn: message.key.participantAlt }
+                { id: jid, ...update, author: message.key.participant ?? undefined, authorPn: message.key.participantAlt, authorUsername: message.key.participantUsername }
             ]);
         };
         const emitGroupRequestJoin = (participant, action, method) => {
@@ -396,6 +447,7 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                 id: jid,
                 author: message.key.participant,
                 authorPn: message.key.participantAlt,
+                authorUsername: message.key.participantUsername,
                 participant: participant.lid,
                 participantPn: participant.pn,
                 action,

package/lib/Utils/rich-message-utils.js

@@ -291,7 +291,7 @@ export const prepareRichResponseMessage = (content) => {
                 }));
                 submessages.push({
                     messageType: RichSubMessageType.TEXT,
-                    messageText: linkField.text + `{{${prefix}}}¹{{/${prefix}}}`,
+                    messageText: linkField.text + ` {{${prefix}}}¹{{/${prefix}}} `,
                     inlineEntities: [{
                         key: prefix,
                         metadata: {

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 tcTokenData = await authState.keys.get('tctoken', [jid]);
-        const tcTokenBuffer = tcTokenData?.[jid]?.token;
-        if (!tcTokenBuffer)
+        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 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: {},
@@ -14,4 +124,40 @@ export async function buildTcTokenFromJid({ authState, jid, baseContent = [] })
     catch (error) {
         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/use-single-file-auth-state.js

@@ -4,27 +4,26 @@ import { proto } from '../../WAProto/index.js';
 import { initAuthCreds } from './auth-utils.js';
 import { BufferJSON } from './generics.js';
 import { LRUCache } from 'lru-cache';
+import { Mutex } from 'async-mutex';
 // Lia@Changes 25-03-26 --- Add useSingleFileAuthState with integrated cache
 const FLUSH_TIMEOUT_MS = 3000;
 // Lia@Changes 22-04-26 --- Enhanced useSingleFileAuthState with LRUCache
 export const useSingleFileAuthState = async (fileName) => {
     const cache = new LRUCache({
-        max: 10000,
+        max: 15000,
         ttl: 1000 * DEFAULT_CACHE_TTLS.SIGNAL_STORE,
         updateAgeOnGet: false,
         updateAgeOnHas: false,
         ttlAutopurge: true
     });
-    let fileData = {},
-        isLoaded = false,
-        isWriting = false,
-        isNeedWrite = false,
-        flushTimeout = null,
-        loadPromise = null;
-    const loadKey = () => {
-        if (isLoaded) return;
-        if (loadPromise) return loadPromise;
-        loadPromise = (async () => {
+    // Lia@Changes 26-04-26 --- Add mutex for prevent race condition
+    const mutex = new Mutex();
+    let fileData = {};
+    let isLoaded = false;
+    let flushTimeout = null;
+    const loadKey = async () => {
+        return await mutex.runExclusive(async () => {
+            if (isLoaded) return;
             try {
                 const data = JSON.parse(await readFile(fileName, 'utf-8'), BufferJSON.reviver);
                 fileData = data || {};
@@ -36,26 +35,20 @@ export const useSingleFileAuthState = async (fileName) => {
                 fileData = {};
             }
             isLoaded = true;
-            loadPromise = null;
-        })();
-        return loadPromise;
+        });
     };
     const flushKey = () => {
         if (flushTimeout) return;
         flushTimeout = setTimeout(async () => {
             flushTimeout = null;
-            if (isWriting) {
-                isNeedWrite = true;
-                return;
-            }
-            isWriting = true;
-            do {
-                isNeedWrite = false;
-                const tempFile = fileName + '.temp';
-                await writeFile(tempFile, JSON.stringify(fileData, BufferJSON.replacer));
-                await rename(tempFile, fileName);
-            } while (isNeedWrite);
-            isWriting = false;
+            await mutex.runExclusive(async () => {
+                try {
+                    const tempFile = fileName + '.temp';
+                    await writeFile(tempFile, JSON.stringify(fileData, BufferJSON.replacer));
+                    await rename(tempFile, fileName);
+                }
+                catch { }
+            });
         }, FLUSH_TIMEOUT_MS);
     };
     const writeKey = (keyName, value) => {

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,22 @@
+import { assertNodeErrorFree } from '../../WABinary/index.js';
+import { USyncUser } from '../USyncUser.js';
+export class USyncUsernameProtocol {
+    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;
+    }
+}

package/lib/WAUSync/Protocols/index.js

@@ -1,4 +1,5 @@
 export * from './USyncDeviceProtocol.js';
 export * from './USyncContactProtocol.js';
 export * from './USyncStatusProtocol.js';
-export * from './USyncDisappearingModeProtocol.js';
+export * from './USyncDisappearingModeProtocol.js';
+export * from './USyncUsernameProtocol.js';

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() {
@@ -90,4 +90,8 @@ export class USyncQuery {
         this.protocols.push(new USyncLIDProtocol());
         return this;
     }
+    withUsernameProtocol() {
+        this.protocols.push(new USyncUsernameProtocol());
+        return this;
+    }
 }

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

@@ -1,6 +1,6 @@
 {
    "name": "@itsliaaa/baileys",
-   "version": "0.1.33",
+   "version": "0.2.1",
    "description": "Enhanced Baileys v7 with fixed newsletter media upload, plus support for interactive messages, albums, and more message types.",
    "main": "lib/index.js",
    "type": "module",