@japofc/baileys 2.1.0

package/lib/Utils/business.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export function uploadingNecessaryImagesOfProduct(product: any, waUploadToServer: any, timeoutMs?: number): Promise<any>;
+export function parseCatalogNode(node: any): {
+    products: any;
+    nextPageCursor: any;
+};
+export function parseCollectionsNode(node: any): {
+    collections: any;
+};
+export function parseOrderDetailsNode(node: any): {
+    price: {
+        total: number;
+        currency: any;
+    };
+    products: any;
+};
+export function toProductNode(productId: any, product: any): {
+    tag: string;
+    attrs: {
+        compliance_category: string;
+        is_hidden: any;
+    };
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function parseProductNode(productNode: any): {
+    id: any;
+    imageUrls: {
+        requested: any;
+        original: any;
+    };
+    reviewStatus: {
+        whatsapp: any;
+    };
+    availability: string;
+    name: any;
+    retailerId: any;
+    url: any;
+    description: any;
+    price: number;
+    currency: any;
+    isHidden: boolean;
+};
+export function uploadingNecessaryImages(images: any, waUploadToServer: any, timeoutMs?: number): Promise<any[]>;

package/lib/Utils/business.js

@@ -0,0 +1,239 @@
+import { Boom } from '@hapi/boom';
+import { createHash } from 'crypto';
+import { createWriteStream, promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString } from '../WABinary/index.js';
+import { generateMessageIDV2 } from './generics.js';
+import logger from './logger.js';
+import { getStream, getUrlFromDirectPath } from './messages-media.js';
+export const parseCatalogNode = (node) => {
+    const catalogNode = getBinaryNodeChild(node, 'product_catalog');
+    const products = getBinaryNodeChildren(catalogNode, 'product').map(parseProductNode);
+    const paging = getBinaryNodeChild(catalogNode, 'paging');
+    return {
+        products,
+        nextPageCursor: paging ? getBinaryNodeChildString(paging, 'after') : undefined
+    };
+};
+export const parseCollectionsNode = (node) => {
+    const collectionsNode = getBinaryNodeChild(node, 'collections');
+    const collections = getBinaryNodeChildren(collectionsNode, 'collection').map(collectionNode => {
+        const id = getBinaryNodeChildString(collectionNode, 'id');
+        const name = getBinaryNodeChildString(collectionNode, 'name');
+        const products = getBinaryNodeChildren(collectionNode, 'product').map(parseProductNode);
+        return {
+            id,
+            name,
+            products,
+            status: parseStatusInfo(collectionNode)
+        };
+    });
+    return {
+        collections
+    };
+};
+export const parseOrderDetailsNode = (node) => {
+    const orderNode = getBinaryNodeChild(node, 'order');
+    const products = getBinaryNodeChildren(orderNode, 'product').map(productNode => {
+        const imageNode = getBinaryNodeChild(productNode, 'image');
+        return {
+            id: getBinaryNodeChildString(productNode, 'id'),
+            name: getBinaryNodeChildString(productNode, 'name'),
+            imageUrl: getBinaryNodeChildString(imageNode, 'url'),
+            price: +getBinaryNodeChildString(productNode, 'price'),
+            currency: getBinaryNodeChildString(productNode, 'currency'),
+            quantity: +getBinaryNodeChildString(productNode, 'quantity')
+        };
+    });
+    const priceNode = getBinaryNodeChild(orderNode, 'price');
+    const orderDetails = {
+        price: {
+            total: +getBinaryNodeChildString(priceNode, 'total'),
+            currency: getBinaryNodeChildString(priceNode, 'currency')
+        },
+        products
+    };
+    return orderDetails;
+};
+export const toProductNode = (productId, product) => {
+    const attrs = {};
+    const content = [];
+    if (typeof productId !== 'undefined') {
+        content.push({
+            tag: 'id',
+            attrs: {},
+            content: Buffer.from(productId)
+        });
+    }
+    if (typeof product.name !== 'undefined') {
+        content.push({
+            tag: 'name',
+            attrs: {},
+            content: Buffer.from(product.name)
+        });
+    }
+    if (typeof product.description !== 'undefined') {
+        content.push({
+            tag: 'description',
+            attrs: {},
+            content: Buffer.from(product.description)
+        });
+    }
+    if (typeof product.retailerId !== 'undefined') {
+        content.push({
+            tag: 'retailer_id',
+            attrs: {},
+            content: Buffer.from(product.retailerId)
+        });
+    }
+    if (product.images.length) {
+        content.push({
+            tag: 'media',
+            attrs: {},
+            content: product.images.map(img => {
+                if (!('url' in img)) {
+                    throw new Boom('Expected img for product to already be uploaded', { statusCode: 400 });
+                }
+                return {
+                    tag: 'image',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'url',
+                            attrs: {},
+                            content: Buffer.from(img.url.toString())
+                        }
+                    ]
+                };
+            })
+        });
+    }
+    if (typeof product.price !== 'undefined') {
+        content.push({
+            tag: 'price',
+            attrs: {},
+            content: Buffer.from(product.price.toString())
+        });
+    }
+    if (typeof product.currency !== 'undefined') {
+        content.push({
+            tag: 'currency',
+            attrs: {},
+            content: Buffer.from(product.currency)
+        });
+    }
+    if ('originCountryCode' in product) {
+        if (typeof product.originCountryCode === 'undefined') {
+            attrs['compliance_category'] = 'COUNTRY_ORIGIN_EXEMPT';
+        }
+        else {
+            content.push({
+                tag: 'compliance_info',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'country_code_origin',
+                        attrs: {},
+                        content: Buffer.from(product.originCountryCode)
+                    }
+                ]
+            });
+        }
+    }
+    if (typeof product.isHidden !== 'undefined') {
+        attrs['is_hidden'] = product.isHidden.toString();
+    }
+    const node = {
+        tag: 'product',
+        attrs,
+        content
+    };
+    return node;
+};
+export const parseProductNode = (productNode) => {
+    const isHidden = productNode.attrs.is_hidden === 'true';
+    const id = getBinaryNodeChildString(productNode, 'id');
+    const mediaNode = getBinaryNodeChild(productNode, 'media');
+    const statusInfoNode = getBinaryNodeChild(productNode, 'status_info');
+    const product = {
+        id,
+        imageUrls: parseImageUrls(mediaNode),
+        reviewStatus: {
+            whatsapp: getBinaryNodeChildString(statusInfoNode, 'status')
+        },
+        availability: 'in stock',
+        name: getBinaryNodeChildString(productNode, 'name'),
+        retailerId: getBinaryNodeChildString(productNode, 'retailer_id'),
+        url: getBinaryNodeChildString(productNode, 'url'),
+        description: getBinaryNodeChildString(productNode, 'description'),
+        price: +getBinaryNodeChildString(productNode, 'price'),
+        currency: getBinaryNodeChildString(productNode, 'currency'),
+        isHidden
+    };
+    return product;
+};
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 30000) {
+    product = {
+        ...product,
+        images: product.images
+            ? await uploadingNecessaryImages(product.images, waUploadToServer, timeoutMs)
+            : product.images
+    };
+    return product;
+}
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export const uploadingNecessaryImages = async (images, waUploadToServer, timeoutMs = 30000) => {
+    const results = await Promise.all(images.map(async (img) => {
+        if ('url' in img) {
+            const url = img.url.toString();
+            if (url.includes('.whatsapp.net')) {
+                return { url };
+            }
+        }
+        const { stream } = await getStream(img);
+        const hasher = createHash('sha256');
+        const filePath = join(tmpdir(), 'img' + generateMessageIDV2());
+        const encFileWriteStream = createWriteStream(filePath);
+        // JAP@Fix (bug 61): no 'error' listener meant a write failure (e.g. disk
+        // full) would surface as an unhandled 'error' event instead of rejecting
+        // this promise; and the stream was never closed before unlink() below.
+        const writeStreamError = new Promise((_, reject) => encFileWriteStream.on('error', reject));
+        for await (const block of stream) {
+            hasher.update(block);
+            encFileWriteStream.write(block);
+        }
+        await Promise.race([
+            new Promise((resolve) => encFileWriteStream.end(resolve)),
+            writeStreamError
+        ]);
+        const sha = hasher.digest('base64');
+        const { directPath } = await waUploadToServer(filePath, {
+            mediaType: 'product-catalog-image',
+            fileEncSha256B64: sha,
+            timeoutMs
+        });
+        await fs.unlink(filePath).catch(err => logger.warn({ err, filePath }, 'JAP@Fix (bug 57): error deleting temp file')); // was console.log
+        return { url: getUrlFromDirectPath(directPath) };
+    }));
+    return results;
+};
+const parseImageUrls = (mediaNode) => {
+    const imgNode = getBinaryNodeChild(mediaNode, 'image');
+    return {
+        requested: getBinaryNodeChildString(imgNode, 'request_image_url'),
+        original: getBinaryNodeChildString(imgNode, 'original_image_url')
+    };
+};
+const parseStatusInfo = (mediaNode) => {
+    const node = getBinaryNodeChild(mediaNode, 'status_info');
+    return {
+        status: getBinaryNodeChildString(node, 'status'),
+        canAppeal: getBinaryNodeChildString(node, 'can_appeal') === 'true'
+    };
+};

