@fer2809fl/baileys 7.0.1 → 7.0.4

package/lib/Utils/signal.d.ts

@@ -15,19 +15,6 @@ export declare const generateOrGetPreKeys: (creds: AuthenticationCreds, range: n
 };
 export declare const xmppSignedPreKey: (key: SignedKeyPair) => BinaryNode;
 export declare const xmppPreKey: (pair: KeyPair, id: number) => BinaryNode;
-export declare const extractE2ESessionFromRetryReceipt: (receipt: BinaryNode) => {
-    registrationId: number;
-    identityKey: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
-    signedPreKey: {
-        keyId: number;
-        publicKey: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
-        signature: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
-    };
-    preKey: {
-        keyId: number;
-        publicKey: Uint8Array;
-    } | undefined;
-} | null;
 export declare const parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepositoryWithLIDStore) => Promise<void>;
 export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, myLid: string, excludeZeroDevices: boolean) => FullJid[];
 /**

package/lib/Utils/signal.js

@@ -55,48 +55,6 @@ export const xmppPreKey = (pair, id) => ({
         { 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
         ? {

package/lib/Utils/sticker-pack.d.ts

@@ -0,0 +1,10 @@
+import type { StickerPackContent } from '../Types/Message.js';
+export type MakeStickerPackOptions = StickerPackContent & {
+  contextInfo?: any;
+};
+export declare const makeStickerPack: (
+  options?: MakeStickerPackOptions,
+) => {
+  stickerPack: StickerPackContent;
+  contextInfo?: any;
+};

package/lib/Utils/sticker-pack.js

@@ -0,0 +1,111 @@
+/**
+ * Default emojis assigned to stickers when none are provided.
+ * Rotates through this list by sticker index.
+ */
+const DEFAULT_EMOJIS = [
+  "😀",
+  "😂",
+  "😍",
+  "🔥",
+  "👍",
+  "🎉",
+  "😎",
+  "🤩",
+  "💯",
+  "🥳",
+];
+
+/**
+ * Normalize a single sticker entry.
+ * Input can be:
+ *   - Buffer
+ *   - { url: string }
+ *   - { sticker: Buffer | { url: string }, emojis?: string[], accessibilityLabel?: string }
+ *
+ * @param {Buffer | { url: string } | object} entry
+ * @param {number} index
+ * @returns {{ sticker: Buffer | { url: string }, emojis: string[], accessibilityLabel: string }}
+ */
+const normalizeSticker = (entry, index) => {
+  if (
+    Buffer.isBuffer(entry) ||
+    (entry &&
+      typeof entry === "object" &&
+      "url" in entry &&
+      !("sticker" in entry))
+  ) {
+    return {
+      sticker: entry,
+      emojis: [DEFAULT_EMOJIS[index % DEFAULT_EMOJIS.length]],
+      accessibilityLabel: "",
+    };
+  }
+  return {
+    sticker: entry.sticker || entry.data,
+    emojis: entry.emojis || [DEFAULT_EMOJIS[index % DEFAULT_EMOJIS.length]],
+    accessibilityLabel: entry.accessibilityLabel || "",
+  };
+};
+
+/**
+ * Build a stickerPack message object ready to pass to sock.sendMessage.
+ *
+ * @param {object} options
+ * @param {string} options.name - Pack display name
+ * @param {string} [options.publisher] - Pack publisher/author name
+ * @param {string} [options.description] - Pack description
+ * @param {string} [options.packId] - Custom pack ID (auto-generated if omitted)
+ * @param {Array<Buffer | { url: string } | { sticker: Buffer | { url: string }, emojis?: string[] }>} options.stickers
+ *   List of stickers — accepts raw buffers, URL objects, or full sticker descriptor objects.
+ * @param {Buffer | { url: string }} [options.cover]
+ *   Tray/cover image. Defaults to the first sticker if omitted.
+ * @param {object} [options.contextInfo] - Optional context info (mentions, forwarding, etc.)
+ * @returns {{ stickerPack: object }}
+ *
+ * @example
+ * // With buffers
+ * await sock.sendMessage(jid, makeStickerPack({
+ *     name: 'My Pack',
+ *     stickers: [buf1, buf2, buf3]
+ * }));
+ *
+ * @example
+ * // With URLs
+ * await sock.sendMessage(jid, makeStickerPack({
+ *     name: 'Anime Pack',
+ *     publisher: 'Ourin AI',
+ *     stickers: [
+ *         { url: 'https://example.com/s1.webp', emojis: ['😀'] },
+ *         { url: 'https://example.com/s2.webp' }
+ *     ],
+ *     cover: { url: 'https://example.com/cover.jpg' }
+ * }));
+ */
+export const makeStickerPack = ({
+  name,
+  publisher = "Ourin AI",
+  description = "",
+  packId,
+  stickers = [],
+  cover,
+  contextInfo,
+} = {}) => {
+  if (!name) throw new Error("makeStickerPack: name is required");
+  if (!stickers.length)
+    throw new Error("makeStickerPack: at least one sticker is required");
+
+  const normalizedStickers = stickers.map(normalizeSticker);
+  const resolvedCover = cover ?? normalizedStickers[0].sticker;
+
+  return {
+    stickerPack: {
+      name,
+      publisher,
+      description,
+      ...(packId ? { packId } : {}),
+      stickers: normalizedStickers,
+      cover: resolvedCover,
+    },
+    ...(contextInfo ? { contextInfo } : {}),
+  };
+};

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

