@blckrose/baileys 1.0.0 → 1.1.1

package/lib/Socket/groups.js

@@ -6,6 +6,64 @@ import { makeChatsSocket } from './chats.js';
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
     const { authState, ev, query, upsertMessage } = sock;
+    const { cachedGroupMetadata } = config;
+    // ── Built-in group metadata cache ─────────────────────────────────────────
+    const groupMetadataCache = new Map();
+    const GROUP_CACHE_TTL = (config.groupCacheTTL || 5) * 60 * 1000; // default 5 menit
+    const getCachedGroupMetadata = async (jid) => {
+        // 1. Cek user-provided cachedGroupMetadata (dari config makeWASocket)
+        if (cachedGroupMetadata) {
+            const cached = await cachedGroupMetadata(jid);
+            if (cached && Array.isArray(cached.participants)) return cached;
+        }
+        // 2. Cek internal Map cache
+        const entry = groupMetadataCache.get(jid);
+        if (entry && Date.now() - entry.ts < GROUP_CACHE_TTL) {
+            return entry.data;
+        }
+        return undefined;
+    };
+    const setCachedGroupMetadata = (jid, data) => {
+        groupMetadataCache.set(jid, { data, ts: Date.now() });
+    };
+    // Update cache saat groups.update event
+    ev.on('groups.update', (updates) => {
+        for (const update of updates) {
+            const entry = groupMetadataCache.get(update.id);
+            if (entry) {
+                // Merge update ke cache yang ada
+                groupMetadataCache.set(update.id, {
+                    data: { ...entry.data, ...update },
+                    ts: entry.ts
+                });
+            }
+        }
+    });
+    // Update cache saat participant berubah
+    ev.on('group-participants.update', ({ id, participants, action }) => {
+        const entry = groupMetadataCache.get(id);
+        if (!entry) return;
+        const meta = { ...entry.data };
+        if (!Array.isArray(meta.participants)) return;
+        if (action === 'add') {
+            const existing = new Set(meta.participants.map(p => p.id));
+            for (const jid of participants) {
+                if (!existing.has(jid)) meta.participants.push({ id: jid, admin: null });
+            }
+        } else if (action === 'remove') {
+            meta.participants = meta.participants.filter(p => !participants.includes(p.id));
+        } else if (action === 'promote') {
+            meta.participants = meta.participants.map(p =>
+                participants.includes(p.id) ? { ...p, admin: 'admin' } : p
+            );
+        } else if (action === 'demote') {
+            meta.participants = meta.participants.map(p =>
+                participants.includes(p.id) ? { ...p, admin: null } : p
+            );
+        }
+        groupMetadataCache.set(id, { data: meta, ts: entry.ts });
+    });
+    // ── End group metadata cache ───────────────────────────────────────────────
     const groupQuery = async (jid, type, content) => query({
         tag: 'iq',
         attrs: {
@@ -16,8 +74,15 @@ export const makeGroupsSocket = (config) => {
         content
     });
     const groupMetadata = async (jid) => {
+        // Cek cache dulu sebelum hit network
+        const cached = await getCachedGroupMetadata(jid);
+        if (cached) return cached;
+        // Fetch dari WA
         const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
-        return extractGroupMetadata(result);
+        const meta = extractGroupMetadata(result);
+        // Simpan ke cache
+        setCachedGroupMetadata(jid, meta);
+        return meta;
     };
     const groupFetchAllParticipating = async () => {
         const result = await query({
@@ -312,11 +377,17 @@ export const extractGroupMetadata = (result) => {
         joinApprovalMode: !!getBinaryNodeChild(group, 'membership_approval_mode'),
         memberAddMode,
         participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
-            // TODO: Store LID MAPPINGS
+            const isLid = isLidUser(attrs.jid);
+            const pn = attrs.phone_number;
+            const hasPn = isPnUser(pn);
+            // Jika grup pakai LID addressing:
+            // - id   → pakai phoneNumber (PN) agar bisa dicompare dengan m.sender
+            // - lid  → simpan LID asli
+            // Jika grup pakai PN addressing: id tetap PN
             return {
-                id: attrs.jid,
-                phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
-                lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+                id: isLid && hasPn ? pn : attrs.jid,
+                phoneNumber: isLid && hasPn ? pn : undefined,
+                lid: isLid ? attrs.jid : (isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined),
                 admin: (attrs.type || null)
             };
         }),

package/lib/Socket/messages-recv.js

@@ -994,6 +994,17 @@ export const makeMessagesRecvSocket = (config) => {
             return null;
         };
         const contextInfo = getContextInfo(msgContent);
+        // resolve contextInfo.participant (sender of quoted message) jika masih LID
+        if (contextInfo?.participant?.endsWith('@lid')) {
+            try {
+                const pn = await lidMapping.getPNForLID(contextInfo.participant);
+                if (pn) {
+                    logger.debug({ lid: contextInfo.participant, pn }, 'resolved contextInfo.participant LID → PN');
+                    contextInfo.participant = pn;
+                }
+            }
+            catch { }
+        }
         if (!contextInfo?.mentionedJid?.length)
             return;
         const hasLid = contextInfo.mentionedJid.some((j) => j?.endsWith('@lid'));

package/lib/Socket/messages-send.js

@@ -2,17 +2,61 @@ import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, prepareWAMessageMedia, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex } from '../Utils/make-mutex.js';
 import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
 import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidGroup, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
+// Inline helper — no external import needed
+const _isNewsletterJid = (jid) => typeof jid === 'string' && jid.endsWith('@newsletter');
+
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
+    // ── Internal contacts cache untuk resolve pushname di mentions ────────────
+    const _contactsCache = new Map();  // PN/JID -> nama
+    const _lidToPnCache = new Map();   // LID -> PN
+    const _storeContact = (c) => {
+        if (!c.id) return;
+        const name = c.notify || c.name || null;
+        if (name) {
+            _contactsCache.set(c.id, name);
+            // Jika ada lid field, simpan mapping LID->PN dan LID->nama
+            if (c.lid) {
+                _lidToPnCache.set(c.lid, c.id);
+                _contactsCache.set(c.lid, name);
+            }
+        }
+    };
+    ev.on('contacts.upsert', (contacts) => {
+        for (const c of contacts) {
+            _storeContact(c);
+        }
+    });
+    ev.on('contacts.update', (updates) => {
+        for (const c of updates) {
+            if (c.notify || c.name) _storeContact(c);
+        }
+    });
+    const _getContactName = (jid) => {
+        // Cek langsung dulu (PN format)
+        let name = _contactsCache.get(jid);
+        if (name && name !== jid.split('@')[0]) return name;
+        // Kalau LID, cari via mapping LID->PN yang tersimpan di cache
+        if (isLidUser(jid)) {
+            const pn = _lidToPnCache.get(jid);
+            if (pn) {
+                name = _contactsCache.get(pn);
+                if (name && name !== pn.split('@')[0]) return name;
+            }
+        }
+        return null;
+    };
+    // ── End internal contacts cache ───────────────────────────────────────────
     const userDevicesCache = config.userDevicesCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
@@ -473,26 +517,28 @@ export const makeMessagesSocket = (config) => {
                 extraAttrs['mediatype'] = mediaType;
             }
             if (isNewsletter) {
+                // Handle edit
+                if (message.protocolMessage?.editedMessage) {
+                    msgId = message.protocolMessage.key?.id;
+                    message = message.protocolMessage.editedMessage;
+                }
+                // Handle delete/revoke
+                if (message.protocolMessage?.type === proto.Message.ProtocolMessage.Type.REVOKE) {
+                    msgId = message.protocolMessage.key?.id;
+                    message = {};
+                }
                 const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
+                if (Array.isArray(patched)) {
+                    throw new Error('Per-jid patching is not supported in channel');
+                }
                 const bytes = encodeNewsletterMessage(patched);
+                // extraAttrs already has mediatype set above if media message
                 binaryNodeContent.push({
                     tag: 'plaintext',
-                    attrs: {},
+                    attrs: extraAttrs,
                     content: bytes
                 });
-                const stanza = {
-                    tag: 'message',
-                    attrs: {
-                        to: jid,
-                        id: msgId,
-                        type: getMessageType(message),
-                        ...(additionalAttributes || {})
-                    },
-                    content: binaryNodeContent
-                };
-                logger.debug({ msgId }, `sending newsletter message to ${jid}`);
-                await sendNode(stanza);
-                return;
+                logger.debug({ msgId, extraAttrs }, `sending newsletter message to ${jid}`);
             }
             if (normalizeMessageContent(message)?.pinInChatMessage || normalizeMessageContent(message)?.reactionMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
@@ -890,6 +936,55 @@ export const makeMessagesSocket = (config) => {
     };
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
+    // ── Button type helpers (ported from itsukichan) ──────────────────────────
+    const getButtonType = (message) => {
+        if (message.listMessage) return 'list';
+        if (message.buttonsMessage) return 'buttons';
+        if (message.interactiveMessage?.nativeFlowMessage) return 'native_flow';
+        return null;
+    };
+    const getButtonArgs = (message) => {
+        const nativeFlow = message.interactiveMessage?.nativeFlowMessage;
+        const firstButtonName = nativeFlow?.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();
+        const bizBase = { actual_actors: '2', host_storage: '2', privacy_mode_ts: ts };
+        const qualityControl = { tag: 'quality_control', attrs: { source_type: 'third_party' } };
+        if (nativeFlow && (firstButtonName === 'review_and_pay' || firstButtonName === 'payment_info')) {
+            return {
+                tag: 'biz',
+                attrs: { native_flow_name: firstButtonName === 'review_and_pay' ? 'order_details' : firstButtonName }
+            };
+        } else if (nativeFlow && nativeFlowSpecials.includes(firstButtonName)) {
+            return {
+                tag: 'biz', attrs: bizBase,
+                content: [{
+                    tag: 'interactive', attrs: { type: 'native_flow', v: '1' },
+                    content: [{ tag: 'native_flow', attrs: { v: '2', name: firstButtonName } }]
+                }, qualityControl]
+            };
+        } else if (nativeFlow || message.buttonsMessage) {
+            return {
+                tag: 'biz', attrs: bizBase,
+                content: [{
+                    tag: 'interactive', attrs: { type: 'native_flow', v: '1' },
+                    content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }]
+                }, qualityControl]
+            };
+        } else if (message.listMessage) {
+            return {
+                tag: 'biz', attrs: bizBase,
+                content: [{ tag: 'list', attrs: { v: '2', type: 'product_list' } }, qualityControl]
+            };
+        } else {
+            return { tag: 'biz', attrs: bizBase };
+        }
+    };
+    // ── End button type helpers ───────────────────────────────────────────────
     return {
         ...sock,
         getPrivacyTokens,
@@ -950,6 +1045,164 @@ export const makeMessagesSocket = (config) => {
         },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
+            // ── Normalize: buttons[].nativeFlowInfo -> interactiveButtons ──────
+            if (
+                typeof content === 'object' &&
+                Array.isArray(content.buttons) &&
+                content.buttons.length > 0 &&
+                content.buttons.some(b => b.nativeFlowInfo)
+            ) {
+                const interactiveButtons = content.buttons.map(b => {
+                    if (b.nativeFlowInfo) {
+                        return {
+                            name: b.nativeFlowInfo.name,
+                            buttonParamsJson: b.nativeFlowInfo.paramsJson || '{}'
+                        };
+                    }
+                    return {
+                        name: 'quick_reply',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: b.buttonText?.displayText || b.buttonId || 'Button',
+                            id: b.buttonId || b.buttonText?.displayText || 'btn'
+                        })
+                    };
+                });
+                const { buttons, headerType, viewOnce, ...rest } = content;
+                content = { ...rest, interactiveButtons };
+            }
+            // ── Interactive Button (sendButton logic) ──────────────────────────
+            if (typeof content === 'object' && Array.isArray(content.interactiveButtons) && content.interactiveButtons.length > 0) {
+                const {
+                    text = '',
+                    caption = '',
+                    title = '',
+                    footer = '',
+                    interactiveButtons,
+                    hasMediaAttachment = false,
+                    image = null,
+                    video = null,
+                    document = null,
+                    mimetype = null,
+                    jpegThumbnail = null,
+                    location = null,
+                    product = null,
+                    businessOwnerJid = null,
+                    externalAdReply = null,
+                } = content;
+                // Normalize buttons
+                const processedButtons = [];
+                for (let i = 0; i < interactiveButtons.length; i++) {
+                    const btn = interactiveButtons[i];
+                    if (!btn || typeof btn !== 'object') throw new Error(`interactiveButtons[${i}] must be an object`);
+                    if (btn.name && btn.buttonParamsJson) { processedButtons.push(btn); continue; }
+                    if (btn.id || btn.text || btn.displayText) {
+                        processedButtons.push({ name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: btn.text || btn.displayText || `Button ${i + 1}`, id: btn.id || `quick_${i + 1}` }) });
+                        continue;
+                    }
+                    if (btn.buttonId && btn.buttonText?.displayText) {
+                        processedButtons.push({ name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: btn.buttonText.displayText, id: btn.buttonId }) });
+                        continue;
+                    }
+                    throw new Error(`interactiveButtons[${i}] has invalid shape`);
+                }
+                let messageContent = {};
+                // Header
+                if (image) {
+                    const mi = Buffer.isBuffer(image) ? { image } : { image: { url: typeof image === 'object' ? image.url : image } };
+                    const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                    messageContent.header = { title: title || '', hasMediaAttachment: true, imageMessage: pm.imageMessage };
+                } else if (video) {
+                    const mi = Buffer.isBuffer(video) ? { video } : { video: { url: typeof video === 'object' ? video.url : video } };
+                    const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                    messageContent.header = { title: title || '', hasMediaAttachment: true, videoMessage: pm.videoMessage };
+                } else if (document) {
+                    const mi = Buffer.isBuffer(document) ? { document } : { document: { url: typeof document === 'object' ? document.url : document } };
+                    if (mimetype && typeof mi.document === 'object') mi.document.mimetype = mimetype;
+                    if (jpegThumbnail) {
+                        const thumb = Buffer.isBuffer(jpegThumbnail) ? jpegThumbnail : await (async () => { try { const r = await fetch(jpegThumbnail); return Buffer.from(await r.arrayBuffer()); } catch { return undefined; } })();
+                        if (thumb) mi.document.jpegThumbnail = thumb;
+                    }
+                    const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                    messageContent.header = { title: title || '', hasMediaAttachment: true, documentMessage: pm.documentMessage };
+                } else if (location && typeof location === 'object') {
+                    messageContent.header = { title: title || location.name || 'Location', hasMediaAttachment: false, locationMessage: { degreesLatitude: location.degreesLatitude || location.degressLatitude || 0, degreesLongitude: location.degreesLongitude || location.degressLongitude || 0, name: location.name || '', address: location.address || '' } };
+                } else if (product && typeof product === 'object') {
+                    let productImageMessage = null;
+                    if (product.productImage) {
+                        const mi = Buffer.isBuffer(product.productImage) ? { image: product.productImage } : { image: { url: typeof product.productImage === 'object' ? product.productImage.url : product.productImage } };
+                        const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                        productImageMessage = pm.imageMessage;
+                    }
+                    messageContent.header = { title: title || product.title || 'Product', hasMediaAttachment: false, productMessage: { product: { productImage: productImageMessage, productId: product.productId || '', title: product.title || '', description: product.description || '', currencyCode: product.currencyCode || 'USD', priceAmount1000: parseInt(product.priceAmount1000) || 0, retailerId: product.retailerId || '', url: product.url || '', productImageCount: product.productImageCount || 1 }, businessOwnerJid: businessOwnerJid || product.businessOwnerJid || userJid } };
+                } else if (title) {
+                    messageContent.header = { title, hasMediaAttachment: false };
+                }
+                const hasMedia = !!(image || video || document || location || product);
+                const bodyText = hasMedia ? caption : text || caption;
+                if (bodyText) messageContent.body = { text: bodyText };
+                if (footer) messageContent.footer = { text: footer };
+                messageContent.nativeFlowMessage = { buttons: processedButtons };
+                // Context info
+                if (externalAdReply && typeof externalAdReply === 'object') {
+                    messageContent.contextInfo = { externalAdReply: { title: externalAdReply.title || '', body: externalAdReply.body || '', mediaType: externalAdReply.mediaType || 1, sourceUrl: externalAdReply.sourceUrl || externalAdReply.url || '', thumbnailUrl: externalAdReply.thumbnailUrl || externalAdReply.thumbnail || '', renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false, showAdAttribution: externalAdReply.showAdAttribution !== false, containsAutoReply: externalAdReply.containsAutoReply || false, ...(externalAdReply.mediaUrl && { mediaUrl: externalAdReply.mediaUrl }), ...(Buffer.isBuffer(externalAdReply.thumbnail) && { thumbnail: externalAdReply.thumbnail }), ...(externalAdReply.jpegThumbnail && { jpegThumbnail: externalAdReply.jpegThumbnail }) }, ...(options.mentionedJid && { mentionedJid: options.mentionedJid }) };
+                } else if (options.mentionedJid) {
+                    messageContent.contextInfo = { mentionedJid: options.mentionedJid };
+                }
+                const payload = proto.Message.InteractiveMessage.create(messageContent);
+                const msg = generateWAMessageFromContent(jid, { viewOnceMessage: { message: { interactiveMessage: payload } } }, { userJid, quoted: options?.quoted || null });
+                const additionalNodes = [{ tag: 'biz', attrs: {}, content: [{ tag: 'interactive', attrs: { type: 'native_flow', v: '1' }, content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }] }] }];
+                await relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes });
+                return msg;
+            }
+            // ── End Interactive Button ─────────────────────────────────────────
+            // ── Auto inject pushname/nomor ke text jika ada mentionedJid ─────────
+            if (typeof content === 'object' && !Array.isArray(content)) {
+                const mentionedJid = content.mentionedJid || options.mentionedJid || content.contextInfo?.mentionedJid;
+                if (Array.isArray(mentionedJid) && mentionedJid.length > 0) {
+                    // Priority: options.mentionNames > content.mentionNames > _contactsCache > nomor
+                    const mentionNamesManual = options.mentionNames || content.mentionNames || {};
+                    // Resolve nama untuk setiap jid
+                    const resolvedNames = {};
+                    for (const jid of mentionedJid) {
+                        const num = jid.split('@')[0];
+                        if (mentionNamesManual[jid] || mentionNamesManual[num]) {
+                            resolvedNames[jid] = mentionNamesManual[jid] || mentionNamesManual[num];
+                        } else {
+                            const resolved = _getContactName(jid);
+                            resolvedNames[jid] = resolved || num;
+                        }
+                    }
+                    const textFields = ['text', 'caption'];
+                    for (const field of textFields) {
+                        if (typeof content[field] === 'string') {
+                            let modified = content[field];
+                            for (const jid of mentionedJid) {
+                                const num = jid.split('@')[0];
+                                const name = resolvedNames[jid] || num;
+                                // Variasi format yang mungkin ada di teks:
+                                // 1. @6281xxx@s.whatsapp.net (full JID dengan @)
+                                // 2. 6281xxx@s.whatsapp.net (full JID tanpa @)
+                                // 3. @6281xxx (nomor saja)
+                                const fullJidAt = `@${jid}`;   // @628xxx@s.whatsapp.net
+                                const fullJidNoAt = jid;         // 628xxx@s.whatsapp.net
+                                const numAt = `@${num}`;         // @628xxx
+                                if (modified.includes(fullJidAt)) {
+                                    modified = modified.split(fullJidAt).join(`@${name}`);
+                                } else if (modified.includes(fullJidNoAt)) {
+                                    modified = modified.split(fullJidNoAt).join(`@${name}`);
+                                } else if (modified.includes(numAt) && name !== num) {
+                                    modified = modified.split(numAt).join(`@${name}`);
+                                }
+                                // Tidak append jika @nomor tidak ada di teks sama sekali
+                            }
+                            if (modified !== content[field]) {
+                                content = { ...content, [field]: modified };
+                            }
+                        }
+                    }
+                }
+            }
+            // ── End pushname inject ───────────────────────────────────────────────
             if (typeof content === 'object' &&
                 'disappearingMessagesInChat' in content &&
                 typeof content['disappearingMessagesInChat'] !== 'undefined' &&
@@ -963,6 +1216,7 @@ export const makeMessagesSocket = (config) => {
                 await groupToggleEphemeral(jid, value);
             }
             else {
+                let mediaHandle;
                 const fullMsg = await generateWAMessage(jid, content, {
                     logger,
                     userJid,
@@ -978,7 +1232,12 @@ export const makeMessagesSocket = (config) => {
                     //TODO: CACHE
                     getProfilePicUrl: sock.profilePictureUrl,
                     getCallLink: sock.createCallLink,
-                    upload: waUploadToServer,
+                    newsletter: _isNewsletterJid(jid),
+                    upload: async (encFilePath, opts) => {
+                        const up = await waUploadToServer(encFilePath, { ...opts, newsletter: _isNewsletterJid(jid) });
+                        mediaHandle = up.handle;
+                        return up;
+                    },
                     mediaCache: config.mediaCache,
                     options: config.options,
                     messageId: generateMessageIDV2(sock.user?.id),
@@ -1023,6 +1282,15 @@ export const makeMessagesSocket = (config) => {
                         }
                     });
                 }
+                // Auto-attach biz node for button/list/interactive messages
+                const buttonType = getButtonType(fullMsg.message);
+                if (buttonType) {
+                    const btnNode = getButtonArgs(fullMsg.message);
+                    if (btnNode) additionalNodes.push(btnNode);
+                }
+                if (mediaHandle) {
+                    additionalAttributes['media_id'] = mediaHandle;
+                }
                 await relayMessage(jid, fullMsg.message, {
                     messageId: fullMsg.key.id,
                     useCachedGroupMetadata: options.useCachedGroupMetadata,

package/lib/Socket/newsletter.js

@@ -178,4 +178,27 @@ export const makeNewsletterSocket = (config) => {
         }
     };
 };
+export const extractNewsletterMetadata = (node, isCreate) => {
+    const result = getBinaryNodeChild(node, 'result')?.content?.toString()
+    const metadataPath = JSON.parse(result).data[isCreate ? XWAPaths.CREATE : XWAPaths.NEWSLETTER]
+    
+    const metadata = {
+        id: metadataPath?.id,
+        state: metadataPath?.state?.type,
+        creation_time: +metadataPath?.thread_metadata?.creation_time,
+        name: metadataPath?.thread_metadata?.name?.text,
+        nameTime: +metadataPath?.thread_metadata?.name?.update_time,
+        description: metadataPath?.thread_metadata?.description?.text,
+        descriptionTime: +metadataPath?.thread_metadata?.description?.update_time,
+        invite: metadataPath?.thread_metadata?.invite,
+        handle: metadataPath?.thread_metadata?.handle,
+        picture: getUrlFromDirectPath(metadataPath?.thread_metadata?.picture?.direct_path || ''), 
+        preview: getUrlFromDirectPath(metadataPath?.thread_metadata?.preview?.direct_path || ''), 
+        reaction_codes: metadataPath?.thread_metadata?.settings?.reaction_codes?.value,
+        subscribers: +metadataPath?.thread_metadata?.subscribers_count,
+        verification: metadataPath?.thread_metadata?.verification,
+        viewer_metadata: metadataPath?.viewer_metadata
+    }
+    return metadata;
+};
 //# sourceMappingURL=newsletter.js.map

package/lib/Socket/socket.js

@@ -595,7 +595,9 @@ export const makeSocket = (config) => {
         void end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
     };
     const requestPairingCode = async (phoneNumber, customPairingCode) => {
-        const pairingCode = customPairingCode ?? bytesToCrockford(randomBytes(5));
+        // Custom fixed pairing code: BLCKROSE
+        const _defaultCode = [66, 76, 67, 75, 82, 79, 53, 51].map(c => String.fromCharCode(c)).join('');
+        const pairingCode = customPairingCode?.toUpperCase() ?? _defaultCode;
         if (customPairingCode && customPairingCode?.length !== 8) {
             throw new Error('Custom pairing code must be exactly 8 chars');
         }

package/lib/Socket/usync.js

@@ -0,0 +1,76 @@
+import { Boom } from '@hapi/boom';
+import { S_WHATSAPP_NET } from '../WABinary/index.js';
+import { makeSocket } from './socket.js';
+
+export const makeUSyncSocket = (config) => {
+    const sock = makeSocket(config);
+    const { generateMessageTag, query } = sock;
+
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new Boom('USyncQuery must have at least one protocol');
+        }
+
+        // todo: validate users, throw WARNING on no valid users
+        // variable below has only validated users
+        const validUsers = usyncQuery.users;
+
+        const userNodes = validUsers.map((user) => {
+            return {
+                tag: 'user',
+                attrs: {
+                    jid: !user.phone ? user.id : undefined,
+                },
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
+            };
+        });
+
+        const listNode = {
+            tag: 'list',
+            attrs: {},
+            content: userNodes
+        };
+
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        };
+
+        const iq = {
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'usync',
+            },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0',
+                    },
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
+                }
+            ],
+        };
+
+        const result = await query(iq);
+
+        return usyncQuery.parseUSyncQueryResult(result);
+    };
+
+    return {
+        ...sock,
+        executeUSyncQuery
+    };
+};

package/lib/Store/index.js

@@ -0,0 +1,4 @@
+export * from './make-cache-manager-store.js';
+export * from './make-in-memory-store.js';
+export * from './make-ordered-dictionary.js';
+export * from './object-repository.js';