kage-baileys 2.0.1 → 3.0.1

package/engine-requirements.js

@@ -1,6 +1,6 @@
 'use strict';
 const [major, minor] = process.versions.node.split('.').map(Number);
 if (major < 22 || (major === 22 && minor < 12)) {
- console.error('Kage Baileys requires Node.js >=22.12.0. Use a supported Node.js LTS release.');
+ console.error('Kage Baileys necesita Node >=22.12.0 por interoperabilidad CommonJS/ESM. Selecciona Node 22 o 24 en el panel. No basta con borrar engines.');
  process.exitCode = 1;
 }

package/lib/Utils/automation-tools.js

@@ -114,7 +114,6 @@ function installKageTools(conn, options = {}) {
   const status = require('./status-tools');
   const country = require('./country-info');
   conn.getReceivedStatuses = (includeUnavailable = false) => status.listStatuses(conn, includeUnavailable);
-  conn.reactToReceivedStatus = (entry, emoji) => status.reactToStatus(conn, entry, emoji);
   conn.getCountryForJid = jid => country.getCountryForJid(conn, jid);
   conn.downloadNormalMedia = (raw, opts) => downloadNormalMedia(conn, raw, opts);
   conn.saveNormalMedia = (raw, opts) => saveNormalMedia(conn, raw, opts);
@@ -150,7 +149,7 @@ function installKageTools(conn, options = {}) {
   conn.enableStatusTracking = (settings = {}) => {
     if (stop) return stop;
     let active = true;
-    const scopedSettings = new Proxy(settings, { get(target, key) { return key === 'statusReaction' ? active && target[key] : target[key]; } });
+    const scopedSettings = new Proxy(settings, { get(target, key) { return key === 'statusSave' ? active && target[key] : target[key]; } });
     const upsert = event => { for (const raw of event?.messages || []) status.handleStatus(raw, conn, scopedSettings).catch(e => conn.logger?.warn?.({ error: e.message }, 'status tracking')); };
     const deleted = event => { for (const key of event?.keys || []) status.markStatusDeleted(conn, key); };
     const updated = items => { for (const item of items || []) if (item.key?.remoteJid === 'status@broadcast' && item.update?.message === null) status.markStatusDeleted(conn, item.key); };

package/lib/Utils/generics.js

@@ -46,7 +46,7 @@ const axios_1 = __importDefault(require("axios"));
 const crypto_1 = require("crypto");
 const os_1 = require("os");
 const WAProto_1 = require("../../WAProto");
-const kage-baileys_version_json_1 = require("../Defaults/kage-baileys-version.json");
+const kageVersionJson = require("../Defaults/wileys-version.json");
 const Types_1 = require("../Types");
 const WABinary_1 = require("../WABinary");
 const COMPANION_PLATFORM_MAP = {
@@ -261,19 +261,22 @@ exports.printQRIfNecessaryListener = printQRIfNecessaryListener;
 
 const fetchLatestKageVersion = async (options = {}) => {
     try {
-        const { data } = await axios_1.default.get('https://registry.npmjs.org/kage-baileys', {
+        const { data } = await axios_1.default.get('https://registry.npmjs.org/kage-baileys/latest', {
+            timeout: 15000,
             ...options,
             responseType: 'json'
         });
-        const versionStr = data.version;  
-        const [major, minor, patch] = versionStr.split('.').map(Number);
+        const versionStr = data.version;
+        const match = /^(\d+)\.(\d+)\.(\d+)/.exec(versionStr || '');
+        if (!match) throw new Error('Invalid Kage package version');
+        const [major, minor, patch] = match.slice(1).map(Number);
         return {
             version: [major, minor, patch],
             isLatest: true
         };
     } catch (error) {
         return {
-            version: kage-baileys_version_json_1.version,  
+            version: require('../../package.json').version.split('-')[0].split('.').map(Number),
             isLatest: false,
             error
         };
@@ -281,26 +284,8 @@ const fetchLatestKageVersion = async (options = {}) => {
 };
 exports.fetchLatestKageVersion = fetchLatestKageVersion;
 
-const fetchLatestBaileysVersion = async (options = {}) => {
-    try {
-        const { data } = await axios_1.default.get('https://registry.npmjs.org/kage-baileys', {
-            ...options,
-            responseType: 'json'
-        });
-        const versionStr = data.version; 
-        const [major, minor, patch] = versionStr.split('.').map(Number);
-        return {
-            version: [major, minor, patch],
-            isLatest: true
-        };
-    } catch (error) {
-        return {
-            version: kage-baileys_version_json_1.version,  
-            isLatest: false,
-            error
-        };
-    }
-};
+// WhatsApp needs its WEB protocol version, not the npm library semver.
+const fetchLatestBaileysVersion = async (options = {}) => fetchLatestWaWebVersion(options);
 exports.fetchLatestBaileysVersion = fetchLatestBaileysVersion;
 
 /**
@@ -310,14 +295,15 @@ exports.fetchLatestBaileysVersion = fetchLatestBaileysVersion;
 const fetchLatestWaWebVersion = async (options) => {
     try {
         const { data } = await axios_1.default.get('https://web.whatsapp.com/sw.js', {
+            timeout: 15000,
             ...options,
-            responseType: 'json'
+            responseType: 'text'
         });
         const regex = /\\?"client_revision\\?":\s*(\d+)/;
         const match = data.match(regex);
         if (!(match === null || match === void 0 ? void 0 : match[1])) {
             return {
-                version: kage-baileys_version_json_1.version,
+                version: kageVersionJson.version,
                 isLatest: false,
                 error: {
                     message: 'Could not find client revision in the fetched content'
@@ -332,7 +318,7 @@ const fetchLatestWaWebVersion = async (options) => {
     }
     catch (error) {
         return {
-            version: kage-baileys_version_json_1.version,
+            version: kageVersionJson.version,
             isLatest: false,
             error
         };

package/lib/Utils/status-tools.js

@@ -2,7 +2,7 @@
 // Estados recibidos por ESTA conexión. No consulta estados ocultos ni audiencias privadas.
 const { mkdirSync, readFileSync, writeFileSync, renameSync, chmodSync } = require('node:fs')
 const { resolve, join } = require('node:path')
-const { createHash, randomInt } = require('node:crypto')
+const { createHash } = require('node:crypto')
 const reportError = (area, error) => console.error(`[${area}]`, error?.message || error)
 const caches = new WeakMap()
 const DAY = 86_400_000
@@ -155,8 +155,9 @@ function captureStatus(raw, conn) {
     viewOnce: !!(old?.viewOnce || info.wrappers.some(w => /viewOnce/.test(w))),
     routes: [...new Set([...(old?.routes || []), raw.key.remoteJid])]
   }
-  state.entries.set(identity, entry); prune(state); persist(state)
-  return entry
+  const stored = old ? Object.assign(old, entry) : entry
+  state.entries.set(identity, stored); prune(state); persist(state)
+  return stored
 }
 function listStatuses(conn, includeUnavailable = false) { const state = stateFor(conn); prune(state); return [...state.entries.values()].filter(e => includeUnavailable || !['deleted', 'expired'].includes(e.availability)).sort((a, b) => a.receivedAt - b.receivedAt) }
 function findStatus(conn, selector = '') {
@@ -164,27 +165,6 @@ function findStatus(conn, selector = '') {
   return listStatuses(conn, true).find(entry => entry.id === id || entry.sourceKey?.id === selector)
 }
 function clearStatuses(conn) { const state = stateFor(conn); const count = state.entries.size; for (const entry of state.entries.values()) retire(entry, 'expired', Date.now()); state.entries.clear(); persist(state); return count }
-function isStatusEmoji(text) {
-  if (typeof text !== 'string' || text.length > 32 || !/\p{Extended_Pictographic}|\p{Regional_Indicator}|\u20e3/u.test(text)) return false
-  return [...new Intl.Segmenter('es', { granularity: 'grapheme' }).segment(text)].length === 1
-}
-async function reactToStatus(conn, entry, emoji, options = {}) {
-  if (!isStatusEmoji(emoji)) throw new Error('Escribe un solo emoji, por ejemplo ❤️, 👍🏽 o 👨‍👩‍👧‍👦.')
-  if (!entry || ['deleted', 'expired'].includes(entry.availability) || entry.expiresAt <= Date.now()) throw new Error('Ese estado ya no está disponible en la caché.')
-  if (!entry.sourceKey?.id || !/@(s\.whatsapp\.net|lid)$/.test(entry.author)) throw new Error('La notificación no incluye la clave y el autor originales; no es posible reaccionar con seguridad.')
-  const self = normalizeJid(conn.user?.jid || conn.user?.id)
-  if (entry.author === self || entry.author === normalizeJid(conn.user?.lid) || entry.sourceKey.fromMe) throw new Error('No se reacciona a los estados de la propia cuenta.')
-  const state = stateFor(conn)
-  if (state.busy) throw new Error('Hay otra reacción en curso; espera unos segundos.')
-  const interval = Math.max(1000, Number(options.intervalMs ?? global.safety?.statusReactionIntervalMs) || 5000)
-  if (Date.now() - state.last < interval) throw new Error('Espera unos segundos entre reacciones.')
-  state.busy = true; state.last = Date.now()
-  try {
-    if (typeof conn.readMessages === 'function') await conn.readMessages([entry.sourceKey])
-    await conn.sendMessage('status@broadcast', { react: { text: emoji, key: entry.sourceKey } }, { statusJidList: [entry.author] })
-    entry.reactedWith = emoji; entry.reactedAt = Date.now(); state.last = Date.now(); persist(state)
-  } finally { state.busy = false }
-}
 async function handleStatus(raw, conn, settings = {}) {
   if (raw?.key?.remoteJid !== 'status@broadcast') return false
   const entry = captureStatus(raw, conn)
@@ -192,27 +172,8 @@ async function handleStatus(raw, conn, settings = {}) {
     try { await require('./status-archive').handleStatusArchive(conn, entry, settings, settings.archiveOptions || {}) }
     catch (error) { reportError('status-archive', error) }
   }
-  if (!entry || !settings.statusReaction || raw.key.fromMe || entry.reactedAt) return true
-  const state = stateFor(conn)
-  state.scheduled ||= new Set()
-  if (state.scheduled.has(entry.id) || state.scheduled.size >= 30) return true
-  state.scheduled.add(entry.id)
-  const task = (state.reactionTail || Promise.resolve()).then(async () => {
-    const gap = Math.max(1000, Number(settings.statusReactionIntervalMs ?? global.safety?.statusReactionIntervalMs) || 5000)
-    const wait = Math.max(0, state.last + gap - Date.now())
-    if (wait) await new Promise(resolve => setTimeout(resolve, wait))
-    if (!settings.statusReaction || entry.reactedAt || ['deleted', 'expired'].includes(entry.availability)) return
-    const pool = Array.isArray(settings.statusEmojis) ? settings.statusEmojis.filter(isStatusEmoji) : ['❤️', '🔥', '👍', '😊', '👏', '💜']
-    const emoji = settings.statusEmojiMode === 'random' ? pool.length ? pool[randomInt(pool.length)] : '❤️' : settings.statusEmoji || '❤️'
-    if (!isStatusEmoji(emoji)) return
-    const self = normalizeJid(conn.user?.jid || conn.user?.id)
-    if (!entry.author || entry.author === self || entry.author === normalizeJid(conn.user?.lid)) return
-    await reactToStatus(conn, entry, emoji, { intervalMs: gap })
-  })
-  state.reactionTail = task.catch(error => reportError('reacciones-estados', error)).finally(() => state.scheduled.delete(entry.id))
   return true
 }
-async function waitStatusReactions(conn) { await stateFor(conn).reactionTail }
 
 exports.markStatusDeleted = markStatusDeleted;
 exports.flushStatuses = flushStatuses;
@@ -221,8 +182,5 @@ exports.captureStatus = captureStatus;
 exports.listStatuses = listStatuses;
 exports.findStatus = findStatus;
 exports.clearStatuses = clearStatuses;
-exports.isStatusEmoji = isStatusEmoji;
-exports.reactToStatus = reactToStatus;
 exports.handleStatus = handleStatus;
 
-exports.waitStatusReactions = waitStatusReactions;

package/lib/index.d.ts

@@ -193,8 +193,8 @@ export declare const extractSyncdPatches: any;
 export declare const extractUrlFromText: any;
 export declare const extractVideoThumb: any;
 export declare const fetchLatestBaileysVersion: any;
+export declare const fetchLatestKageVersion: any;
 export declare const fetchLatestWaWebVersion: any;
-export declare const fetchLatestWileysVersion: any;
 export declare const findStatus: any;
 export declare const flushStatuses: any;
 export declare const generateCodeBlockContent: any;
@@ -283,7 +283,6 @@ export declare const isJidUser: any;
 export declare const isKnownStatusContact: any;
 export declare const isLidUser: any;
 export declare const isRealMessage: any;
-export declare const isStatusEmoji: any;
 export declare const isWABusinessPlatform: any;
 export declare const jidDecode: any;
 export declare const jidEncode: any;
@@ -313,7 +312,6 @@ export declare const processContactAction: any;
 export declare const processHistoryMessage: any;
 export declare const processSyncAction: any;
 export declare const promiseTimeout: any;
-export declare const reactToStatus: any;
 export declare const readAndEmitEventStream: any;
 export declare const reduceBinaryNodeToDictionary: any;
 export declare const resendViewOnceMessage: any;
@@ -344,7 +342,6 @@ export declare const uploadFile: any;
 export declare const useMultiFileAuthState: any;
 export declare const version: any;
 export declare const vid2jpg: any;
-export declare const waitStatusReactions: any;
 export declare const writeRandomPadMax16: any;
 export declare const xmppPreKey: any;
 export declare const xmppSignedPreKey: any;

package/lib/index.js

@@ -95,7 +95,7 @@ for (const __p of __kageExtraModules) {
     try { __kageMergeSafe(require(__p)); } catch (__e) { /* opcional */ }
 }
 try { __kageMergeSafe(require("./VoIP/index.js")); } catch (__e) { /* VoIP opcional */ }
-exports.KAGE_BUILD = Object.freeze({ name: "kage-baileys", version: "1.1.8" });
+exports.KAGE_BUILD = Object.freeze({ name: "kage-baileys", version: "3.0.1" });
 
 __exportStar(require("./Utils/status-tools.js"), exports);
 __exportStar(require("./Utils/country-info.js"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kage-baileys",
-  "version": "2.0.1",
+  "version": "3.0.1",
   "description": "Kage Baileys una libreria de WhatsApp.",
   "keywords": [
     "kage-baileys",
@@ -38,8 +38,9 @@
     "test": "node --test test/*.test.cjs",
     "check": "npm run lint && npm test",
     "example": "node Example/connection.cjs",
-    "preinstall": "node engine-requirements.js",
-    "gen:types": "node scripts/generate-public-types.cjs"
+    "gen:types": "node scripts/generate-public-types.cjs",
+    "check:engine": "node engine-requirements.js",
+    "prepublishOnly": "npm run gen:protobuf && npm run gen:types && npm run check"
   },
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
@@ -71,7 +72,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "protobufjs-cli": "2.7.1",
+    "protobufjs-cli": "^2.7.1",
     "typescript": "^5.8.2"
   },
   "peerDependencies": {

package/test/installation-repair.test.cjs

@@ -0,0 +1,43 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const axios = require('axios');
+const { fetchLatestBaileysVersion, fetchLatestKageVersion } = require('../lib/Utils/generics');
+const fallback = require('../lib/Defaults/wileys-version.json').version;
+async function mocked(get, fn) {
+ const old = axios.get;
+ axios.get = get;
+ try { await fn(); } finally { axios.get = old; }
+}
+test('connection version is WhatsApp WEB revision, not npm library semver', async () => {
+ await mocked(async (url, options) => {
+  assert.equal(url,'https://web.whatsapp.com/sw.js');
+  assert.equal(options.responseType,'text');
+  assert.equal(options.timeout,15000);
+  return {data:'self.config={"client_revision":1043857761}'};
+ }, async () => {
+  assert.deepEqual(await fetchLatestBaileysVersion(),{version:[2,3000,1043857761],isLatest:true});
+ });
+});
+test('network failure retains the included WhatsApp protocol version and original error', async () => {
+ const error = new Error('offline test');
+ await mocked(async () => {throw error}, async () => {
+  const result = await fetchLatestBaileysVersion();
+  assert.deepEqual(result.version,fallback);assert.equal(result.isLatest,false);assert.equal(result.error,error);
+ });
+});
+test('malformed version response cannot pass an undefined or npm version to socket', async () => {
+ await mocked(async () => ({data:'<html>service unavailable</html>'}), async () => {
+  const result = await fetchLatestBaileysVersion();assert.deepEqual(result.version,fallback);assert.equal(result.isLatest,false);
+ });
+});
+test('package update helper requests a real npm version document', async () => {
+ await mocked(async url => {assert.equal(url,'https://registry.npmjs.org/kage-baileys/latest');return {data:{version:'2.0.1'}}},async()=>{
+  const result=await fetchLatestKageVersion();assert.deepEqual(result.version,[2,0,1]);assert.equal(result.isLatest,true);
+ });
+});
+test('package fallback is the installed library version, not a WhatsApp version', async () => {
+ await mocked(async()=>{throw new Error('offline')},async()=>{
+  const result=await fetchLatestKageVersion();assert.deepEqual(result.version,require('../package.json').version.split('.').map(Number));assert.equal(result.isLatest,false);
+ });
+});

package/test/revision.test.cjs

@@ -11,8 +11,6 @@ const countries = require('../lib/Utils/countries.json');
 const examples = require('libphonenumber-js/examples.mobile.json');
 const raw = (id = 'S1', author = '51987654321@s.whatsapp.net', message = { conversation: 'Hola' }) => ({ key: { remoteJid: 'status@broadcast', participant: author, id, fromMe: false }, messageTimestamp: Math.floor(Date.now()/1000), message });
 const socket = () => ({ user: { id: '34612345678:2@s.whatsapp.net' }, statusStorageDir: false, sendMessage: async () => ({}), readMessages: async () => {}, ev: new EventEmitter() });
-for (const emoji of ['❤️','🔥','👍','👍🏽','👨‍👩‍👧‍👦','😊','🇵🇪','1️⃣','💜','👏','🌈','🏳️‍🌈','🧑🏽‍💻','🫶','☀️','⭐','🐕','💯','😀','🎉']) test(`emoji accepted: ${emoji}`, () => assert.equal(api.isStatusEmoji(emoji), true));
-for (const value of ['', 'hola', '❤️🔥', 'a❤️', '123', null, 2, ' ', '\n', '👍 👍', 'x', '🇵🇪🇲🇽', '❤️'.repeat(30)]) test(`emoji rejected: ${JSON.stringify(value)}`, () => assert.equal(api.isStatusEmoji(value), false));
 for (const code of ['PE','MX','ES','AR','CO','CL','EC','BO','BR','US','CA','GB','FR','DE','IT','JP','KR','AU','NZ','IN','ZA','EG','MA','UY','PY','VE','CR','PA','DO','GT']) test(`offline country lookup ${code}`, () => {
   const info = api.getCountryInfo(require('libphonenumber-js').getExampleNumber(code, examples).number);
   assert.ok(info, code); assert.equal(info.code, code); assert.equal(info.name, countries[code].name);
@@ -100,23 +98,6 @@ test('status cache bounded to 500 entries', () => {
   const c = socket(); for (let i=0;i<510;i++) api.captureStatus(raw('id-'+i),c);
   assert.equal(api.listStatuses(c).length,500); assert.equal(api.clearStatuses(c),500);
 });
-test('manual reaction uses status route, real message key and emoji', async () => {
-  const c = socket(); let sent; c.sendMessage = async (...args) => { sent=args; };
-  const e = api.captureStatus(raw(),c); await api.reactToStatus(c,e,'👍🏽');
-  assert.equal(sent[0],'status@broadcast'); assert.equal(sent[1].react.text,'👍🏽'); assert.deepEqual(sent[2].statusJidList,[e.author]);
-});
-test('cannot react to deleted or self statuses', async () => {
-  const c = socket(); const e = api.captureStatus(raw(),c); api.markStatusDeleted(c,e.sourceKey);
-  await assert.rejects(api.reactToStatus(c,e,'🔥'), /disponible/);
-  const self = api.captureStatus(raw('self','34612345678@s.whatsapp.net'),c);
-  await assert.rejects(api.reactToStatus(c,self,'🔥'), /propia cuenta/);
-});
-test('random reaction uses configured emoji pool and deduplicates delivery', async () => {
-  const c = socket(); const sent=[]; c.sendMessage=async (...args) => { sent.push(args); };
-  const settings = { statusReaction:true,statusEmojiMode:'random',statusEmojis:['🔥','💜'] };
-  await api.handleStatus(raw(),c,settings); await api.handleStatus(raw(),c,settings); await api.waitStatusReactions(c);
-  assert.equal(sent.length,1); assert.ok(settings.statusEmojis.includes(sent[0][1].react.text));
-});
 test('socket bindings install and detach status listeners without duplicates', async () => {
   const c = socket(); api.installKageTools(c); api.installKageTools(c);
   const stop = c.enableStatusTracking(); assert.equal(c.enableStatusTracking(),stop); assert.equal(c.ev.listenerCount('messages.upsert'),1);
@@ -140,14 +121,6 @@ test('browser presets support documented calls and missing browser', () => {
   assert.equal(api.Browsers().length,3); assert.doesNotThrow(()=>api.getPlatformId());
 });
 
-test('automatic reaction queue processes a burst with configured pacing', async () => {
-  const c = socket(); const sent=[];
-  c.sendMessage = async (...args) => { sent.push({ time: Date.now(), args }); };
-  const settings = { statusReaction: true, statusEmoji: '🔥', statusReactionIntervalMs: 1000 };
-  await api.handleStatus(raw('first'), c, settings); await api.handleStatus(raw('second'), c, settings);
-  await api.waitStatusReactions(c);
-  assert.equal(sent.length,2); assert.ok(sent[1].time - sent[0].time >= 990);
-});
 test('detaching status tracking never overwrites persisted activation setting', () => {
   const c = socket(); api.installKageTools(c); const settings = { statusReaction: true };
   const stop = c.enableStatusTracking(settings); stop(); stop();

package/test/status-policy.test.cjs

@@ -0,0 +1,40 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const api = require('../lib');
+const raw = id => ({ key: { remoteJid: 'status@broadcast', participant: '51987654321@s.whatsapp.net', id }, messageTimestamp: Math.floor(Date.now()/1000), message: { conversation: 'estado' } });
+const socket = () => ({ user: { id: '34612345678@s.whatsapp.net' }, statusStorageDir: false, ev: new EventEmitter(), sent: [], async sendMessage(...args) { this.sent.push(args); } });
+test('Baileys has no application-level status reaction exports or socket method', () => {
+  for (const name of ['reactToStatus', 'waitStatusReactions', 'isStatusEmoji']) assert.equal(api[name], undefined);
+  const conn = api.installKageTools(socket());
+  assert.equal(conn.reactToReceivedStatus, undefined);
+});
+test('statusReaction settings never send reactions from Baileys', async () => {
+  const conn = socket();
+  await api.handleStatus(raw('A'), conn, { statusReaction: true, statusEmoji: '🔥' });
+  await api.handleStatus(raw('A'), conn, { statusReaction: true });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(conn.sent.length, 0);
+  assert.equal(api.listStatuses(conn).length, 1);
+});
+test('optional status tracking only records received statuses', async () => {
+  const conn = api.installKageTools(socket());
+  const stop = conn.enableStatusTracking({ statusReaction: true });
+  conn.ev.emit('messages.upsert', { type: 'notify', messages: [raw('B')] });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(conn.sent.length, 0);
+  assert.equal(conn.getReceivedStatuses().length, 1);
+  stop();
+  assert.equal(conn.ev.listenerCount('messages.upsert'), 0);
+});
+test('official status reaction schema survives encoding and decoding', () => {
+  const source = { reactionMessage: { key: { remoteJid: 'status@broadcast', participant: '51987654321@s.whatsapp.net', id: 'ORIGINAL', fromMe: false }, text: '❤️', senderTimestampMs: '1770000000000' } };
+  const message = api.proto.Message.fromObject(source);
+  assert.equal(api.proto.Message.verify(message), null);
+  const decoded = api.proto.Message.decode(api.proto.Message.encode(message).finish());
+  assert.equal(decoded.reactionMessage.text, '❤️');
+  assert.equal(decoded.reactionMessage.key.id, 'ORIGINAL');
+  assert.equal(decoded.reactionMessage.key.remoteJid, 'status@broadcast');
+  assert.equal(api.proto.MessageAssociation.AssociationType.STATUS_REACTION, 18);
+});