@@ -21,7 +21,6 @@ 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.d.ts

@@ -1,37 +1,12 @@
 import type { SignalKeyStoreWithTransaction } from '../Types/index.js';
 import type { BinaryNode } from '../WABinary/index.js';
-/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
-export declare const TC_TOKEN_INDEX_KEY = "__index";
-/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
-export declare function readTcTokenIndex(keys: SignalKeyStoreWithTransaction): Promise<string[]>;
-/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
-export declare function buildMergedTcTokenIndexWrite(keys: SignalKeyStoreWithTransaction, addedJids: Iterable<string>): Promise<{
-    [TC_TOKEN_INDEX_KEY]: {
-        token: Buffer;
-    };
-}>;
-export declare function isTcTokenExpired(timestamp: number | string | null | undefined): boolean;
-export declare function shouldSendNewTcToken(senderTimestamp: number | undefined): boolean;
-/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
-export declare function resolveTcTokenJid(jid: string, getLIDForPN: (pn: string) => Promise<string | null>): Promise<string>;
-/** Resolve target JID for issuing privacy token based on AB prop 14303 */
-export declare function resolveIssuanceJid(jid: string, issueToLid: boolean, getLIDForPN: (pn: string) => Promise<string | null>, getPNForLID?: (lid: string) => Promise<string | null>): Promise<string>;
 type TcTokenParams = {
     jid: string;
     baseContent?: BinaryNode[];
     authState: {
         keys: SignalKeyStoreWithTransaction;
     };
-    getLIDForPN: (pn: string) => Promise<string | null>;
-};
-export declare function buildTcTokenFromJid({ authState, jid, baseContent, getLIDForPN }: TcTokenParams): Promise<BinaryNode[] | undefined>;
-type StoreTcTokensParams = {
-    result: BinaryNode;
-    fallbackJid: string;
-    keys: SignalKeyStoreWithTransaction;
-    getLIDForPN: (pn: string) => Promise<string | null>;
-    onNewJidStored?: (jid: string) => void;
 };
-export declare function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }: StoreTcTokensParams): Promise<void>;
+export declare function buildTcTokenFromJid({ authState, jid, baseContent }: TcTokenParams): Promise<BinaryNode[] | undefined>;
 export {};
 //# sourceMappingURL=tc-token-utils.d.ts.map

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