package/lib/Utils/button-helper-utils.d.ts

@@ -0,0 +1,53 @@
+import type { BinaryNode } from '../WABinary/index.js';
+
+export type DetectedMediaType =
+    | 'image' | 'gif' | 'video' | 'ptt' | 'audio' | 'vcard' | 'document'
+    | 'contact_array' | 'livelocation' | 'sticker' | 'list' | 'list_response'
+    | 'buttons_response' | 'order' | 'product' | 'native_flow_response' | 'url' | '';
+
+export type DetectedMessageType = 'reaction' | 'poll' | 'event' | 'media' | 'text';
+export type DetectedButtonType = 'list' | 'buttons' | 'native_flow' | undefined;
+
+export declare function getMediaType(message: any): DetectedMediaType;
+export declare function getMessageType(message: any): DetectedMessageType;
+export declare function getButtonType(message: any): DetectedButtonType;
+/** Derive the binary node(s) that must accompany a button/interactive/list message. */
+export declare function getButtonArgs(message: any): BinaryNode;
+/** Build contextInfo for @mention or @all. */
+export declare const buildMentionContextInfo: (message: any) => {
+    contextInfo: Record<string, any>;
+};
+/** Extract embedded media from buttons/interactive message (top-level or header-nested). */
+export declare const extractFromButtonsMessage: (msg: any) => {
+    imageMessage?: any;
+    videoMessage?: any;
+    documentMessage?: any;
+} | null;
+/** Normalise media input: string → { url }, Buffer → as-is, others → as-is. */
+export declare const normalizeMediaInput: (media: any) => any;
+/** Wrap buttons/template/list/interactive in viewOnceMessageV2Extension for MD clients. */
+export declare const patchMessageForMdIfRequired: (message: any) => any;
+
+export interface AlbumMessageOptions {
+    userJid: string;
+    /** Socket surface used for relay + upload (`sock`). */
+    suki: any;
+}
+
+/** Build and relay an album (multi-image/video) message. Returns the individual media WAMessages. */
+export declare const prepareAlbumMessageContent: (jid: string, albums: any[], options: AlbumMessageOptions) => Promise<any[]>;
+
+export interface MessageExtrasContext {
+    query: (...args: any[]) => Promise<any>;
+    newsletterWMexQuery?: (...args: any[]) => Promise<any>;
+}
+
+export interface MessageExtrasAddon {
+    /** Fetch profile picture URL for any JID, including newsletters. */
+    profilePictureUrl: (jid: string) => Promise<string | null>;
+    /** Query the ephemeral (disappearing messages) timer for a group. 0 if not set. */
+    getEphemeralGroup: (jid: string) => Promise<number | string>;
+}
+
+/** Addon factory for socket-level message extras (profilePictureUrl, getEphemeralGroup). */
+export declare const makeMessageExtrasAddon: (ctx: MessageExtrasContext) => MessageExtrasAddon;

