@omnizap-system/omnizap 2.5.12

package/app/modules/rpgPokemonModule/rpgEvolutionUtils.js

@@ -0,0 +1,22 @@
+const toInt = (value, fallback = 0) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.trunc(parsed) : fallback;
+};
+
+export const registerEvolutionPokedexEntry = async ({ ownerJid, evolutionOutcome, connection = null, registerEntry }) => {
+  if (typeof registerEntry !== 'function') {
+    throw new Error('registerEntry é obrigatório para registrar evolução na Pokédex.');
+  }
+
+  const evolvedPokeId = toInt(evolutionOutcome?.updatePayload?.pokeId, 0);
+  if (!ownerJid || evolvedPokeId <= 0) return false;
+
+  await registerEntry(
+    {
+      ownerJid,
+      pokeId: evolvedPokeId,
+    },
+    connection,
+  );
+  return true;
+};

package/app/modules/rpgPokemonModule/rpgPokemonAiHelpService.js

@@ -0,0 +1,14 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createModuleAiHelpWrapper } from '../../services/ai/moduleAiHelpWrapperFactory.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const rpgPokemonAiHelpWrapper = createModuleAiHelpWrapper({
+  moduleKey: 'rpg_pokemon',
+  moduleLabel: 'comandos de rpg pokemon',
+  envPrefix: 'RPG_POKEMON_AI_HELP',
+  moduleDirPath: __dirname,
+  moduleNameFallback: 'rpgPokemonModule',
+});

package/app/modules/rpgPokemonModule/rpgPokemonCommand.js