@@ -1,123 +1,12 @@
-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 }) {
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [] }) {
     try {
-        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
-        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
-        const entry = tcTokenData?.[storageJid];
-        const tcTokenBuffer = entry?.token;
-        const timestamp = entry?.timestamp;
-        if (!tcTokenBuffer?.length || timestamp === undefined || isTcTokenExpired(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 } });
-            }
+        const tcTokenData = await authState.keys.get('tctoken', [jid]);
+        const tcTokenBuffer = tcTokenData?.[jid]?.token;
+        if (!tcTokenBuffer)
             return baseContent.length > 0 ? baseContent : undefined;
-        }
         baseContent.push({
             tag: 'tctoken',
-            attrs: { t: String(timestamp) },
+            attrs: {},
             content: tcTokenBuffer
         });
         return baseContent;
@@ -126,39 +15,4 @@ export async function buildTcTokenFromJid({ authState, jid, baseContent = [], ge
         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.d.ts

@@ -2,7 +2,6 @@ import { proto } from '../../WAProto/index.js';
 import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types/index.js';
 import { type BinaryNode } from '../WABinary/index.js';
 export declare const generateLoginNode: (userJid: string, config: SocketConfig) => proto.IClientPayload;
-export declare const getPlatformType: (platform: string) => proto.DeviceProps.PlatformType;
 export declare const generateRegistrationNode: ({ registrationId, signedPreKey, signedIdentityKey }: SignalCreds, config: SocketConfig) => proto.ClientPayload;
 export declare const configureSuccessfulPairing: (stanza: BinaryNode, { advSecretKey, signedIdentityKey, signalIdentities }: Pick<AuthenticationCreds, "advSecretKey" | "signedIdentityKey" | "signalIdentities">) => {
     creds: Partial<AuthenticationCreds>;

package/lib/Utils/validate-connection.js

@@ -13,9 +13,7 @@ const getUserAgent = (config) => {
             secondary: config.version[1],
             tertiary: config.version[2]
         },
-        platform: config.browser[1].toLocaleLowerCase().includes('android')
-            ? proto.ClientPayload.UserAgent.Platform.ANDROID
-            : proto.ClientPayload.UserAgent.Platform.WEB,
+        platform: proto.ClientPayload.UserAgent.Platform.WEB,
         releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         osVersion: '0.1',
         device: 'Desktop',
@@ -45,12 +43,7 @@ const getClientPayload = (config) => {
         connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config)
     };
-    if (!config.browser[1].toLocaleLowerCase().includes('android')) {
-        payload.webInfo = getWebInfo(config);
-    }
-    if (config.pushName) {
-        payload.pushName = config.pushName;
-    }
+    payload.webInfo = getWebInfo(config);
     return payload;
 };
 export const generateLoginNode = (userJid, config) => {
@@ -66,11 +59,8 @@ export const generateLoginNode = (userJid, config) => {
     };
     return proto.ClientPayload.fromObject(payload);
 };
-export const getPlatformType = (platform) => {
+const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase();
-    if (platformType === 'ANDROID') {
-        return proto.DeviceProps.PlatformType.ANDROID_PHONE;
-    }
     return (proto.DeviceProps.PlatformType[platformType] ||
         proto.DeviceProps.PlatformType.CHROME);
 };

package/lib/WABinary/decode.d.ts

@@ -1,5 +1,5 @@
 import type { BinaryNode, BinaryNodeCodingOptions } from './types.js';
-export declare const decompressingIfRequired: (buffer: Buffer) => Promise<Buffer<ArrayBufferLike>>;
+export declare const decompressingIfRequired: (buffer: Buffer) => Promise<Buffer>;
 export declare const decodeDecompressedBinaryNode: (buffer: Buffer, opts: Pick<BinaryNodeCodingOptions, "DOUBLE_BYTE_TOKENS" | "SINGLE_BYTE_TOKENS" | "TAGS">, indexRef?: {
     index: number;
 }) => BinaryNode;

package/lib/WABinary/generic-utils.d.ts

@@ -3,7 +3,7 @@ import { type BinaryNode } from './types.js';
 export declare const getBinaryNodeChildren: (node: BinaryNode | undefined, childTag: string) => BinaryNode[];
 export declare const getBinaryNodeChild: (node: BinaryNode | undefined, childTag: string) => BinaryNode | undefined;
 export declare const getAllBinaryNodeChildren: ({ content }: BinaryNode) => BinaryNode[];
-export declare const getBinaryNodeChildBuffer: (node: BinaryNode | undefined, childTag: string) => Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike> | undefined;
+export declare const getBinaryNodeChildBuffer: (node: BinaryNode | undefined, childTag: string) => Uint8Array<ArrayBufferLike> | (BinaryNode[] & Buffer) | (string & Buffer) | undefined;
 export declare const getBinaryNodeChildString: (node: BinaryNode | undefined, childTag: string) => string | undefined;
 export declare const getBinaryNodeChildUInt: (node: BinaryNode, childTag: string, length: number) => number | undefined;
 export declare const assertNodeErrorFree: (node: BinaryNode) => void;
@@ -12,4 +12,6 @@ export declare const reduceBinaryNodeToDictionary: (node: BinaryNode, tag: strin
 };
 export declare const getBinaryNodeMessages: ({ content }: BinaryNode) => proto.WebMessageInfo[];
 export declare function binaryNodeToString(node: BinaryNode | BinaryNode['content'], i?: number): string;
+export declare const getBinaryNodeFilter: (node: BinaryNode[] | undefined) => boolean;
+export declare const getAdditionalNode: (name: string) => BinaryNode[];
 //# sourceMappingURL=generic-utils.d.ts.map

package/lib/WABinary/generic-utils.js

@@ -1,5 +1,6 @@
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
+import { unixTimestampSeconds } from '../Utils/generics.js';
 import {} from './types.js';
 // some extra useful utilities
 const indexCache = new WeakMap();
@@ -110,4 +111,81 @@ export function binaryNodeToString(node, i = 0) {
     const content = children ? `>\n${children}\n${tabs(i)}</${node.tag}>` : '/>';
     return tag + content;
 }
+export const getBinaryNodeFilter = (node) => {
+    if (!Array.isArray(node))
+        return false;
+    return node.some((item) => ['native_flow'].includes(item?.content?.[0]?.content?.[0]?.tag) ||
+        ['interactive', 'buttons', 'list'].includes(item?.content?.[0]?.tag) ||
+        ['hsm', 'biz'].includes(item?.tag) ||
+        (['bot'].includes(item?.tag) && item?.attrs?.biz_bot === '1'));
+};
+const ORDER_RESPONSE_NAME = {
+    review_and_pay: 'order_details',
+    review_order: 'order_status',
+    payment_info: 'payment_info',
+    payment_status: 'payment_status',
+    payment_method: 'payment_method'
+};
+const FLOW_NAME = {
+    cta_catalog: 'cta_catalog',
+    mpm: 'mpm',
+    call_request: 'call_permission_request',
+    view_catalog: 'automated_greeting_message_view_catalog',
+    wa_pay_detail: 'wa_payment_transaction_details',
+    send_location: 'send_location'
+};
+export const getAdditionalNode = (name) => {
+    const lowerName = name?.toLowerCase();
+    const ts = unixTimestampSeconds(new Date()) - 77980457;
+    if (ORDER_RESPONSE_NAME[lowerName]) {
+        return [{
+                tag: 'biz',
+                attrs: { native_flow_name: ORDER_RESPONSE_NAME[lowerName] },
+                content: []
+            }];
+    }
+    if (FLOW_NAME[lowerName] || lowerName === 'interactive' || lowerName === 'buttons' || lowerName === 'list') {
+        return [{
+                tag: 'biz',
+                attrs: {
+                    actual_actors: '2',
+                    host_storage: '2',
+                    privacy_mode_ts: `${ts}`
+                },
+                content: [{
+                        tag: 'engagement',
+                        attrs: {
+                            customer_service_state: 'open',
+                            conversation_state: 'open'
+                        }
+                    }, {
+                        tag: 'interactive',
+                        attrs: { type: 'native_flow', v: '1' },
+                        content: [{
+                                tag: 'native_flow',
+                                attrs: {
+                                    v: '9',
+                                    name: FLOW_NAME[lowerName] ?? 'mixed'
+                                },
+                                content: []
+                            }]
+                    }]
+            }];
+    }
+    return [{
+            tag: 'biz',
+            attrs: {
+                actual_actors: '2',
+                host_storage: '2',
+                privacy_mode_ts: `${ts}`
+            },
+            content: [{
+                    tag: 'engagement',
+                    attrs: {
+                        customer_service_state: 'open',
+                        conversation_state: 'open'
+                    }
+                }]
+        }];
+};
 //# sourceMappingURL=generic-utils.js.map

package/lib/WABinary/jid-utils.d.ts

@@ -45,15 +45,4 @@ export declare const isHostedLidUser: (jid: string | undefined) => boolean | und
 export declare const isJidBot: (jid: string | undefined) => boolean | "" | undefined;
 export declare const jidNormalizedUser: (jid: string | undefined) => string;
 export declare const transferDevice: (fromJid: string, toJid: string) => string;
-/**
- * Resuelve el JID objetivo de un comando siguiendo esta prioridad:
- * 1. Mensaje citado (quoted)
- * 2. Primera mención (@usuario)
- * 3. Argumento numérico pasado como texto
- * 4. Remitente del mensaje (fallback)
- *
- * Esto permite detectar y normalizar el JID sin tener que pasar
- * manualmente el número del bot/usuario en cada comando.
- */
-export declare const resolveJid: (m: any, arg?: string) => string;
 //# sourceMappingURL=jid-utils.d.ts.map

package/lib/WABinary/jid-utils.js

@@ -93,37 +93,4 @@ export const transferDevice = (fromJid, toJid) => {
     const { server, user } = jidDecode(toJid);
     return jidEncode(user, server, deviceId);
 };
-/**
- * Resuelve el JID objetivo de un comando siguiendo esta prioridad:
- * 1. Mensaje citado (quoted)
- * 2. Primera mención (@usuario)
- * 3. Argumento numérico pasado como texto
- * 4. Remitente del mensaje (fallback)
- *
- * Esto permite detectar y normalizar el JID sin tener que pasar
- * manualmente el número del bot/usuario en cada comando.
- */
-export const resolveJid = (m, arg = '') => {
-    // 1. Mensaje citado
-    const quoted = m?.quoted?.sender || m?.quoted?.key?.participant || m?.quoted?.participant;
-    if (quoted) {
-        return jidNormalizedUser(quoted);
-    }
-    // 2. Primera mención
-    const menciones = m?.message?.extendedTextMessage?.contextInfo?.mentionedJid ||
-        m?.message?.imageMessage?.contextInfo?.mentionedJid ||
-        [];
-    if (menciones.length > 0) {
-        return jidNormalizedUser(menciones[0]);
-    }
-    // 3. Argumento numérico
-    if (arg) {
-        const num = String(arg).replace(/[^0-9]/g, '');
-        if (num.length >= 7) {
-            return `${num}@s.whatsapp.net`;
-        }
-    }
-    // 4. Fallback al remitente
-    return jidNormalizedUser(m?.sender);
-};
 //# sourceMappingURL=jid-utils.js.map

package/lib/WAM/encode.d.ts

@@ -1,3 +1,3 @@
 import { BinaryInfo } from './BinaryInfo.js';
-export declare const encodeWAM: (binaryInfo: BinaryInfo) => Buffer<ArrayBuffer>;
+export declare const encodeWAM: (binaryInfo: BinaryInfo) => Buffer;
 //# sourceMappingURL=encode.d.ts.map

package/lib/WAUSync/Protocols/USyncContactProtocol.js

@@ -11,34 +11,11 @@ export class USyncContactProtocol {
         };
     }
     getUserElement(user) {
-        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
-                }
-            };
-        }
+        //TODO: Implement type / username fields (not yet supported)
         return {
             tag: 'contact',
-            attrs: {}
+            attrs: {},
+            content: user.phone
         };
     }
     parser(node) {