package/lib/Utils/button-helper-utils.js

@@ -0,0 +1,312 @@
+// Evernight AI — lib/Utils/button-helper-utils.js / Creator : J.AP
+// Converted TS -> JS ESM to match @japofc/baileys compiled-lib conventions.
+
+import { randomBytes } from 'crypto';
+import { generateWAMessage, generateWAMessageFromContent, normalizeMessageContent } from './messages.js';
+import { getUrlFromDirectPath } from './messages-media.js';
+import { unixTimestampSeconds } from './generics.js';
+import { getBinaryNodeChild, isJidGroup, isJidNewsletter, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { QueryIds, XWAPaths } from '../Types/Mex.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SECTION 1 — Message Type Detection
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** @param {import('../../WAProto/index.js').proto.IMessage} message */
+export function getMediaType(message) {
+	if (message.imageMessage) return 'image';
+	if (message.videoMessage) return message.videoMessage.gifPlayback ? 'gif' : 'video';
+	if (message.audioMessage) return message.audioMessage.ptt ? 'ptt' : 'audio';
+	if (message.contactMessage) return 'vcard';
+	if (message.documentMessage) return 'document';
+	if (message.contactsArrayMessage) return 'contact_array';
+	if (message.liveLocationMessage) return 'livelocation';
+	if (message.stickerMessage) return 'sticker';
+	if (message.listMessage) return 'list';
+	if (message.listResponseMessage) return 'list_response';
+	if (message.buttonsResponseMessage) return 'buttons_response';
+	if (message.orderMessage) return 'order';
+	if (message.productMessage) return 'product';
+	if (message.interactiveResponseMessage) return 'native_flow_response';
+	if (message.groupInviteMessage) return 'url';
+	return '';
+}
+
+/** @param {import('../../WAProto/index.js').proto.IMessage} message */
+export function getMessageType(message) {
+	const normalizedMessage = normalizeMessageContent(message);
+	if (!normalizedMessage) return 'text';
+	if (normalizedMessage.reactionMessage || normalizedMessage.encReactionMessage) return 'reaction';
+	if (
+		normalizedMessage.pollCreationMessage ||
+		normalizedMessage.pollCreationMessageV2 ||
+		normalizedMessage.pollCreationMessageV3 ||
+		normalizedMessage.pollUpdateMessage
+	)
+		return 'poll';
+	if (normalizedMessage.eventMessage) return 'event';
+	if (getMediaType(normalizedMessage) !== '') return 'media';
+	return 'text';
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SECTION 2 — Button / Biz Node Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** @param {import('../../WAProto/index.js').proto.IMessage} message */
+export function getButtonType(message) {
+	const inner = message.viewOnceMessageV2Extension?.message || message;
+	if (inner.listMessage) return 'list';
+	if (inner.buttonsMessage) return 'buttons';
+	if (inner.interactiveMessage?.nativeFlowMessage) return 'native_flow';
+	if (inner.interactiveMessage?.carouselMessage) return 'native_flow';
+	if (message.viewOnceMessage?.message?.interactiveMessage?.carouselMessage) return 'native_flow';
+	if (message.viewOnceMessageV2?.message?.interactiveMessage?.carouselMessage) return 'native_flow';
+	if (message.viewOnceMessage?.message?.interactiveMessage?.nativeFlowMessage) return 'native_flow';
+	if (message.viewOnceMessageV2?.message?.interactiveMessage?.nativeFlowMessage) return 'native_flow';
+	if (message.viewOnceMessageV2Extension?.message?.interactiveMessage?.nativeFlowMessage) return 'native_flow';
+	if (message.viewOnceMessageV2Extension?.message?.interactiveMessage?.carouselMessage) return 'native_flow';
+	return undefined;
+}
+
+/**
+ * Derive the binary node(s) that must accompany a button/interactive/list
+ * message so it renders correctly across WA Messenger + WA Business,
+ * Android + iOS.
+ * @param {import('../../WAProto/index.js').proto.IMessage} message
+ * @returns {import('../WABinary/index.js').BinaryNode}
+ */
+export function getButtonArgs(message) {
+	const inner = message.viewOnceMessageV2Extension?.message || message;
+	const nativeFlow =
+		inner.interactiveMessage?.nativeFlowMessage ||
+		message.viewOnceMessage?.message?.interactiveMessage?.nativeFlowMessage ||
+		message.viewOnceMessageV2?.message?.interactiveMessage?.nativeFlowMessage;
+	const carouselMessage =
+		inner.interactiveMessage?.carouselMessage ||
+		message.viewOnceMessage?.message?.interactiveMessage?.carouselMessage ||
+		message.viewOnceMessageV2?.message?.interactiveMessage?.carouselMessage;
+
+	const firstButtonName =
+		nativeFlow?.buttons?.[0]?.name ||
+		carouselMessage?.cards?.[0]?.nativeFlowMessage?.buttons?.[0]?.name;
+	const nativeFlowSpecials = [
+		'mpm',
+		'cta_catalog',
+		'send_location',
+		'call_permission_request',
+		'wa_payment_transaction_details',
+		'automated_greeting_message_view_catalog'
+	];
+	const ts = unixTimestampSeconds().toString();
+	if (nativeFlow && (firstButtonName === 'review_and_pay' || firstButtonName === 'payment_info')) {
+		return {
+			tag: 'biz',
+			attrs: { native_flow_name: firstButtonName === 'review_and_pay' ? 'order_details' : firstButtonName }
+		};
+	}
+
+	if (nativeFlow && nativeFlowSpecials.includes(firstButtonName ?? '')) {
+		return {
+			tag: 'biz',
+			attrs: { actual_actors: '2', host_storage: '2', privacy_mode_ts: ts },
+			content: [
+				{
+					tag: 'interactive',
+					attrs: { type: 'native_flow', v: '1' },
+					content: [{ tag: 'native_flow', attrs: { v: '2', name: firstButtonName } }]
+				},
+				{ tag: 'quality_control', attrs: { source_type: 'third_party' } }
+			]
+		};
+	}
+
+	if (nativeFlow || carouselMessage || message.buttonsMessage) {
+		return {
+			tag: 'biz',
+			attrs: {},
+			content: [
+				{
+					tag: 'interactive',
+					attrs: { type: 'native_flow', v: '1' },
+					content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }]
+				}
+			]
+		};
+	}
+
+	if (inner.listMessage) {
+		return { tag: 'biz', attrs: {}, content: [{ tag: 'list', attrs: { v: '2', type: 'product_list' } }] };
+	}
+
+	return { tag: 'biz', attrs: {} };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SECTION 3 — WS Extras (mentions, media, MD patch, album, socket extras)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Build contextInfo for @mention or @all. */
+export const buildMentionContextInfo = (message) => {
+	if (message.mentionAll) return { contextInfo: { nonJidMentions: 1 } };
+	if (message.mentions?.length) return { contextInfo: { mentionedJid: message.mentions } };
+	return { contextInfo: {} };
+};
+
+/** Extract embedded media from buttons/interactive message (top-level or header-nested). */
+export const extractFromButtonsMessage = (msg) => {
+	const header = typeof msg.header === 'object' && msg.header !== null;
+	if (header ? msg.header?.imageMessage : msg.imageMessage)
+		return { imageMessage: header ? msg.header.imageMessage : msg.imageMessage };
+	if (header ? msg.header?.videoMessage : msg.videoMessage)
+		return { videoMessage: header ? msg.header.videoMessage : msg.videoMessage };
+	if (header ? msg.header?.documentMessage : msg.documentMessage)
+		return { documentMessage: header ? msg.header.documentMessage : msg.documentMessage };
+	return null;
+};
+
+/** Normalise media input: string → { url }, Buffer → as-is, others → as-is. */
+export const normalizeMediaInput = (media) => {
+	if (!media) return media;
+	if (Buffer.isBuffer(media)) return media;
+	if (typeof media === 'string') return { url: media };
+	return media;
+};
+
+/** Wrap buttons/template/list/interactive in viewOnceMessageV2Extension for MD clients. */
+export const patchMessageForMdIfRequired = (message) => {
+	if (
+		message?.buttonsMessage ||
+		message?.templateMessage ||
+		message?.listMessage ||
+		message?.interactiveMessage?.nativeFlowMessage
+	) {
+		return {
+			viewOnceMessageV2Extension: {
+				message: {
+					messageContextInfo: { deviceListMetadataVersion: 2, deviceListMetadata: {} },
+					...message
+				}
+			}
+		};
+	}
+
+	return message;
+};
+
+/**
+ * Build and relay an album (multi-image/video) message.
+ * @param {string} jid
+ * @param {Array<object>} albums
+ * @param {{ userJid: string, suki: { relayMessage: Function, waUploadToServer: Function } }} options
+ * @returns {Promise<Array<object>>} Array of individual media WAMessage objects
+ * @example
+ * const items = await prepareAlbumMessageContent(jid, [
+ *     { image: { url: 'https://...' }, caption: 'Photo 1' },
+ *     { video: { url: 'https://...' }, caption: 'Video 1' }
+ * ], { userJid: sock.user.id, suki: sock })
+ */
+export const prepareAlbumMessageContent = async (jid, albums, options) => {
+	const messages = [];
+
+	const albumMsg = generateWAMessageFromContent(
+		jid,
+		{
+			albumMessage: {
+				expectedImageCount: albums.filter((item) => 'image' in item).length,
+				expectedVideoCount: albums.filter((item) => 'video' in item).length
+			}
+		},
+		{ userJid: options.userJid }
+	);
+
+	await options.suki.relayMessage(jid, albumMsg.message, { messageId: albumMsg.key.id });
+
+	for (const media of albums) {
+		let mediaMsg;
+		const uploadFn = async (encFilePath, opts) => {
+			const res = await options.suki.waUploadToServer(encFilePath, {
+				...opts,
+				newsletter: isJidNewsletter(jid)
+			});
+			return {
+				mediaUrl: res.url ?? '',
+				directPath: res.directPath ?? '',
+				handle: res.handle,
+				mediaKey: res.mediaKey,
+				fileEncSha256: res.fileEncSha256,
+				fileSha256: res.fileSha256,
+				fileLength: res.fileLength
+			};
+		};
+
+		const sharedOpts = { userJid: options.userJid, upload: uploadFn };
+
+		if ('image' in media && media.image) mediaMsg = await generateWAMessage(jid, media, sharedOpts);
+		else if ('video' in media && media.video) mediaMsg = await generateWAMessage(jid, media, sharedOpts);
+
+		if (mediaMsg) {
+			mediaMsg.message.messageContextInfo = {
+				messageSecret: randomBytes(32),
+				messageAssociation: { associationType: 1, parentMessageKey: albumMsg.key }
+			};
+			messages.push(mediaMsg);
+		}
+	}
+
+	return messages;
+};
+
+/**
+ * Addon factory for socket-level message extras (profilePictureUrl, getEphemeralGroup).
+ * @param {{ query: Function, newsletterWMexQuery?: Function }} ctx
+ */
+export const makeMessageExtrasAddon = (ctx) => {
+	const { query, newsletterWMexQuery } = ctx;
+
+	/**
+	 * Fetch profile picture URL for any JID, including newsletters.
+	 * @example
+	 * const url = await sock.profilePictureUrl('1234567890@s.whatsapp.net')
+	 */
+	const profilePictureUrl = async (jid) => {
+		if (isJidNewsletter(jid) && newsletterWMexQuery) {
+			const node = await newsletterWMexQuery(undefined, QueryIds.METADATA, {
+				input: { key: jid, type: 'JID', view_role: 'GUEST' },
+				fetch_viewer_metadata: true,
+				fetch_full_image: true,
+				fetch_creation_time: true
+			});
+			const resultStr = getBinaryNodeChild(node, 'result')?.content?.toString();
+			if (!resultStr) return null;
+
+			const metadata = JSON.parse(resultStr).data[XWAPaths.xwa2_newsletter_metadata];
+			return getUrlFromDirectPath(metadata?.thread_metadata?.picture?.direct_path || '');
+		}
+
+		const result = await query({
+			tag: 'iq',
+			attrs: { target: jidNormalizedUser(jid), to: S_WHATSAPP_NET, type: 'get', xmlns: 'w:profile:picture' },
+			content: [{ tag: 'picture', attrs: { type: 'image', query: 'url' }, content: undefined }]
+		});
+		return getBinaryNodeChild(result, 'picture')?.attrs?.url || null;
+	};
+
+	/**
+	 * Query the ephemeral (disappearing messages) timer for a group.
+	 * @returns {Promise<number|string>} timer in seconds, or 0 if not set
+	 * @example
+	 * const timer = await sock.getEphemeralGroup('120363xxx@g.us')
+	 */
+	const getEphemeralGroup = async (jid) => {
+		if (!isJidGroup(jid)) throw new TypeError('Jid should originate from a group!');
+		const result = await query({
+			tag: 'iq',
+			attrs: { id: `ephemeral-${Date.now()}`, to: jid, type: 'get', xmlns: 'w:g2' },
+			content: [{ tag: 'query', attrs: { request: 'interactive' }, content: undefined }]
+		});
+		return getBinaryNodeChild(getBinaryNodeChild(result, 'group'), 'ephemeral')?.attrs?.expiration || 0;
+	};
+
+	return { profilePictureUrl, getEphemeralGroup };
+};