@@ -0,0 +1,174 @@
+import { sendAndStore } from '../../services/messaging/messagePersistenceService.js';
+import { resolveUserIdCached } from '../../config/index.js';
+import logger from '#logger';
+import { buildRpgHelpText, buildUsageText } from './rpgPokemonMessages.js';
+import { executeRpgPokemonAction } from './rpgPokemonService.js';
+import { getRpgPokemonUsageText } from './rpgPokemonConfigRuntime.js';
+
+const ALLOWED_ACTIONS = new Set(['help', 'ajuda', 'start', 'perfil', 'explorar', 'atacar', 'capturar', 'fugir', 'time', 'escolher', 'loja', 'comprar', 'usar', 'bolsa', 'pokedex', 'evolucao', 'evolução', 'missoes', 'missões', 'viajar', 'tm', 'berry', 'raid', 'desafiar', 'pvp', 'ginasio', 'ginásio', 'trade', 'coop', 'evento', 'social', 'karma', 'engajamento']);
+const HELP_ACTIONS = new Set(['help', 'ajuda']);
+
+const getContextInfo = (messageInfo) => {
+  const root = messageInfo?.message;
+  if (!root || typeof root !== 'object') return null;
+
+  for (const value of Object.values(root)) {
+    if (value?.contextInfo && typeof value.contextInfo === 'object') {
+      return value.contextInfo;
+    }
+    if (value?.message && typeof value.message === 'object') {
+      for (const nested of Object.values(value.message)) {
+        if (nested?.contextInfo && typeof nested.contextInfo === 'object') {
+          return nested.contextInfo;
+        }
+      }
+    }
+  }
+
+  return null;
+};
+
+const extractMentionedJids = (messageInfo) => {
+  const contextInfo = getContextInfo(messageInfo);
+  if (!Array.isArray(contextInfo?.mentionedJid)) return [];
+  return Array.from(new Set(contextInfo.mentionedJid.filter((jid) => typeof jid === 'string' && jid.trim())));
+};
+
+const resolveOwnerJid = ({ senderJid, senderIdentity }) => {
+  if (senderIdentity && typeof senderIdentity === 'object') {
+    const resolved = resolveUserIdCached({
+      jid: senderIdentity?.jid || senderJid || null,
+      lid: senderIdentity?.participant || senderIdentity?.jid || senderJid || null,
+      participantAlt: senderIdentity?.participantAlt || null,
+    });
+
+    if (resolved) return resolved;
+  }
+
+  if (senderJid && typeof senderJid === 'string') {
+    return (
+      resolveUserIdCached({
+        jid: senderJid,
+        lid: senderJid,
+        participantAlt: null,
+      }) || senderJid
+    );
+  }
+
+  return null;
+};
+
+export const handleRpgPokemonCommand = async ({ sock, remoteJid, messageInfo, expirationMessage, senderJid, senderIdentity = null, args = [], commandPrefix = '/' }) => {
+  const action = String(args?.[0] || '')
+    .trim()
+    .toLowerCase();
+
+  if (!action) {
+    await sendAndStore(sock, remoteJid, { text: buildRpgHelpText(commandPrefix) }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+    return;
+  }
+
+  if (HELP_ACTIONS.has(action)) {
+    await sendAndStore(sock, remoteJid, { text: buildRpgHelpText(commandPrefix) }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+    return;
+  }
+
+  if (!ALLOWED_ACTIONS.has(action)) {
+    const usageText = getRpgPokemonUsageText('rpg', { commandPrefix }) || buildUsageText(commandPrefix);
+    await sendAndStore(
+      sock,
+      remoteJid,
+      {
+        text: `${usageText}\n\nUse um subcomando válido depois de ${commandPrefix}rpg.\nGuia completo: ${commandPrefix}rpg help`,
+      },
+      { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+    );
+    return;
+  }
+
+  const ownerJid = resolveOwnerJid({ senderJid, senderIdentity });
+  if (!ownerJid) {
+    await sendAndStore(sock, remoteJid, { text: '❌ Não foi possível identificar o jogador para o RPG.' }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+    return;
+  }
+
+  try {
+    const result = await executeRpgPokemonAction({
+      ownerJid,
+      chatJid: remoteJid,
+      action,
+      actionArgs: args.slice(1),
+      mentionedJids: extractMentionedJids(messageInfo),
+      commandPrefix,
+    });
+
+    const responseText = result?.text || '❌ Não foi possível processar o comando RPG agora.';
+    const mentions = Array.isArray(result?.mentions) ? result.mentions.filter(Boolean) : [];
+    const imageBuffer = Buffer.isBuffer(result?.imageBuffer) ? result.imageBuffer : null;
+    const imageUrl = typeof result?.imageUrl === 'string' && result.imageUrl.trim() ? result.imageUrl.trim() : null;
+    const resultCaption = typeof result?.caption === 'string' && result.caption.trim() ? result.caption.trim() : null;
+    const caption = result?.preferResultCaption && resultCaption ? resultCaption : responseText;
+    const sendTextAfterImage = Boolean(result?.sendTextAfterImage);
+
+    if (imageBuffer) {
+      try {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            image: imageBuffer,
+            caption,
+            ...(mentions.length ? { mentions } : {}),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        if (sendTextAfterImage && responseText && responseText !== caption) {
+          await sendAndStore(sock, remoteJid, { text: responseText, ...(mentions.length ? { mentions } : {}) }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        }
+        return;
+      } catch (error) {
+        logger.warn('Falha ao enviar frame canvas do RPG Pokemon. Fallback para imagem URL/texto.', {
+          ownerJid,
+          action,
+          error: error.message,
+        });
+      }
+    }
+
+    if (imageUrl) {
+      try {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            image: { url: imageUrl },
+            caption,
+            ...(mentions.length ? { mentions } : {}),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        if (sendTextAfterImage && responseText && responseText !== caption) {
+          await sendAndStore(sock, remoteJid, { text: responseText, ...(mentions.length ? { mentions } : {}) }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        }
+        return;
+      } catch (error) {
+        logger.warn('Falha ao enviar imagem do RPG Pokemon. Enviando texto puro.', {
+          ownerJid,
+          action,
+          imageUrl,
+          error: error.message,
+        });
+      }
+    }
+
+    await sendAndStore(sock, remoteJid, { text: responseText, ...(mentions.length ? { mentions } : {}) }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+  } catch (error) {
+    logger.error('Erro no comando RPG Pokemon.', {
+      ownerJid,
+      action,
+      error: error.message,
+    });
+
+    await sendAndStore(sock, remoteJid, { text: '❌ Erro ao executar comando RPG. Tente novamente em instantes.' }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+  }
+};

package/app/modules/rpgPokemonModule/rpgPokemonConfigRuntime.js

@@ -0,0 +1,68 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { createModuleCommandConfigRuntime } from '../../services/ai/moduleCommandConfigRuntimeService.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CONFIG_PATH = path.join(__dirname, 'commandConfig.json');
+
+const DEFAULT_TEXTS = {
+  usage_header: '',
+};
+
+const runtime = createModuleCommandConfigRuntime({
+  configPath: CONFIG_PATH,
+  fallbackConfig: {
+    module: 'rpgPokemonModule',
+    commands: [],
+    textos: DEFAULT_TEXTS,
+  },
+});
+
+const renderUsageMethod = (method, commandPrefix) => String(method || '').replaceAll('<prefix>', String(commandPrefix || '/'));
+
+const resolveUsageLines = (entry, variant) => {
+  if (!entry || typeof entry !== 'object') return [];
+
+  const usageMessages = entry?.mensagens_uso && typeof entry.mensagens_uso === 'object' ? entry.mensagens_uso : null;
+
+  if (usageMessages) {
+    const variantKey = typeof variant === 'string' ? variant.trim() : '';
+    const picked = (variantKey && usageMessages[variantKey]) || usageMessages.default || null;
+    if (Array.isArray(picked)) {
+      return picked.filter(Boolean).map((value) => String(value));
+    }
+    if (typeof picked === 'string' && picked.trim()) {
+      return [picked.trim()];
+    }
+  }
+
+  const methods = Array.isArray(entry?.metodos_de_uso) ? entry.metodos_de_uso : [];
+  return methods.filter(Boolean).map((value) => String(value));
+};
+
+export const getRpgPokemonModuleConfig = () => runtime.getModuleConfig();
+
+export const resolveRpgPokemonCommandName = (command) => runtime.resolveCommandName(command);
+export const getRpgPokemonCommandEntry = (command) => runtime.getCommandEntry(command);
+export const listEnabledRpgPokemonCommands = () => runtime.listEnabledCommands();
+
+export const getRpgPokemonTextConfig = () => {
+  const config = getRpgPokemonModuleConfig();
+  const raw = config?.textos && typeof config.textos === 'object' ? config.textos : {};
+  return {
+    ...DEFAULT_TEXTS,
+    ...raw,
+  };
+};
+
+export const getRpgPokemonUsageText = (command, { commandPrefix = '/', header, variant } = {}) => {
+  const entry = getRpgPokemonCommandEntry(command);
+  const methods = resolveUsageLines(entry, variant);
+  if (!methods.length) return '';
+
+  const prefixHeader = typeof header === 'string' ? header : getRpgPokemonTextConfig().usage_header || DEFAULT_TEXTS.usage_header;
+  const lines = methods.map((method) => renderUsageMethod(method, commandPrefix));
+  return prefixHeader ? [prefixHeader, ...lines].join('\n') : lines.join('\n');
+};

package/app/modules/rpgPokemonModule/rpgPokemonDomain.js

@@ -0,0 +1,192 @@
+export const BIOME_KEYS = ['floresta', 'cidade', 'caverna'];
+
+export const BIOME_DEFINITIONS = {
+  floresta: {
+    key: 'floresta',
+    label: 'Floresta',
+    preferredTypes: ['grass', 'bug'],
+    preferredHabitats: ['forest', 'grassland'],
+  },
+  cidade: {
+    key: 'cidade',
+    label: 'Cidade',
+    preferredTypes: ['electric', 'normal'],
+    preferredHabitats: ['urban', 'rough-terrain'],
+  },
+  caverna: {
+    key: 'caverna',
+    label: 'Caverna',
+    preferredTypes: ['rock', 'ground'],
+    preferredHabitats: ['cave', 'mountain'],
+  },
+};
+
+export const MISSION_KEYS = {
+  EXPLORE: 'explorar',
+  WIN: 'vitorias',
+  CAPTURE: 'capturas',
+};
+
+export const DAILY_MISSION_TARGET = {
+  [MISSION_KEYS.EXPLORE]: 3,
+  [MISSION_KEYS.WIN]: 2,
+  [MISSION_KEYS.CAPTURE]: 1,
+};
+
+export const WEEKLY_MISSION_TARGET = {
+  [MISSION_KEYS.EXPLORE]: 20,
+  [MISSION_KEYS.WIN]: 12,
+  [MISSION_KEYS.CAPTURE]: 5,
+};
+
+export const DAILY_MISSION_REWARD = {
+  gold: 150,
+  xp: 120,
+  items: [{ key: 'potion', quantity: 1 }],
+};
+
+export const WEEKLY_MISSION_REWARD = {
+  gold: 800,
+  xp: 500,
+  items: [
+    { key: 'superpotion', quantity: 2 },
+    { key: 'pokeball', quantity: 2 },
+  ],
+};
+
+const toInt = (value, fallback = 0) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.trunc(parsed) : fallback;
+};
+
+const toDateOnly = (value) => {
+  if (!value) return null;
+  if (value instanceof Date) return value.toISOString().slice(0, 10);
+  return String(value).slice(0, 10);
+};
+
+const stableHash = (value) => {
+  const raw = String(value || '');
+  let hash = 0;
+  for (let i = 0; i < raw.length; i += 1) {
+    hash = (hash * 31 + raw.charCodeAt(i)) >>> 0;
+  }
+  return hash;
+};
+
+export const resolveBiomeFromKey = (biomeKey) => {
+  const key = String(biomeKey || '')
+    .trim()
+    .toLowerCase();
+  return BIOME_DEFINITIONS[key] || null;
+};
+
+export const resolveDefaultBiomeForGroup = (groupJid) => {
+  const index = stableHash(groupJid) % BIOME_KEYS.length;
+  const biomeKey = BIOME_KEYS[index];
+  return BIOME_DEFINITIONS[biomeKey];
+};
+
+export const resolveMissionRefs = (date = new Date()) => {
+  const year = date.getUTCFullYear();
+  const month = date.getUTCMonth();
+  const day = date.getUTCDate();
+  const today = new Date(Date.UTC(year, month, day));
+  const weekDay = today.getUTCDay();
+  const diffToMonday = weekDay === 0 ? 6 : weekDay - 1;
+  const monday = new Date(today);
+  monday.setUTCDate(today.getUTCDate() - diffToMonday);
+
+  return {
+    dailyRefDate: toDateOnly(today),
+    weeklyRefDate: toDateOnly(monday),
+  };
+};
+
+export const buildMissionProgressZero = () => ({
+  [MISSION_KEYS.EXPLORE]: 0,
+  [MISSION_KEYS.WIN]: 0,
+  [MISSION_KEYS.CAPTURE]: 0,
+});
+
+export const normalizeMissionProgress = (value) => {
+  const source = value && typeof value === 'object' ? value : {};
+  return {
+    [MISSION_KEYS.EXPLORE]: Math.max(0, toInt(source[MISSION_KEYS.EXPLORE], 0)),
+    [MISSION_KEYS.WIN]: Math.max(0, toInt(source[MISSION_KEYS.WIN], 0)),
+    [MISSION_KEYS.CAPTURE]: Math.max(0, toInt(source[MISSION_KEYS.CAPTURE], 0)),
+  };
+};
+
+export const isMissionCompleted = (progress, target) => {
+  return progress[MISSION_KEYS.EXPLORE] >= target[MISSION_KEYS.EXPLORE] && progress[MISSION_KEYS.WIN] >= target[MISSION_KEYS.WIN] && progress[MISSION_KEYS.CAPTURE] >= target[MISSION_KEYS.CAPTURE];
+};
+
+export const resolveMissionStateForRefs = ({ ownerJid, row, refs }) => {
+  const normalized = {
+    owner_jid: ownerJid,
+    daily_ref_date: toDateOnly(row?.daily_ref_date) || refs.dailyRefDate,
+    weekly_ref_date: toDateOnly(row?.weekly_ref_date) || refs.weeklyRefDate,
+    daily_progress_json: normalizeMissionProgress(row?.daily_progress_json),
+    weekly_progress_json: normalizeMissionProgress(row?.weekly_progress_json),
+    daily_claimed_at: row?.daily_claimed_at || null,
+    weekly_claimed_at: row?.weekly_claimed_at || null,
+  };
+
+  let dirty = false;
+  if (normalized.daily_ref_date !== refs.dailyRefDate) {
+    normalized.daily_ref_date = refs.dailyRefDate;
+    normalized.daily_progress_json = buildMissionProgressZero();
+    normalized.daily_claimed_at = null;
+    dirty = true;
+  }
+
+  if (normalized.weekly_ref_date !== refs.weeklyRefDate) {
+    normalized.weekly_ref_date = refs.weeklyRefDate;
+    normalized.weekly_progress_json = buildMissionProgressZero();
+    normalized.weekly_claimed_at = null;
+    dirty = true;
+  }
+
+  return {
+    normalized,
+    dirty,
+  };
+};
+
+export const resolveVictoryRewards = (battleSnapshot) => {
+  const enemyLevel = Math.max(1, toInt(battleSnapshot?.enemy?.level, 1));
+  const growthRate = String(battleSnapshot?.enemy?.growthRate || '')
+    .trim()
+    .toLowerCase();
+  const isGymBattle = battleSnapshot?.mode === 'gym';
+
+  const growthMultiplier = growthRate === 'slow' ? 1.12 : growthRate === 'fast' ? 0.92 : growthRate === 'medium slow' ? 1.06 : 1;
+
+  const rewards = {
+    playerXp: Math.max(1, Math.round(enemyLevel * 14 * growthMultiplier)),
+    pokemonXp: Math.max(1, Math.round(enemyLevel * 20 * growthMultiplier)),
+    gold: Math.max(40, Math.round(enemyLevel * 12 * growthMultiplier)),
+    items: [],
+  };
+
+  if (isGymBattle) {
+    rewards.playerXp = Math.round(rewards.playerXp * 2.2);
+    rewards.pokemonXp = Math.round(rewards.pokemonXp * 2);
+    rewards.gold = Math.round(rewards.gold * 2.3);
+    rewards.items.push({ key: 'pokeball', quantity: 1 });
+  }
+
+  return rewards;
+};
+
+export const __testablesRpgPokemonDomain = {
+  resolveBiomeFromKey,
+  resolveDefaultBiomeForGroup,
+  resolveMissionRefs,
+  buildMissionProgressZero,
+  normalizeMissionProgress,
+  isMissionCompleted,
+  resolveMissionStateForRefs,
+  resolveVictoryRewards,
+};

package/app/modules/rpgPokemonModule/rpgPokemonDomain.test.js

@@ -0,0 +1,93 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { __testablesRpgPokemonDomain } from './rpgPokemonDomain.js';
+
+const { resolveBiomeFromKey, resolveDefaultBiomeForGroup, resolveMissionRefs, buildMissionProgressZero, normalizeMissionProgress, isMissionCompleted, resolveMissionStateForRefs, resolveVictoryRewards } = __testablesRpgPokemonDomain;
+
+test('bioma deve ser resolvido por chave e mapeamento de grupo deve ser determinístico', () => {
+  const cidade = resolveBiomeFromKey('cidade');
+  assert.equal(cidade?.key, 'cidade');
+  assert.deepEqual(cidade?.preferredTypes, ['electric', 'normal']);
+
+  const first = resolveDefaultBiomeForGroup('120363000000000000@g.us');
+  const second = resolveDefaultBiomeForGroup('120363000000000000@g.us');
+  assert.equal(first?.key, second?.key);
+});
+
+test('missões: referência diária/semanal deve usar dia UTC e início da semana na segunda', () => {
+  const refs = resolveMissionRefs(new Date(Date.UTC(2026, 1, 10, 15, 30, 0)));
+  assert.equal(refs.dailyRefDate, '2026-02-10');
+  assert.equal(refs.weeklyRefDate, '2026-02-09');
+
+  const sundayRefs = resolveMissionRefs(new Date(Date.UTC(2026, 1, 8, 5, 0, 0)));
+  assert.equal(sundayRefs.dailyRefDate, '2026-02-08');
+  assert.equal(sundayRefs.weeklyRefDate, '2026-02-02');
+});
+
+test('missões: reset diário/semanal deve limpar progresso e claimed quando muda referência', () => {
+  const refs = {
+    dailyRefDate: '2026-02-10',
+    weeklyRefDate: '2026-02-09',
+  };
+
+  const row = {
+    daily_ref_date: '2026-02-09',
+    daily_progress_json: { explorar: 3, vitorias: 2, capturas: 1 },
+    daily_claimed_at: '2026-02-09T20:00:00.000Z',
+    weekly_ref_date: '2026-02-02',
+    weekly_progress_json: { explorar: 20, vitorias: 12, capturas: 5 },
+    weekly_claimed_at: '2026-02-05T20:00:00.000Z',
+  };
+
+  const result = resolveMissionStateForRefs({
+    ownerJid: 'player@s.whatsapp.net',
+    row,
+    refs,
+  });
+
+  assert.equal(result.dirty, true);
+  assert.deepEqual(result.normalized.daily_progress_json, buildMissionProgressZero());
+  assert.deepEqual(result.normalized.weekly_progress_json, buildMissionProgressZero());
+  assert.equal(result.normalized.daily_claimed_at, null);
+  assert.equal(result.normalized.weekly_claimed_at, null);
+});
+
+test('missões: normalização e conclusão devem refletir metas preenchidas', () => {
+  const normalized = normalizeMissionProgress({
+    explorar: '3',
+    vitorias: 2,
+    capturas: 1,
+  });
+
+  assert.deepEqual(normalized, {
+    explorar: 3,
+    vitorias: 2,
+    capturas: 1,
+  });
+
+  assert.equal(
+    isMissionCompleted(normalized, {
+      explorar: 3,
+      vitorias: 2,
+      capturas: 1,
+    }),
+    true,
+  );
+});
+
+test('ginásio deve ter recompensa superior e item bônus em relação à batalha selvagem', () => {
+  const wild = resolveVictoryRewards({
+    mode: 'wild',
+    enemy: { level: 10 },
+  });
+  const gym = resolveVictoryRewards({
+    mode: 'gym',
+    enemy: { level: 10 },
+  });
+
+  assert.ok(gym.playerXp > wild.playerXp);
+  assert.ok(gym.pokemonXp > wild.pokemonXp);
+  assert.ok(gym.gold > wild.gold);
+  assert.deepEqual(gym.items, [{ key: 'pokeball', quantity: 1 }]);
+});

package/app/modules/rpgPokemonModule/rpgPokemonEvolution.test.js

@@ -0,0 +1,46 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { registerEvolutionPokedexEntry } from './rpgEvolutionUtils.js';
+
+test('atualização de Pokédex deve ser ignorada quando não há evolução válida', async () => {
+  let called = 0;
+  const registerEntry = async () => {
+    called += 1;
+  };
+
+  const changed = await registerEvolutionPokedexEntry({
+    ownerJid: '5511999999999@s.whatsapp.net',
+    evolutionOutcome: null,
+    registerEntry,
+  });
+
+  assert.equal(changed, false);
+  assert.equal(called, 0);
+});
+
+test('atualização de Pokédex deve registrar pokeId evoluído', async () => {
+  const calls = [];
+  const registerEntry = async (payload, connection) => {
+    calls.push({ payload, connection });
+  };
+
+  const changed = await registerEvolutionPokedexEntry({
+    ownerJid: '5511888888888@s.whatsapp.net',
+    evolutionOutcome: {
+      updatePayload: {
+        pokeId: 6,
+      },
+    },
+    connection: { tx: true },
+    registerEntry,
+  });
+
+  assert.equal(changed, true);
+  assert.equal(calls.length, 1);
+  assert.deepEqual(calls[0].payload, {
+    ownerJid: '5511888888888@s.whatsapp.net',
+    pokeId: 6,
+  });
+  assert.deepEqual(calls[0].connection, { tx: true });
+});